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.1.1.1 by cebix, 1999-10-04T19:31:09Z vs.
Revision 1.21 by cebix, 2012-06-19T22:23:25Z

#	Line 1 | Line 1
1		/*
2	<	*  mon_cmd.cpp - mon standard commands
2	>	*  mon_cmd.cpp - cxmon standard commands
3		*
4	<	*  (C) 1997-1999 Christian Bauer
4	>	*  cxmon (C) 1997-2004 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"
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 26 | 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 53 | 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 *&str, uintptr &len)
71		{
72	<	uint32 value;
72	>	uintptr value;
73
74	+	static const int GRANULARITY = 16; // must be a power of 2
75	+	str = NULL;
76		len = 0;
77		goto start;
78
#	Line 66 | Line 82 | static bool byte_string(uint8 *s, uint32
82
83		start:
84		if (mon_token == T_STRING) {
85	<	uint8 *p = (uint8 *)mon_string;
86	<	while ((*s++ = *p++) != 0) ;
87	<	s--;
88	<	len += strlen(mon_string);
85	>	unsigned n = strlen(mon_string);
86	>	str = (uint8 *)realloc(str, (len + n - 1 + GRANULARITY) & ~(GRANULARITY - 1));
87	>	memcpy(str + len, mon_string, n);
88	>	len += n;
89		mon_get_token();
90		} else if (mon_expression(&value)) {
91	<	*s++ = value;
91	>	str = (uint8 *)realloc(str, (len + GRANULARITY) & ~(GRANULARITY - 1));
92	>	str[len] = value;
93		len++;
94	<	} else
94	>	} else {
95	>	if (str)
96	>	free(str);
97		return false;
98	+	}
99
100	<	} else if (mon_token == T_END)
100	>	} else if (mon_token == T_END) {
101		return true;
102	<	else {
102	>	} else {
103		mon_error("',' expected");
104	+	if (str)
105	+	free(str);
106		return false;
107		}
108		}
#	Line 104 | Line 126 | static inline uint8 char2print(uint8 c)
126
127		void version(void)
128		{
129	<	fprintf(monout, "mon V%d.%d\n", MON_VERSION, MON_REVISION);
129	>	fprintf(monout, "cxmon V" VERSION "\n");
130		}
131
132
#	Line 147 | Line 169 | void redir_output(void)
169
170		void print_expr(void)
171		{
172	<	uint32 val;
172	>	uintptr val;
173
174		if (!mon_expression(&val))
175		return;
#	Line 157 | Line 179 | void print_expr(void)
179		}
180
181		if (val > 0x7fffffff) {
182	<	fprintf(monout, "Hex unsigned:  $%08lx\n"
183	<	"Hex signed  : -$%08lx\n"
184	<	"Dec unsigned:  %lu\n"
185	<	"Dec signed  : %ld\n", val, -val, val, val);
182	>	fprintf(monout, "Hex unsigned:  $%08x\n"
183	>	"Hex signed  : -$%08x\n"
184	>	"Dec unsigned:  %u\n"
185	>	"Dec signed  : %d\n", val, -val, val, val);
186		fprintf(monout, "Char        : '%c%c%c%c'\n", char2print(val >> 24), char2print(val >> 16), char2print(val >> 8), char2print(val));
187		} else {
188	<	fprintf(monout, "Hex : $%08lx\n"
189	<	"Dec : %ld\n", val, val);
188	>	fprintf(monout, "Hex : $%08x\n"
189	>	"Dec : %d\n", val, val);
190		fprintf(monout, "Char: '%c%c%c%c'\n", char2print(val >> 24), char2print(val >> 16), char2print(val >> 8), char2print(val));
191		}
192		}
#	Line 199 | Line 221 | void shell_command(void)
221
222		void memory_dump(void)
223		{
224	<	uint32 adr, end_adr;
224	>	uintptr adr, end_adr;
225		uint8 mem[MEMDUMP_BPL + 1];
226
227		mem[MEMDUMP_BPL] = 0;
#	Line 208 | Line 230 | void memory_dump(void)
230		return;
231
232		while (adr <= end_adr && !mon_aborted()) {
233	<	fprintf(monout, "%08lx:", mon_use_real_mem ? adr: adr % mon_mem_size);
233	>	fprintf(monout, "%0*lx:", int(2 * sizeof(adr)), mon_use_real_mem ? adr: adr % mon_mem_size);
234		for (int i=0; i<MEMDUMP_BPL; i++, adr++) {
235		if (i % 4 == 0)
236	<	fprintf(monout, " %08lx", mon_read_word(adr));
236	>	fprintf(monout, " %08x", mon_read_word(adr));
237		mem[i] = char2print(mon_read_byte(adr));
238		}
239		fprintf(monout, "  '%s'\n", mem);
#	Line 230 | Line 252 | void memory_dump(void)
252
253		void ascii_dump(void)
254		{
255	<	uint32 adr, end_adr;
255	>	uintptr adr, end_adr;
256		uint8 str[ASCIIDUMP_BPL + 1];
257
258		str[ASCIIDUMP_BPL] = 0;
#	Line 239 | Line 261 | void ascii_dump(void)
261		return;
262
263		while (adr <= end_adr && !mon_aborted()) {
264	<	fprintf(monout, "%08lx:", mon_use_real_mem ? adr : adr % mon_mem_size);
264	>	fprintf(monout, "%0*lx:", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
265		for (int i=0; i<ASCIIDUMP_BPL; i++, adr++)
266		str[i] = char2print(mon_read_byte(adr));
267		fprintf(monout, " '%s'\n", str);
#	Line 250 | Line 272 | void ascii_dump(void)
272
273
274		/*
275	+	*  Binary dump
276	+	*  b [start [end]]
277	+	*/
278	+
279	+	void binary_dump(void)
280	+	{
281	+	uintptr adr, end_adr;
282	+	uint8 str[9];
283	+
284	+	str[8] = 0;
285	+
286	+	if (!range_args(&adr, &end_adr, 7))  // 8 lines unless end address specified
287	+	return;
288	+
289	+	while (adr <= end_adr && !mon_aborted()) {
290	+	fprintf(monout, "%0*lx:", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
291	+	uint8 b = mon_read_byte(adr);
292	+	for (int m=0x80, i=0; i<8; m>>=1, i++)
293	+	str[i] = (b & m) ? '*' : '.';
294	+	fprintf(monout, " '%s'\n", str);
295	+	adr++;
296	+	}
297	+
298	+	mon_dot_address = adr;
299	+	}
300	+
301	+
302	+	/*
303		*  Disassemble
304		*  d [start [end]]
305		*  d65 [start [end]]
306		*  d68 [start [end]]
307		*  d80 [start [end]]
308		*  d86 [start [end]]
309	+	*  d8086 [start [end]]
310		*/
311
312		enum CPUType {
313		CPU_PPC,
314		CPU_6502,
315		CPU_680x0,
316	<	CPU_8080,
317	<	CPU_80x86
316	>	CPU_Z80,
317	>	CPU_80x86_32,
318	>	CPU_80x86_16,
319	>	CPU_x86_64,
320	>	CPU_MIPS,
321	>	CPU_MIPS_LITTLE,
322		};
323
324		static void disassemble(CPUType type)
325		{
326	<	uint32 adr, end_adr;
326	>	uintptr adr, end_adr;
327
328		if (!range_args(&adr, &end_adr, 16 * 4 - 1))  // 16 lines unless end address specified
329		return;
#	Line 277 | Line 332 | static void disassemble(CPUType type)
332		case CPU_PPC:
333		while (adr <= end_adr && !mon_aborted()) {
334		uint32 w = mon_read_word(adr);
335	<	fprintf(monout, "%08lx: %08lx\t", mon_use_real_mem ? adr : adr % mon_mem_size, w);
335	>	fprintf(monout, "%0*lx: %08x\t", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size, w);
336		disass_ppc(monout, mon_use_real_mem ? adr : adr % mon_mem_size, w);
337		adr += 4;
338		}
#	Line 288 | Line 343 | static void disassemble(CPUType type)
343		uint8 op = mon_read_byte(adr);
344		uint8 lo = mon_read_byte(adr + 1);
345		uint8 hi = mon_read_byte(adr + 2);
346	<	fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
346	>	fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
347		adr += disass_6502(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
348		}
349		break;
350
351		case CPU_680x0:
352		while (adr <= end_adr && !mon_aborted()) {
353	<	uint16 buf[8];
354	<	buf[0] = mon_read_half(adr);
300	<	buf[1] = mon_read_half(adr + 2);
301	<	buf[2] = mon_read_half(adr + 4);
302	<	buf[3] = mon_read_half(adr + 6);
303	<	buf[4] = mon_read_half(adr + 8);
304	<	buf[5] = mon_read_half(adr + 10);
305	<	buf[6] = mon_read_half(adr + 12);
306	<	buf[7] = mon_read_half(adr + 14);
307	<	fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
308	<	adr += disass_68k(monout, mon_use_real_mem ? adr : adr % mon_mem_size, buf);
353	>	fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
354	>	adr += disass_68k(monout, mon_use_real_mem ? adr : adr % mon_mem_size);
355		}
356		break;
357
358	<	case CPU_8080:
358	>	case CPU_Z80:
359		while (adr <= end_adr && !mon_aborted()) {
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);
364	<	adr += disass_8080(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
360	>	fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
361	>	adr += disass_z80(monout, mon_use_real_mem ? adr : adr % mon_mem_size);
362	>	}
363	>	break;
364	>
365	>	case CPU_MIPS:
366	>	case CPU_MIPS_LITTLE:
367	>	while (adr <= end_adr && !mon_aborted()) {
368	>	fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
369	>	adr += disass_mips(monout, mon_use_real_mem ? adr : adr % mon_mem_size, type == CPU_MIPS_LITTLE);
370	>	}
371	>	break;
372	>
373	>	case CPU_x86_64:
374	>	while (adr <= end_adr && !mon_aborted()) {
375	>	fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
376	>	adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 64);
377		}
378		break;
379
380	<	case CPU_80x86:
380	>	case CPU_80x86_32:
381		while (adr <= end_adr && !mon_aborted()) {
382	<	uint8 buf[16];
383	<	for (int i=0; i<16; i++)
326	<	buf[i] = mon_read_byte(adr + i);
327	<	fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
328	<	adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, buf);
382	>	fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
383	>	adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 32);
384		}
385		break;
386	+
387	+	case CPU_80x86_16:
388	+	while (adr <= end_adr && !mon_aborted()) {
389	+	fprintf(monout, "%0*lx: ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
390	+	adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 16);
391	+	}
392		}
393
394		mon_dot_address = adr;
#	Line 348 | Line 409 | void disassemble_680x0(void)
409		disassemble(CPU_680x0);
410		}
411
412	<	void disassemble_8080(void)
412	>	void disassemble_z80(void)
413	>	{
414	>	disassemble(CPU_Z80);
415	>	}
416	>
417	>	void disassemble_80x86_32(void)
418	>	{
419	>	disassemble(CPU_80x86_32);
420	>	}
421	>
422	>	void disassemble_80x86_16(void)
423	>	{
424	>	disassemble(CPU_80x86_16);
425	>	}
426	>
427	>	void disassemble_x86_64(void)
428	>	{
429	>	disassemble(CPU_x86_64);
430	>	}
431	>
432	>	void disassemble_mips(void)
433		{
434	<	disassemble(CPU_8080);
434	>	disassemble(CPU_MIPS);
435		}
436
437	<	void disassemble_80x86(void)
437	>	void disassemble_mipsel(void)
438		{
439	<	disassemble(CPU_80x86);
439	>	disassemble(CPU_MIPS_LITTLE);
440		}
441
442
#	Line 366 | Line 447 | void disassemble_80x86(void)
447
448		void modify(void)
449		{
450	<	uint32 adr, len, src_adr = 0;
451	<	uint8 str[256];
450	>	uintptr adr, len, src_adr = 0;
451	>	uint8 *str;
452
453		if (!mon_expression(&adr))
454		return;
#	Line 376 | Line 457 | void modify(void)
457
458		while (src_adr < len)
459		mon_write_byte(adr++, str[src_adr++]);
379	–
460		mon_dot_address = adr;
461	+
462	+	free(str);
463		}
464
465
#	Line 388 | Line 470 | void modify(void)
470
471		void fill(void)
472		{
473	<	uint32 adr, end_adr, len, src_adr = 0;
474	<	uint8 str[256];
473	>	uintptr adr, end_adr, len, src_adr = 0;
474	>	uint8 *str;
475
476		if (!mon_expression(&adr))
477		return;
#	Line 398 | Line 480 | void fill(void)
480		if (!byte_string(str, len))
481		return;
482
483	<	while (adr <= end_adr)
484	<	mon_write_byte(adr++, str[src_adr++ % len]);
483	>	if (len) {
484	>	while (adr <= end_adr)
485	>	mon_write_byte(adr++, str[src_adr++ % len]);
486	>	}
487	>
488	>	free(str);
489		}
490
491
#	Line 410 | Line 496 | void fill(void)
496
497		void transfer(void)
498		{
499	<	uint32 adr, end_adr, dest;
499	>	uintptr adr, end_adr, dest;
500		int num;
501
502		if (!mon_expression(&adr))
#	Line 444 | Line 530 | void transfer(void)
530
531		void compare(void)
532		{
533	<	uint32 adr, end_adr, dest;
533	>	uintptr adr, end_adr, dest;
534		int num = 0;
535
536		if (!mon_expression(&adr))
#	Line 460 | Line 546 | void compare(void)
546
547		while (adr <= end_adr && !mon_aborted()) {
548		if (mon_read_byte(adr) != mon_read_byte(dest)) {
549	<	fprintf(monout, "%08lx ", mon_use_real_mem ? adr : adr % mon_mem_size);
549	>	fprintf(monout, "%0*lx ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
550		num++;
551		if (!(num & 7))
552		fputc('\n', monout);
#	Line 481 | Line 567 | void compare(void)
567
568		void hunt(void)
569		{
570	<	uint32 adr, end_adr, len;
571	<	uint8 str[256];
570	>	uintptr adr, end_adr, len;
571	>	uint8 *str;
572		int num = 0;
573
574		if (!mon_expression(&adr))
#	Line 500 | Line 586 | void hunt(void)
586		break;
587
588		if (i == len) {
589	<	fprintf(monout, "%08lx ", mon_use_real_mem ? adr : adr % mon_mem_size);
589	>	fprintf(monout, "%0*lx ", int(2 * sizeof(adr)), mon_use_real_mem ? adr : adr % mon_mem_size);
590		num++;
591		if (num == 1)
592		mon_dot_address = adr;
#	Line 510 | Line 596 | void hunt(void)
596		adr++;
597		}
598
599	+	free(str);
600	+
601		if (num & 7)
602		fputc('\n', monout);
603		fprintf(monout, "Found %d occurrences\n", num);
#	Line 523 | Line 611 | void hunt(void)
611
612		void load_data(void)
613		{
614	<	uint32 start_adr;
614	>	uintptr start_adr;
615		FILE *file;
616		int fc;
617
#	Line 546 | Line 634 | void load_data(void)
634		if (!(file = fopen(mon_string, "rb")))
635		mon_error("Unable to open file");
636		else {
637	<	uint32 adr = start_adr;
637	>	uintptr adr = start_adr;
638
639		while ((fc = fgetc(file)) != EOF)
640		mon_write_byte(adr++, fc);
641		fclose(file);
642
643	<	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);
643	>	fprintf(monerr, "%08x bytes read from %0*lx to %0*lx\n", adr - start_adr, int(2 * sizeof(adr)), mon_use_real_mem ? start_adr : start_adr % mon_mem_size, int(2 * sizeof(adr)), mon_use_real_mem ? adr-1 : (adr-1) % mon_mem_size);
644		mon_dot_address = adr;
645		}
646		}
#	Line 565 | Line 653 | void load_data(void)
653
654		void save_data(void)
655		{
656	<	uint32 start_adr, size;
656	>	uintptr start_adr, size;
657		FILE *file;
658
659		if (!mon_expression(&start_adr))
#	Line 589 | Line 677 | void save_data(void)
677		if (!(file = fopen(mon_string, "wb")))
678		mon_error("Unable to create file");
679		else {
680	<	uint32 adr = start_adr, end_adr = start_adr + size - 1;
680	>	uintptr adr = start_adr, end_adr = start_adr + size - 1;
681
682		while (adr <= end_adr)
683		fputc(mon_read_byte(adr++), file);
684		fclose(file);
685
686	<	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);
686	>	fprintf(monerr, "%08x bytes written from %0*lx to %0*lx\n", size, int(2 * sizeof(adr)), mon_use_real_mem ? start_adr : start_adr % mon_mem_size, int(2 * sizeof(adr)), mon_use_real_mem ? end_adr : end_adr % mon_mem_size);
687		}
688		}

Diff Legend

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