--- mon/src/mon_cmd.cpp	2000/10/06 00:04:22	1.8
+++ mon/src/mon_cmd.cpp	2002/09/07 12:48:15	1.13
@@ -1,7 +1,7 @@
 /*
- *  mon_cmd.cpp - mon standard commands
+ *  mon_cmd.cpp - cxmon standard commands
  *
- *  mon (C) 1997-1999 Christian Bauer, Marc Hellwig
+ *  cxmon (C) 1997-2002 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
@@ -27,7 +27,7 @@
 #include "mon_disass.h"
 
 #ifndef VERSION
-#define VERSION "2"
+#define VERSION "3"
 #endif
 
 
@@ -40,7 +40,7 @@
  *  true: OK, false: Error
  */
 
-static bool range_args(uint32 *adr, uint32 *end_adr, uint32 def_range)
+static bool range_args(uintptr *adr, uintptr *end_adr, uint32 def_range)
 {
 	*adr = mon_dot_address;
 	*end_adr = mon_dot_address + def_range;
@@ -67,9 +67,9 @@ static bool range_args(uint32 *adr, uint
  *  byte_string = (expression | STRING) {COMMA (expression | STRING)} END
  */
 
-static bool byte_string(uint8 *s, uint32 &len)
+static bool byte_string(uint8 *s, uintptr &len)
 {
-	uint32 value;
+	uintptr value;
 
 	len = 0;
 	goto start;
@@ -161,7 +161,7 @@ void redir_output(void)
 
 void print_expr(void)
 {
-	uint32 val;
+	uintptr val;
 
 	if (!mon_expression(&val))
 		return;
@@ -213,7 +213,7 @@ void shell_command(void)
 
 void memory_dump(void)
 {
-	uint32 adr, end_adr;
+	uintptr adr, end_adr;
 	uint8 mem[MEMDUMP_BPL + 1];
 
 	mem[MEMDUMP_BPL] = 0;
@@ -222,7 +222,7 @@ void memory_dump(void)
 		return;
 
 	while (adr <= end_adr && !mon_aborted()) {
-		fprintf(monout, "%08x:", mon_use_real_mem ? adr: adr % mon_mem_size);
+		fprintf(monout, "%0*lx:", 2 * sizeof(adr), 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));
@@ -244,7 +244,7 @@ void memory_dump(void)
 
 void ascii_dump(void)
 {
-	uint32 adr, end_adr;
+	uintptr adr, end_adr;
 	uint8 str[ASCIIDUMP_BPL + 1];
 
 	str[ASCIIDUMP_BPL] = 0;
@@ -253,7 +253,7 @@ void ascii_dump(void)
 		return;
 
 	while (adr <= end_adr && !mon_aborted()) {
-		fprintf(monout, "%08x:", mon_use_real_mem ? adr : adr % mon_mem_size);
+		fprintf(monout, "%0*lx:", 2 * sizeof(adr), 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);
@@ -270,7 +270,7 @@ void ascii_dump(void)
 
 void binary_dump(void)
 {
-	uint32 adr, end_adr;
+	uintptr adr, end_adr;
 	uint8 str[9];
 
 	str[8] = 0;
@@ -279,7 +279,7 @@ void binary_dump(void)
 		return;
 
 	while (adr <= end_adr && !mon_aborted()) {
-		fprintf(monout, "%08x:", mon_use_real_mem ? adr : adr % mon_mem_size);
+		fprintf(monout, "%0*lx:", 2 * sizeof(adr), 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) ? '*' : '.';
@@ -298,20 +298,22 @@ void binary_dump(void)
  *  d68 [start [end]]
  *  d80 [start [end]]
  *  d86 [start [end]]
+ *  d8086 [start [end]]
  */
 
 enum CPUType {
 	CPU_PPC,
 	CPU_6502,
 	CPU_680x0,
-	CPU_8080,
+	CPU_Z80,
 	CPU_80x86_32,
-	CPU_80x86_16
+	CPU_80x86_16,
+	CPU_x86_64
 };
 
 static void disassemble(CPUType type)
 {
-	uint32 adr, end_adr;
+	uintptr adr, end_adr;
 
 	if (!range_args(&adr, &end_adr, 16 * 4 - 1))  // 16 lines unless end address specified
 		return;
@@ -320,7 +322,7 @@ static void disassemble(CPUType 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);
+				fprintf(monout, "%0*lx: %08x\t", 2 * sizeof(adr), 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;
 			}
@@ -331,41 +333,44 @@ static void disassemble(CPUType type)
 				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);
+				fprintf(monout, "%0*lx: ", 2 * sizeof(adr), 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);
+				fprintf(monout, "%0*lx: ", 2 * sizeof(adr), 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_8080:
+		case CPU_Z80:
 			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);
+				fprintf(monout, "%0*lx: ", 2 * sizeof(adr), 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_x86_64:
+			while (adr <= end_adr && !mon_aborted()) {
+				fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
+				adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 64);
 			}
 			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);
+				fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
+				adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 32);
 			}
 			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);
+				fprintf(monout, "%0*lx: ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
+				adr += disass_x86(monout, mon_use_real_mem ? adr : adr % mon_mem_size, 16);
 			}
-			break;
 	}
 
 	mon_dot_address = adr;
@@ -386,9 +391,9 @@ void disassemble_680x0(void)
 	disassemble(CPU_680x0);
 }
 
-void disassemble_8080(void)
+void disassemble_z80(void)
 {
-	disassemble(CPU_8080);
+	disassemble(CPU_Z80);
 }
 
 void disassemble_80x86_32(void)
@@ -401,6 +406,11 @@ void disassemble_80x86_16(void)
 	disassemble(CPU_80x86_16);
 }
 
+void disassemble_x86_64(void)
+{
+	disassemble(CPU_x86_64);
+}
+
 
 /*
  *  Modify memory
@@ -409,7 +419,7 @@ void disassemble_80x86_16(void)
 
 void modify(void)
 {
-	uint32 adr, len, src_adr = 0;
+	uintptr adr, len, src_adr = 0;
 	uint8 str[256];
 
 	if (!mon_expression(&adr))
@@ -431,7 +441,7 @@ void modify(void)
 
 void fill(void)
 {
-	uint32 adr, end_adr, len, src_adr = 0;
+	uintptr adr, end_adr, len, src_adr = 0;
 	uint8 str[256];
 
 	if (!mon_expression(&adr))
@@ -453,7 +463,7 @@ void fill(void)
 
 void transfer(void)
 {
-	uint32 adr, end_adr, dest;
+	uintptr adr, end_adr, dest;
 	int num;
 
 	if (!mon_expression(&adr))
@@ -487,7 +497,7 @@ void transfer(void)
 
 void compare(void)
 {
-	uint32 adr, end_adr, dest;
+	uintptr adr, end_adr, dest;
 	int num = 0;
 
 	if (!mon_expression(&adr))
@@ -503,7 +513,7 @@ void compare(void)
 
 	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);
+			fprintf(monout, "%0*lx ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
 			num++;
 			if (!(num & 7))
 				fputc('\n', monout);
@@ -524,7 +534,7 @@ void compare(void)
 
 void hunt(void)
 {
-	uint32 adr, end_adr, len;
+	uintptr adr, end_adr, len;
 	uint8 str[256];
 	int num = 0;
 
@@ -543,7 +553,7 @@ void hunt(void)
 				break;
 
 		if (i == len) {
-			fprintf(monout, "%08x ", mon_use_real_mem ? adr : adr % mon_mem_size);
+			fprintf(monout, "%0*lx ", 2 * sizeof(adr), mon_use_real_mem ? adr : adr % mon_mem_size);
 			num++;
 			if (num == 1)
 				mon_dot_address = adr;
@@ -566,7 +576,7 @@ void hunt(void)
 
 void load_data(void)
 {
-	uint32 start_adr;
+	uintptr start_adr;
 	FILE *file;
 	int fc;
 
@@ -589,13 +599,13 @@ void load_data(void)
 	if (!(file = fopen(mon_string, "rb")))
 		mon_error("Unable to open file");
 	else {
-		uint32 adr = start_adr;
+		uintptr 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);
+		fprintf(monerr, "%08x bytes read from %0*lx to %0*lx\n", adr - start_adr, 2 * sizeof(adr), mon_use_real_mem ? start_adr : start_adr % mon_mem_size, 2 * sizeof(adr), mon_use_real_mem ? adr-1 : (adr-1) % mon_mem_size);
 		mon_dot_address = adr;
 	}
 }
@@ -608,7 +618,7 @@ void load_data(void)
 
 void save_data(void)
 {
-	uint32 start_adr, size;
+	uintptr start_adr, size;
 	FILE *file;
 
 	if (!mon_expression(&start_adr))
@@ -632,12 +642,12 @@ void save_data(void)
 	if (!(file = fopen(mon_string, "wb")))
 		mon_error("Unable to create file");
 	else {
-		uint32 adr = start_adr, end_adr = start_adr + size - 1;
+		uintptr 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);
+		fprintf(monerr, "%08x bytes written from %0*lx to %0*lx\n", size, 2 * sizeof(adr), mon_use_real_mem ? start_adr : start_adr % mon_mem_size, mon_use_real_mem ? end_adr : end_adr % mon_mem_size);
 	}
 }