mon/src/mon_cmd.cpp

/*
 *  mon_cmd.cpp - cxmon standard commands
 *
 *  cxmon (C) 1997-1999 Christian Bauer, Marc Hellwig
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "sysdeps.h"

#include <stdlib.h>

#include "mon.h"
#include "mon_cmd.h"
#include "mon_disass.h"

#ifndef VERSION
#define VERSION "2"
#endif


/*
 *  range_args = [expression] [[COMMA] expression] END
 *
 *  Read start address to "adr", end address to "end_adr".
 *  "adr" defaults to '.', "end_adr" defaults to '.'+def_range
 *
 *  true: OK, false: Error
 */

static bool range_args(uint32 *adr, uint32 *end_adr, uint32 def_range)
{
        *adr = mon_dot_address;
        *end_adr = mon_dot_address + def_range;

        if (mon_token == T_END)
                return true;
        else {
                if (!mon_expression(adr))
                        return false;
                *end_adr = *adr + def_range;
                if (mon_token == T_END)
                        return true;
                else {
                        if (mon_token == T_COMMA) mon_get_token();
                        if (!mon_expression(end_adr))
                                return false;
                        return mon_token == T_END;
                }
        }
}


/*
 *  byte_string = (expression | STRING) {COMMA (expression | STRING)} END
 */

static bool byte_string(uint8 *s, uint32 &len)
{
        uint32 value;

        len = 0;
        goto start;

        for (;;) {
                if (mon_token == T_COMMA) {
                        mon_get_token();

start:
                        if (mon_token == T_STRING) {
                                uint8 *p = (uint8 *)mon_string;
                                while ((*s++ = *p++) != 0) ;
                                s--;
                                len += strlen(mon_string);
                                mon_get_token();
                        } else if (mon_expression(&value)) {
                                *s++ = value;
                                len++;
                        } else
                                return false;

                } else if (mon_token == T_END)
                        return true;
                else {
                        mon_error("',' expected");
                        return false;
                }
        }
}


/*
 *  Convert character to printable character
 */

static inline uint8 char2print(uint8 c)
{
        return (c >= 0x20 && c <= 0x7e) ? c : '.';
}


/*
 *  Show version
 *  ver
 */

void version(void)
{
        fprintf(monout, "mon V" VERSION "\n");
}


/*
 *  Redirect output
 *  o [file]
 */

void redir_output(void)
{
        // Close old file
        if (monout != monerr) {
                fclose(monout);
                monout = monerr;
                return;
        }

        // No argument given?
        if (mon_token == T_END)
                return;

        // Otherwise open file
        if (mon_token == T_STRING) {
                mon_get_token();
                if (mon_token != T_END) {
                        mon_error("Too many arguments");
                        return;
                }
                if (!(monout = fopen(mon_string, "w")))
                        mon_error("Unable to open file");
        } else
                mon_error("'\"' around file name expected");
}


/*
 *  Compute and display expression
 *  ? expression
 */

void print_expr(void)
{
        uint32 val;

        if (!mon_expression(&val))
                return;
        if (mon_token != T_END) {
                mon_error("Too many arguments");
                return;
        }

        if (val > 0x7fffffff) {
                fprintf(monout, "Hex unsigned:  $%08x\n"
                                          "Hex signed  : -$%08x\n"
                                          "Dec unsigned:  %u\n"
                                          "Dec signed  : %d\n", val, -val, val, val);
                fprintf(monout, "Char        : '%c%c%c%c'\n", char2print(val >> 24), char2print(val >> 16), char2print(val >> 8), char2print(val));
        } else {
                fprintf(monout, "Hex : $%08x\n"
                                          "Dec : %d\n", val, val);
                fprintf(monout, "Char: '%c%c%c%c'\n", char2print(val >> 24), char2print(val >> 16), char2print(val >> 8), char2print(val));
        }
}


/*
 *  Execute shell command
 *  \ "command"
 */

void shell_command(void)
{
        if (mon_token != T_STRING) {
                mon_error("'\"' around command expected");
                return;
        }
        mon_get_token();
        if (mon_token != T_END) {
                mon_error("Too many arguments");
                return;
        }
        system(mon_string);
}


/*
 *  Memory dump
 *  m [start [end]]
 */

#define MEMDUMP_BPL 16  // Bytes per line

