mon/src/mon_cmd.cpp

/*
 *  mon_cmd.cpp - mon standard commands
 *
 *  mon (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 "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"
#include "version.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", VERSION_MAJOR, VERSION_MINOR);
}


/*
 *  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;
}


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