mon/src/mon_cmd.cpp

/*
 *  mon_cmd.cpp - mon standard commands
 *
 *  (C) 1997-1999 Christian Bauer
 */

#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "mon.h"
#include "mon_cmd.h"
#include "mon_ppc.h"
#include "mon_68k.h"
#include "mon_x86.h"
#include "mon_6502.h"
#include "mon_8080.h"


/*
 *  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%d.%d\n", MON_VERSION, MON_REVISION);
}


/*
 *  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:  $%08lx\n"
                                          "Hex signed  : -$%08lx\n"
                                          "Dec unsigned:  %lu\n"
                                          "Dec signed  : %ld\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 : $%08lx\n"
                                          "Dec : %ld\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, "%08lx:", mon_use_real_mem ? adr: adr % mon_mem_size);
                for (int i=0; i<MEMDUMP_BPL; i++, adr++) {
                        if (i % 4 == 0)
                                fprintf(monout, " %08lx", 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, "%08lx:", 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;
}


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

enum CPUType {
        CPU_PPC,
        CPU_6502,
        CPU_680x0,
        CPU_8080,
        CPU_80x86
};

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, "%08lx: %08lx\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, "%08lx: ", 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()) {
                                uint16 buf[8];
                                buf[0] = mon_read_half(adr);
                                buf[1] = mon_read_half(adr + 2);
                                buf[2] = mon_read_half(adr + 4);
                                buf[3] = mon_read_half(adr + 6);
                                buf[4] = mon_read_half(adr + 8);
                                buf[5] = mon_read_half(adr + 10);
                                buf[6] = mon_read_half(adr + 12);
                                buf[7] = mon_read_half(adr + 14);
                                fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
                                adr += disass_68k(monout, mon_use_real_mem ? adr : adr % mon_mem_size, buf);
                        }
                        break;

                case CPU_8080:
                        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, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
                                adr += disass_8080(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
                        }
                        break;

                case CPU_80x86:
                        while (adr <= end_adr && !mon_aborted()) {
                                uint8 buf[16];
                                for (int i=0; i<16; i++)
                                        buf[i] = mon_read_byte(adr + i);
                                fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
                                adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, buf);
                        }
                        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_8080(void)
{
        disassemble(CPU_8080);
}

void disassemble_80x86(void)
{
        disassemble(CPU_80x86);
}


/*
 *  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, "%08lx ", 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, "%08lx ", 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, "%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);
                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, "%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);
        }
}
Revision:	1.1
Committed:	1999-10-04T19:31:09Z (25 years, 1 month ago) by cebix
Branch:	MAIN
Branch point for:	cebix
Log Message:	Initial revision
#	User	Rev	Content
1	cebix	1.1	/*
2			* mon_cmd.cpp - mon standard commands
3			*
4			* (C) 1997-1999 Christian Bauer
5			*/
6
7			#include <stdio.h>
8			#include <string.h>
9			#include <unistd.h>
10
11			#include "mon.h"
12			#include "mon_cmd.h"
13			#include "mon_ppc.h"
14			#include "mon_68k.h"
15			#include "mon_x86.h"
16			#include "mon_6502.h"
17			#include "mon_8080.h"
18
19
20			/*
21			* range_args = [expression] [[COMMA] expression] END
22			*
23			* Read start address to "adr", end address to "end_adr".
24			* "adr" defaults to '.', "end_adr" defaults to '.'+def_range
25			*
26			* true: OK, false: Error
27			*/
28
29			static bool range_args(uint32 adr, uint32 end_adr, uint32 def_range)
30			{
31			*adr = mon_dot_address;
32			*end_adr = mon_dot_address + def_range;
33
34			if (mon_token == T_END)
35			return true;
36			else {
37			if (!mon_expression(adr))
38			return false;
39			end_adr = adr + def_range;
40			if (mon_token == T_END)
41			return true;
42			else {
43			if (mon_token == T_COMMA) mon_get_token();
44			if (!mon_expression(end_adr))
45			return false;
46			return mon_token == T_END;
47			}
48			}
49			}
50
51
52			/*
53			* byte_string = (expression \| STRING) {COMMA (expression \| STRING)} END
54			*/
55
56			static bool byte_string(uint8 *s, uint32 &len)
57			{
58			uint32 value;
59
60			len = 0;
61			goto start;
62
63			for (;;) {
64			if (mon_token == T_COMMA) {
65			mon_get_token();
66
67			start:
68			if (mon_token == T_STRING) {
69			uint8 p = (uint8 )mon_string;
70			while ((s++ = p++) != 0) ;
71			s--;
72			len += strlen(mon_string);
73			mon_get_token();
74			} else if (mon_expression(&value)) {
75			*s++ = value;
76			len++;
77			} else
78			return false;
79
80			} else if (mon_token == T_END)
81			return true;
82			else {
83			mon_error("',' expected");
84			return false;
85			}
86			}
87			}
88
89
90			/*
91			* Convert character to printable character
92			*/
93
94			static inline uint8 char2print(uint8 c)
95			{
96			return (c >= 0x20 && c <= 0x7e) ? c : '.';
97			}
98
99
100			/*
101			* Show version
102			* ver
103			*/
104
105			void version(void)
106			{
107			fprintf(monout, "mon V%d.%d\n", MON_VERSION, MON_REVISION);
108			}
109
110
111			/*
112			* Redirect output
113			* o [file]
114			*/
115
116			void redir_output(void)
117			{
118			// Close old file
119			if (monout != monerr) {
120			fclose(monout);
121			monout = monerr;
122			return;
123			}
124
125			// No argument given?
126			if (mon_token == T_END)
127			return;
128
129			// Otherwise open file
130			if (mon_token == T_STRING) {
131			mon_get_token();
132			if (mon_token != T_END) {
133			mon_error("Too many arguments");
134			return;
135			}
136			if (!(monout = fopen(mon_string, "w")))
137			mon_error("Unable to open file");
138			} else
139			mon_error("'\"' around file name expected");
140			}
141
142
143			/*
144			* Compute and display expression
145			* ? expression
146			*/
147
148			void print_expr(void)
149			{
150			uint32 val;
151
152			if (!mon_expression(&val))
153			return;
154			if (mon_token != T_END) {
155			mon_error("Too many arguments");
156			return;
157			}
158
159			if (val > 0x7fffffff) {
160			fprintf(monout, "Hex unsigned: $%08lx\n"
161			"Hex signed : -$%08lx\n"
162			"Dec unsigned: %lu\n"
163			"Dec signed : %ld\n", val, -val, val, val);
164			fprintf(monout, "Char : '%c%c%c%c'\n", char2print(val >> 24), char2print(val >> 16), char2print(val >> 8), char2print(val));
165			} else {
166			fprintf(monout, "Hex : $%08lx\n"
167			"Dec : %ld\n", val, val);
168			fprintf(monout, "Char: '%c%c%c%c'\n", char2print(val >> 24), char2print(val >> 16), char2print(val >> 8), char2print(val));
169			}
170			}
171
172
173			/*
174			* Execute shell command
175			* \ "command"
176			*/
177
178			void shell_command(void)
179			{
180			if (mon_token != T_STRING) {
181			mon_error("'\"' around command expected");
182			return;
183			}
184			mon_get_token();
185			if (mon_token != T_END) {
186			mon_error("Too many arguments");
187			return;
188			}
189			system(mon_string);
190			}
191
192
193			/*
194			* Memory dump
195			* m [start [end]]
196			*/
197
198			#define MEMDUMP_BPL 16 // Bytes per line
199
200			void memory_dump(void)
201			{
202			uint32 adr, end_adr;
203			uint8 mem[MEMDUMP_BPL + 1];
204
205			mem[MEMDUMP_BPL] = 0;
206
207			if (!range_args(&adr, &end_adr, 16 * MEMDUMP_BPL - 1)) // 16 lines unless end address specified
208			return;
209
210			while (adr <= end_adr && !mon_aborted()) {
211			fprintf(monout, "%08lx:", mon_use_real_mem ? adr: adr % mon_mem_size);
212			for (int i=0; i<MEMDUMP_BPL; i++, adr++) {
213			if (i % 4 == 0)
214			fprintf(monout, " %08lx", mon_read_word(adr));
215			mem[i] = char2print(mon_read_byte(adr));
216			}
217			fprintf(monout, " '%s'\n", mem);
218			}
219
220			mon_dot_address = adr;
221			}
222
223
224			/*
225			* ASCII dump
226			* i [start [end]]
227			*/
228
229			#define ASCIIDUMP_BPL 64 // Bytes per line
230
231			void ascii_dump(void)
232			{
233			uint32 adr, end_adr;
234			uint8 str[ASCIIDUMP_BPL + 1];
235
236			str[ASCIIDUMP_BPL] = 0;
237
238			if (!range_args(&adr, &end_adr, 16 * ASCIIDUMP_BPL - 1)) // 16 lines unless end address specified
239			return;
240
241			while (adr <= end_adr && !mon_aborted()) {
242			fprintf(monout, "%08lx:", mon_use_real_mem ? adr : adr % mon_mem_size);
243			for (int i=0; i<ASCIIDUMP_BPL; i++, adr++)
244			str[i] = char2print(mon_read_byte(adr));
245			fprintf(monout, " '%s'\n", str);
246			}
247
248			mon_dot_address = adr;
249			}
250
251
252			/*
253			* Disassemble
254			* d [start [end]]
255			* d65 [start [end]]
256			* d68 [start [end]]
257			* d80 [start [end]]
258			* d86 [start [end]]
259			*/
260
261			enum CPUType {
262			CPU_PPC,
263			CPU_6502,
264			CPU_680x0,
265			CPU_8080,
266			CPU_80x86
267			};
268
269			static void disassemble(CPUType type)
270			{
271			uint32 adr, end_adr;
272
273			if (!range_args(&adr, &end_adr, 16 * 4 - 1)) // 16 lines unless end address specified
274			return;
275
276			switch (type) {
277			case CPU_PPC:
278			while (adr <= end_adr && !mon_aborted()) {
279			uint32 w = mon_read_word(adr);
280			fprintf(monout, "%08lx: %08lx\t", mon_use_real_mem ? adr : adr % mon_mem_size, w);
281			disass_ppc(monout, mon_use_real_mem ? adr : adr % mon_mem_size, w);
282			adr += 4;
283			}
284			break;
285
286			case CPU_6502:
287			while (adr <= end_adr && !mon_aborted()) {
288			uint8 op = mon_read_byte(adr);
289			uint8 lo = mon_read_byte(adr + 1);
290			uint8 hi = mon_read_byte(adr + 2);
291			fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
292			adr += disass_6502(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
293			}
294			break;
295
296			case CPU_680x0:
297			while (adr <= end_adr && !mon_aborted()) {
298			uint16 buf[8];
299			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);
309			}
310			break;
311
312			case CPU_8080:
313			while (adr <= end_adr && !mon_aborted()) {
314			uint8 op = mon_read_byte(adr);
315			uint8 lo = mon_read_byte(adr + 1);
316			uint8 hi = mon_read_byte(adr + 2);
317			fprintf(monout, "%08lx: ", mon_use_real_mem ? adr : adr % mon_mem_size);
318			adr += disass_8080(monout, mon_use_real_mem ? adr : adr % mon_mem_size, op, lo, hi);
319			}
320			break;
321
322			case CPU_80x86:
323			while (adr <= end_adr && !mon_aborted()) {
324			uint8 buf[16];
325			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);
329			}
330			break;
331			}
332
333			mon_dot_address = adr;
334			}
335
336			void disassemble_ppc(void)
337			{
338			disassemble(CPU_PPC);
339			}
340
341			void disassemble_6502(void)
342			{
343			disassemble(CPU_6502);
344			}
345
346			void disassemble_680x0(void)
347			{
348			disassemble(CPU_680x0);
349			}
350
351			void disassemble_8080(void)
352			{
353			disassemble(CPU_8080);
354			}
355
356			void disassemble_80x86(void)
357			{
358			disassemble(CPU_80x86);
359			}
360
361
362			/*
363			* Modify memory
364			* : addr bytestring
365			*/
366
367			void modify(void)
368			{
369			uint32 adr, len, src_adr = 0;
370			uint8 str[256];
371
372			if (!mon_expression(&adr))
373			return;
374			if (!byte_string(str, len))
375			return;
376
377			while (src_adr < len)
378			mon_write_byte(adr++, str[src_adr++]);
379
380			mon_dot_address = adr;
381			}
382
383
384			/*
385			* Fill
386			* f start end bytestring
387			*/
388
389			void fill(void)
390			{
391			uint32 adr, end_adr, len, src_adr = 0;
392			uint8 str[256];
393
394			if (!mon_expression(&adr))
395			return;
396			if (!mon_expression(&end_adr))
397			return;
398			if (!byte_string(str, len))
399			return;
400
401			while (adr <= end_adr)
402			mon_write_byte(adr++, str[src_adr++ % len]);
403			}
404
405
406			/*
407			* Transfer memory
408			* t start end dest
409			*/
410
411			void transfer(void)
412			{
413			uint32 adr, end_adr, dest;
414			int num;
415
416			if (!mon_expression(&adr))
417			return;
418			if (!mon_expression(&end_adr))
419			return;
420			if (!mon_expression(&dest))
421			return;
422			if (mon_token != T_END) {
423			mon_error("Too many arguments");
424			return;
425			}
426
427			num = end_adr - adr + 1;
428
429			if (dest < adr)
430			for (int i=0; i<num; i++)
431			mon_write_byte(dest++, mon_read_byte(adr++));
432			else {
433			dest += end_adr - adr;
434			for (int i=0; i<num; i++)
435			mon_write_byte(dest--, mon_read_byte(end_adr--));
436			}
437			}
438
439
440			/*
441			* Compare
442			* c start end dest
443			*/
444
445			void compare(void)
446			{
447			uint32 adr, end_adr, dest;
448			int num = 0;
449
450			if (!mon_expression(&adr))
451			return;
452			if (!mon_expression(&end_adr))
453			return;
454			if (!mon_expression(&dest))
455			return;
456			if (mon_token != T_END) {
457			mon_error("Too many arguments");
458			return;
459			}
460
461			while (adr <= end_adr && !mon_aborted()) {
462			if (mon_read_byte(adr) != mon_read_byte(dest)) {
463			fprintf(monout, "%08lx ", mon_use_real_mem ? adr : adr % mon_mem_size);
464			num++;
465			if (!(num & 7))
466			fputc('\n', monout);
467			}
468			adr++; dest++;
469			}
470
471			if (num & 7)
472			fputc('\n', monout);
473			fprintf(monout, "%d byte(s) different\n", num);
474			}
475
476
477			/*
478			* Search for byte string
479			* h start end bytestring
480			*/
481
482			void hunt(void)
483			{
484			uint32 adr, end_adr, len;
485			uint8 str[256];
486			int num = 0;
487
488			if (!mon_expression(&adr))
489			return;
490			if (!mon_expression(&end_adr))
491			return;
492			if (!byte_string(str, len))
493			return;
494
495			while ((adr+len-1) <= end_adr && !mon_aborted()) {
496			uint32 i;
497
498			for (i=0; i<len; i++)
499			if (mon_read_byte(adr + i) != str[i])
500			break;
501
502			if (i == len) {
503			fprintf(monout, "%08lx ", mon_use_real_mem ? adr : adr % mon_mem_size);
504			num++;
505			if (num == 1)
506			mon_dot_address = adr;
507			if (!(num & 7))
508			fputc('\n', monout);
509			}
510			adr++;
511			}
512
513			if (num & 7)
514			fputc('\n', monout);
515			fprintf(monout, "Found %d occurrences\n", num);
516			}
517
518
519			/*
520			* Load data
521			* [ start "file"
522			*/
523
524			void load_data(void)
525			{
526			uint32 start_adr;
527			FILE *file;
528			int fc;
529
530			if (!mon_expression(&start_adr))
531			return;
532			if (mon_token == T_END) {
533			mon_error("Missing file name");
534			return;
535			}
536			if (mon_token != T_STRING) {
537			mon_error("'\"' around file name expected");
538			return;
539			}
540			mon_get_token();
541			if (mon_token != T_END) {
542			mon_error("Too many arguments");
543			return;
544			}
545
546			if (!(file = fopen(mon_string, "rb")))
547			mon_error("Unable to open file");
548			else {
549			uint32 adr = start_adr;
550
551			while ((fc = fgetc(file)) != EOF)
552			mon_write_byte(adr++, fc);
553			fclose(file);
554
555			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);
556			mon_dot_address = adr;
557			}
558			}
559
560
561			/*
562			* Save data
563			* ] start size "file"
564			*/
565
566			void save_data(void)
567			{
568			uint32 start_adr, size;
569			FILE *file;
570
571			if (!mon_expression(&start_adr))
572			return;
573			if (!mon_expression(&size))
574			return;
575			if (mon_token == T_END) {
576			mon_error("Missing file name");
577			return;
578			}
579			if (mon_token != T_STRING) {
580			mon_error("'\"' around file name expected");
581			return;
582			}
583			mon_get_token();
584			if (mon_token != T_END) {
585			mon_error("Too many arguments");
586			return;
587			}
588
589			if (!(file = fopen(mon_string, "wb")))
590			mon_error("Unable to create file");
591			else {
592			uint32 adr = start_adr, end_adr = start_adr + size - 1;
593
594			while (adr <= end_adr)
595			fputc(mon_read_byte(adr++), file);
596			fclose(file);
597
598			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);
599			}
600			}