void memory_dump(void)
{
        uint32 adr, end_adr;
        uint8 mem[MEMDUMP_BPL + 1];

        mem[MEMDUMP_BPL] = 0;

        if (!range_args(&adr, &end_adr, 16 * MEMDUMP_BPL - 1))  // 16 lines unless end address specified
                return;

        while (adr <= end_adr && !mon_aborted()) {
                fprintf(monout, "%08x:", mon_use_real_mem ? adr: adr % mon_mem_size);
                for (int i=0; i<MEMDUMP_BPL; i++, adr++) {
                        if (i % 4 == 0)
                                fprintf(monout, " %08x", mon_read_word(adr));
                        mem[i] = char2print(mon_read_byte(adr));
                }
                fprintf(monout, "  '%s'\n", mem);
        }

        mon_dot_address = adr;
}


/*
 *  ASCII dump
 *  i [start [end]]
 */

#define ASCIIDUMP_BPL 64  // Bytes per line

void ascii_dump(void)
{
        uint32 adr, end_adr;
        uint8 str[ASCIIDUMP_BPL + 1];

        str[ASCIIDUMP_BPL] = 0;

        if (!range_args(&adr, &end_adr, 16 * ASCIIDUMP_BPL - 1))  // 16 lines unless end address specified
                return;

        while (adr <= end_adr && !mon_aborted()) {
                fprintf(monout, "%08x:", mon_use_real_mem ? adr : adr % mon_mem_size);
                for (int i=0; i<ASCIIDUMP_BPL; i++, adr++)
                        str[i] = char2print(mon_read_byte(adr));
                fprintf(monout, " '%s'\n", str);
        }

        mon_dot_address = adr;
}


/*
 *  Binary dump
 *  b [start [end]]
 */

void binary_dump(void)
{
        uint32 adr, end_adr;
        uint8 str[9];

        str[8] = 0;

        if (!range_args(&adr, &end_adr, 7))  // 8 lines unless end address specified
                return;

        while (adr <= end_adr && !mon_aborted()) {
                fprintf(monout, "%08x:", mon_use_real_mem ? adr : adr % mon_mem_size);
                uint8 b = mon_read_byte(adr);
                for (int m=0x80, i=0; i<8; m>>=1, i++)
                        str[i] = (b & m) ? '*' : '.';
                fprintf(monout, " '%s'\n", str);
                adr++;
        }

        mon_dot_address = adr;
}


/*
 *  Disassemble
 *  d [start [end]]
 *  d65 [start [end]]
 *  d68 [start [end]]
 *  d80 [start [end]]
 *  d86 [start [end]]
 *  d8086 [start [end]]
 */

enum CPUType {
        CPU_PPC,
        CPU_6502,
        CPU_680x0,
        CPU_Z80,
        CPU_80x86_32,
        CPU_80x86_16
};

static void disassemble(CPUType type)
{
        uint32 adr, end_adr;

        if (!range_args(&adr, &end_adr, 16 * 4 - 1))  // 16 lines unless end address specified
                return;

        switch (type) {
                case CPU_PPC:
                        while (adr <= end_adr && !mon_aborted()) {
                                uint32 w = mon_read_word(adr);
                                fprintf(monout, "%08x: %08x\t", mon_use_real_mem ? adr : adr % mon_mem_size, w);
                                disass_ppc(monout, mon_use_real_mem ? adr : adr % mon_mem_size, w);
                                adr += 4;
                        }
                        break;

                case CPU_6502:
                        while (adr <= end_adr && !mon_aborted()) {
                                uint8 op = mon_read_byte(adr);
                                uint8 lo = mon_read_byte(adr + 1);
                                uint8 hi = mon_read_byte(adr + 2);
                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
                                adr += disass_6502(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
                        }
                        break;

                case CPU_680x0:
                        while (adr <= end_adr && !mon_aborted()) {
                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
                                adr += disass_68k(monout, mon_use_real_mem ? adr : adr % mon_mem_size);
                        }
                        break;

                case CPU_Z80:
                        while (adr <= end_adr && !mon_aborted()) {
                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
                                adr += disass_z80(monout, mon_use_real_mem ? adr : adr % mon_mem_size);
                        }
                        break;

                case CPU_80x86_32:
                        while (adr <= end_adr && !mon_aborted()) {
                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, false);
                        }
                        break;

                case CPU_80x86_16:
                        while (adr <= end_adr && !mon_aborted()) {
                                fprintf(monout, "%08x: ", mon_use_real_mem ? adr : adr % mon_mem_size);
                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, true);
                        }
                        break;
        }

        mon_dot_address = adr;
}

void disassemble_ppc(void)
{
        disassemble(CPU_PPC);
}

void disassemble_6502(void)
{
        disassemble(CPU_6502);
}

void disassemble_680x0(void)
{
        disassemble(CPU_680x0);
}

void disassemble_z80(void)
{
        disassemble(CPU_Z80);
}

void disassemble_80x86_32(void)
{
        disassemble(CPU_80x86_32);
}

void disassemble_80x86_16(void)
{
        disassemble(CPU_80x86_16);
}


/*
 *  Modify memory
 *  : addr bytestring
 */

void modify(void)
{
        uint32 adr, len, src_adr = 0;
        uint8 str[256];

        if (!mon_expression(&adr))
                return;
        if (!byte_string(str, len))
                return;

        while (src_adr < len)
                mon_write_byte(adr++, str[src_adr++]);

        mon_dot_address = adr;
}


/*
 *  Fill
 *  f start end bytestring
 */

void fill(void)
{
        uint32 adr, end_adr, len, src_adr = 0;
        uint8 str[256];

        if (!mon_expression(&adr))
                return;
        if (!mon_expression(&end_adr))
                return;
        if (!byte_string(str, len))
                return;

        while (adr <= end_adr)
                mon_write_byte(adr++, str[src_adr++ % len]);
}


/*
 *  Transfer memory
 *  t start end dest
 */

void transfer(void)
{
        uint32 adr, end_adr, dest;
        int num;

        if (!mon_expression(&adr))
                return;
        if (!mon_expression(&end_adr))
                return;
        if (!mon_expression(&dest))
                return;
        if (mon_token != T_END) {
                mon_error("Too many arguments");
                return;
        }

        num = end_adr - adr + 1;

        if (dest < adr)
                for (int i=0; i<num; i++)
                        mon_write_byte(dest++, mon_read_byte(adr++));
        else {
                dest += end_adr - adr;
                for (int i=0; i<num; i++)
                        mon_write_byte(dest--, mon_read_byte(end_adr--));
        }
}


/*
 *  Compare
 *  c start end dest
 */

void compare(void)
{
        uint32 adr, end_adr, dest;
        int num = 0;

        if (!mon_expression(&adr))
                return;
        if (!mon_expression(&end_adr))
                return;
        if (!mon_expression(&dest))
                return;
        if (mon_token != T_END) {
                mon_error("Too many arguments");
                return;
        }

        while (adr <= end_adr && !mon_aborted()) {
                if (mon_read_byte(adr) != mon_read_byte(dest)) {
                        fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
                        num++;
                        if (!(num & 7))
                                fputc('\n', monout);
                }
                adr++; dest++;
        }

        if (num & 7)
                fputc('\n', monout);
        fprintf(monout, "%d byte(s) different\n", num);
}


/*
 *  Search for byte string
 *  h start end bytestring
 */

void hunt(void)
{
        uint32 adr, end_adr, len;
        uint8 str[256];
        int num = 0;

        if (!mon_expression(&adr))
                return;
        if (!mon_expression(&end_adr))
                return;
        if (!byte_string(str, len))
                return;

        while ((adr+len-1) <= end_adr && !mon_aborted()) {
                uint32 i;

                for (i=0; i<len; i++)
                        if (mon_read_byte(adr + i) != str[i])
                                break;

                if (i == len) {
                        fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
                        num++;
                        if (num == 1)
                                mon_dot_address = adr;
                        if (!(num & 7))
                                fputc('\n', monout);
                }
                adr++;
        }

        if (num & 7)
                fputc('\n', monout);
        fprintf(monout, "Found %d occurrences\n", num);
}


/*
 *  Load data
 *  [ start "file"
 */

void load_data(void)
{
        uint32 start_adr;
        FILE *file;
        int fc;

        if (!mon_expression(&start_adr))
                return;
        if (mon_token == T_END) {
                mon_error("Missing file name");
                return;
        }
        if (mon_token != T_STRING) {
                mon_error("'\"' around file name expected");
                return;
        }
        mon_get_token();
        if (mon_token != T_END) {
                mon_error("Too many arguments");
                return;
        }

        if (!(file = fopen(mon_string, "rb")))
                mon_error("Unable to open file");
        else {
                uint32 adr = start_adr;

                while ((fc = fgetc(file)) != EOF)
                        mon_write_byte(adr++, fc);
                fclose(file);

                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);
                mon_dot_address = adr;
        }
}


/*
 *  Save data
 *  ] start size "file"
 */

void save_data(void)
{
        uint32 start_adr, size;
        FILE *file;

        if (!mon_expression(&start_adr))
                return;
        if (!mon_expression(&size))
                return;
        if (mon_token == T_END) {
                mon_error("Missing file name");
                return;
        }
        if (mon_token != T_STRING) {
                mon_error("'\"' around file name expected");
                return;
        }
        mon_get_token();
        if (mon_token != T_END) {
                mon_error("Too many arguments");
                return;
        }

        if (!(file = fopen(mon_string, "wb")))
                mon_error("Unable to create file");
        else {
                uint32 adr = start_adr, end_adr = start_adr + size - 1;

                while (adr <= end_adr)
                        fputc(mon_read_byte(adr++), file);
                fclose(file);

                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);
        }
}
Revision:	1.9
Committed:	2000-10-15T15:07:13Z (23 years, 7 months ago) by cebix
Branch:	MAIN
Changes since 1.8:	+8 -10 lines
Log Message:	- extended to 8080 disassembler to a Z80 disassembler - program renamed to "cxmon"
#	Content
1	/*
2	* mon_cmd.cpp - cxmon standard commands
3	*
4	* cxmon (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 "sysdeps.h"
22
23	#include <stdlib.h>
24
25	#include "mon.h"
26	#include "mon_cmd.h"
27	#include "mon_disass.h"
28
29	#ifndef VERSION
30	#define VERSION "2"
31	#endif
32
33
34	/*
35	* range_args = [expression] [[COMMA] expression] END
36	*
37	* Read start address to "adr", end address to "end_adr".
38	* "adr" defaults to '.', "end_adr" defaults to '.'+def_range
39	*
40	* true: OK, false: Error
41	*/
42
43	static bool range_args(uint32 adr, uint32 end_adr, uint32 def_range)
44	{
45	*adr = mon_dot_address;
46	*end_adr = mon_dot_address + def_range;
47
48	if (mon_token == T_END)
49	return true;
50	else {
51	if (!mon_expression(adr))
52	return false;
53	end_adr = adr + def_range;
54	if (mon_token == T_END)
55	return true;
56	else {
57	if (mon_token == T_COMMA) mon_get_token();
58	if (!mon_expression(end_adr))
59	return false;
60	return mon_token == T_END;
61	}
62	}
63	}
64
65
66	/*
67	* byte_string = (expression \| STRING) {COMMA (expression \| STRING)} END
68	*/
69
70	static bool byte_string(uint8 *s, uint32 &len)
71	{
72	uint32 value;
73
74	len = 0;
75	goto start;
76
77	for (;;) {
78	if (mon_token == T_COMMA) {
79	mon_get_token();
80
81	start:
82	if (mon_token == T_STRING) {
83	uint8 p = (uint8 )mon_string;
84	while ((s++ = p++) != 0) ;
85	s--;
86	len += strlen(mon_string);
87	mon_get_token();
88	} else if (mon_expression(&value)) {
89	*s++ = value;
90	len++;
91	} else
92	return false;
93
94	} else if (mon_token == T_END)
95	return true;
96	else {
97	mon_error("',' expected");
98	return false;
99	}
100	}
101	}
102
103
104	/*
105	* Convert character to printable character
106	*/
107
108	static inline uint8 char2print(uint8 c)
109	{
110	return (c >= 0x20 && c <= 0x7e) ? c : '.';
111	}
112
113
114	/*
115	* Show version
116	* ver
117	*/
118
119	void version(void)
120	{
121	fprintf(monout, "mon V" VERSION "\n");
122	}
123
124
125	/*
126	* Redirect output
127	* o [file]
128	*/
129
130	void redir_output(void)
131	{
132	// Close old file
133	if (monout != monerr) {
134	fclose(monout);
135	monout = monerr;
136	return;
137	}
138
139	// No argument given?
140	if (mon_token == T_END)
141	return;
142
143	// Otherwise open file
144	if (mon_token == T_STRING) {
145	mon_get_token();
146	if (mon_token != T_END) {
147	mon_error("Too many arguments");
148	return;
149	}
150	if (!(monout = fopen(mon_string, "w")))
151	mon_error("Unable to open file");
152	} else
153	mon_error("'\"' around file name expected");
154	}
155
156
157	/*
158	* Compute and display expression
159	* ? expression
160	*/
161
162	void print_expr(void)
163	{
164	uint32 val;
165
166	if (!mon_expression(&val))
167	return;
168	if (mon_token != T_END) {
169	mon_error("Too many arguments");
170	return;
171	}
172
173	if (val > 0x7fffffff) {
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 : $%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	}
185
186
187	/*
188	* Execute shell command
189	* \ "command"
190	*/
191
192	void shell_command(void)
193	{
194	if (mon_token != T_STRING) {
195	mon_error("'\"' around command expected");
196	return;
197	}
198	mon_get_token();
199	if (mon_token != T_END) {
200	mon_error("Too many arguments");
201	return;
202	}
203	system(mon_string);
204	}
205
206
207	/*
208	* Memory dump
209	* m [start [end]]
210	*/
211
212	#define MEMDUMP_BPL 16 // Bytes per line
213
214	void memory_dump(void)
215	{
216	uint32 adr, end_adr;
217	uint8 mem[MEMDUMP_BPL + 1];
218
219	mem[MEMDUMP_BPL] = 0;
220
221	if (!range_args(&adr, &end_adr, 16 * MEMDUMP_BPL - 1)) // 16 lines unless end address specified
222	return;
223
224	while (adr <= end_adr && !mon_aborted()) {
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, " %08x", mon_read_word(adr));
229	mem[i] = char2print(mon_read_byte(adr));
230	}
231	fprintf(monout, " '%s'\n", mem);
232	}
233
234	mon_dot_address = adr;
235	}
236
237
238	/*
239	* ASCII dump
240	* i [start [end]]
241	*/
242
243	#define ASCIIDUMP_BPL 64 // Bytes per line
244
245	void ascii_dump(void)
246	{
247	uint32 adr, end_adr;
248	uint8 str[ASCIIDUMP_BPL + 1];
249
250	str[ASCIIDUMP_BPL] = 0;
251
252	if (!range_args(&adr, &end_adr, 16 * ASCIIDUMP_BPL - 1)) // 16 lines unless end address specified
253	return;
254
255	while (adr <= end_adr && !mon_aborted()) {
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);
260	}
261
262	mon_dot_address = adr;
263	}
264
265
266	/*
267	* Binary dump
268	* b [start [end]]
269	*/
270
271	void binary_dump(void)
272	{
273	uint32 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_Z80,
309	CPU_80x86_32,
310	CPU_80x86_16
311	};
312
313	static void disassemble(CPUType type)
314	{
315	uint32 adr, end_adr;
316
317	if (!range_args(&adr, &end_adr, 16 * 4 - 1)) // 16 lines unless end address specified
318	return;
319
320	switch (type) {
321	case CPU_PPC:
322	while (adr <= end_adr && !mon_aborted()) {
323	uint32 w = mon_read_word(adr);
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	}
328	break;
329
330	case CPU_6502:
331	while (adr <= end_adr && !mon_aborted()) {
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, "%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	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_Z80:
348	while (adr <= end_adr && !mon_aborted()) {
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_32:
355	while (adr <= end_adr && !mon_aborted()) {
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	}
368
369	mon_dot_address = adr;
370	}
371
372	void disassemble_ppc(void)
373	{
374	disassemble(CPU_PPC);
375	}
376
377	void disassemble_6502(void)
378	{
379	disassemble(CPU_6502);
380	}
381
382	void disassemble_680x0(void)
383	{
384	disassemble(CPU_680x0);
385	}
386
387	void disassemble_z80(void)
388	{
389	disassemble(CPU_Z80);
390	}
391
392	void disassemble_80x86_32(void)
393	{
394	disassemble(CPU_80x86_32);
395	}
396
397	void disassemble_80x86_16(void)
398	{
399	disassemble(CPU_80x86_16);
400	}
401
402
403	/*
404	* Modify memory
405	* : addr bytestring
406	*/
407
408	void modify(void)
409	{
410	uint32 adr, len, src_adr = 0;
411	uint8 str[256];
412
413	if (!mon_expression(&adr))
414	return;
415	if (!byte_string(str, len))
416	return;
417
418	while (src_adr < len)
419	mon_write_byte(adr++, str[src_adr++]);
420
421	mon_dot_address = adr;
422	}
423
424
425	/*
426	* Fill
427	* f start end bytestring
428	*/
429
430	void fill(void)
431	{
432	uint32 adr, end_adr, len, src_adr = 0;
433	uint8 str[256];
434
435	if (!mon_expression(&adr))
436	return;
437	if (!mon_expression(&end_adr))
438	return;
439	if (!byte_string(str, len))
440	return;
441
442	while (adr <= end_adr)
443	mon_write_byte(adr++, str[src_adr++ % len]);
444	}
445
446
447	/*
448	* Transfer memory
449	* t start end dest
450	*/
451
452	void transfer(void)
453	{
454	uint32 adr, end_adr, dest;
455	int num;
456
457	if (!mon_expression(&adr))
458	return;
459	if (!mon_expression(&end_adr))
460	return;
461	if (!mon_expression(&dest))
462	return;
463	if (mon_token != T_END) {
464	mon_error("Too many arguments");
465	return;
466	}
467
468	num = end_adr - adr + 1;
469
470	if (dest < adr)
471	for (int i=0; i<num; i++)
472	mon_write_byte(dest++, mon_read_byte(adr++));
473	else {
474	dest += end_adr - adr;
475	for (int i=0; i<num; i++)
476	mon_write_byte(dest--, mon_read_byte(end_adr--));
477	}
478	}
479
480
481	/*
482	* Compare
483	* c start end dest
484	*/
485
486	void compare(void)
487	{
488	uint32 adr, end_adr, dest;
489	int num = 0;
490
491	if (!mon_expression(&adr))
492	return;
493	if (!mon_expression(&end_adr))
494	return;
495	if (!mon_expression(&dest))
496	return;
497	if (mon_token != T_END) {
498	mon_error("Too many arguments");
499	return;
500	}
501
502	while (adr <= end_adr && !mon_aborted()) {
503	if (mon_read_byte(adr) != mon_read_byte(dest)) {
504	fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
505	num++;
506	if (!(num & 7))
507	fputc('\n', monout);
508	}
509	adr++; dest++;
510	}
511
512	if (num & 7)
513	fputc('\n', monout);
514	fprintf(monout, "%d byte(s) different\n", num);
515	}
516
517
518	/*
519	* Search for byte string
520	* h start end bytestring
521	*/
522
523	void hunt(void)
524	{
525	uint32 adr, end_adr, len;
526	uint8 str[256];
527	int num = 0;
528
529	if (!mon_expression(&adr))
530	return;
531	if (!mon_expression(&end_adr))
532	return;
533	if (!byte_string(str, len))
534	return;
535
536	while ((adr+len-1) <= end_adr && !mon_aborted()) {
537	uint32 i;
538
539	for (i=0; i<len; i++)
540	if (mon_read_byte(adr + i) != str[i])
541	break;
542
543	if (i == len) {
544	fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
545	num++;
546	if (num == 1)
547	mon_dot_address = adr;
548	if (!(num & 7))
549	fputc('\n', monout);
550	}
551	adr++;
552	}
553
554	if (num & 7)
555	fputc('\n', monout);
556	fprintf(monout, "Found %d occurrences\n", num);
557	}
558
559
560	/*
561	* Load data
562	* [ start "file"
563	*/
564
565	void load_data(void)
566	{
567	uint32 start_adr;
568	FILE *file;
569	int fc;
570
571	if (!mon_expression(&start_adr))
572	return;
573	if (mon_token == T_END) {
574	mon_error("Missing file name");
575	return;
576	}
577	if (mon_token != T_STRING) {
578	mon_error("'\"' around file name expected");
579	return;
580	}
581	mon_get_token();
582	if (mon_token != T_END) {
583	mon_error("Too many arguments");
584	return;
585	}
586
587	if (!(file = fopen(mon_string, "rb")))
588	mon_error("Unable to open file");
589	else {
590	uint32 adr = start_adr;
591
592	while ((fc = fgetc(file)) != EOF)
593	mon_write_byte(adr++, fc);
594	fclose(file);
595
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	}
600
601
602	/*
603	* Save data
604	* ] start size "file"
605	*/
606
607	void save_data(void)
608	{
609	uint32 start_adr, size;
610	FILE *file;
611
612	if (!mon_expression(&start_adr))
613	return;
614	if (!mon_expression(&size))
615	return;
616	if (mon_token == T_END) {
617	mon_error("Missing file name");
618	return;
619	}
620	if (mon_token != T_STRING) {
621	mon_error("'\"' around file name expected");
622	return;
623	}
624	mon_get_token();
625	if (mon_token != T_END) {
626	mon_error("Too many arguments");
627	return;
628	}
629
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;
634
635	while (adr <= end_adr)
636	fputc(mon_read_byte(adr++), file);
637	fclose(file);
638
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	}