--- mon/src/mon.cpp	1999/10/04 21:16:02	1.2
+++ mon/src/mon.cpp	2004/02/12 17:14:36	1.24
@@ -1,7 +1,7 @@
 /*
- *  mon.cpp - mon main program
+ *  mon.cpp - cxmon main program
  *
- *  mon (C) 1997-1999 Christian Bauer, Marc Hellwig
+ *  cxmon (C) 1997-2003 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
@@ -20,13 +20,28 @@
 
 #include "sysdeps.h"
 
-#ifdef HAVE_READLINE_READLINE_H
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <ctype.h>
+#include <string>
+#include <map>
+
+#if defined(HAVE_READLINE_H)
+extern "C" {
+#include <readline.h>
+}
+#elif defined(HAVE_READLINE_READLINE_H)
 extern "C" {
 #include <readline/readline.h>
 }
 #endif
 
-#ifdef HAVE_READLINE_HISTORY_H
+#if defined(HAVE_HISTORY_H)
+extern "C" {
+#include <history.h>
+}
+#elif defined(HAVE_READLINE_HISTORY_H)
 extern "C" {
 #include <readline/history.h>
 }
@@ -34,7 +49,11 @@ extern "C" {
 
 #include "mon.h"
 #include "mon_cmd.h"
-#include "version.h"
+#include "mon_lowmem.h"
+
+#ifndef VERSION
+#define VERSION "3"
+#endif
 
 
 // Buffer we're operating on
@@ -47,74 +66,66 @@ static uint8 *mem;
 FILE *monin, *monout, *monerr;
 
 // Input line
-static char input[INPUT_LENGTH];
+static char *input;
 static char *in_ptr;
 char *mon_args_ptr;
 
 // Current address, value of '.' in expressions
-uint32 mon_dot_address;
+uintptr mon_dot_address;
 
 // Current value of ':' in expression
 static uint32 colon_value;
 
 
 // Scanner variables
-enum Token mon_token;			// Last token read
-uint32 mon_number;				// Contains the number if mon_token==T_NUMBER
-char mon_string[INPUT_LENGTH];	// Contains the string if mon_token==T_STRING
-char mon_name[INPUT_LENGTH];	// Contains the variable name if mon_token==T_NAME
+enum Token mon_token;  // Last token read
+uintptr mon_number;    // Contains the number if mon_token==T_NUMBER
+char *mon_string;      // Contains the string if mon_token==T_STRING
+char *mon_name;        // Contains the variable name if mon_token==T_NAME
 
 
 // List of installed commands
 struct CmdSpec {
-	const char *name;	// Name of command
-	void (*func)(void);	// Function that executes this command
+	const char *name;  // Name of command
+	void (*func)();    // Function that executes this command
 };
 
-static CmdSpec *cmds;		// Array of CmdSpecs
-static int num_cmds;		// Number of installed commands
-static char *cmd_help;		// Help text for commands
+static CmdSpec *cmds;   // Array of CmdSpecs
+static int num_cmds;    // Number of installed commands
+static char *cmd_help;  // Help text for commands
 
 
 // List of variables
-struct Variable {
-	Variable *next;	// Pointer to next variable (must be first element of struct)
-	char *name;		// Variable name
-	uint32 value;	// Variable value
-};
-
-static Variable *first_var;	// Pointer to first variable
+typedef std::map<std::string, uintptr> var_map;
+static var_map vars;
 
 
 // Prototypes
-static void init_abort(void);
-static void exit_abort(void);
+static void init_abort();
+static void exit_abort();
 
 static void read_line(char *prompt);		// Scanner
-static char get_char(void);
+static char get_char();
 static void put_back(char c);
-static enum Token get_hex_number(uint32 &i);
-static enum Token get_dec_number(uint32 &i);
-static enum Token get_char_number(uint32 &i);
-static enum Token get_string(char *str);
-static enum Token get_hex_or_name(uint32 &i, char *name);
-
-static bool eor_expr(uint32 *number);	// Parser
-static bool and_expr(uint32 *number);
-static bool shift_expr(uint32 *number);
-static bool add_expr(uint32 *number);
-static bool mul_expr(uint32 *number);
-static bool factor(uint32 *number);
-static Variable *lookup_var(const char *s);
-static Variable *insert_var(const char *s);
-static void remove_var(const char *s);
+static enum Token get_hex_number(uintptr &i);
+static enum Token get_dec_number(uintptr &i);
+static enum Token get_char_number(uintptr &i);
+static enum Token get_string(char *&str);
+static enum Token get_hex_or_name(uintptr &i, char *&name);
+
+static bool eor_expr(uintptr *number);	// Parser
+static bool and_expr(uintptr *number);
+static bool shift_expr(uintptr *number);
+static bool add_expr(uintptr *number);
+static bool mul_expr(uintptr *number);
+static bool factor(uintptr *number);
 
 
 /*
  *  Add command to mon
  */
 
-void mon_add_command(const char *name, void (*func)(void), const char *help_text)
+void mon_add_command(const char *name, void (*func)(), const char *help_text)
 {
 	num_cmds++;
 	if (cmds)
@@ -159,7 +170,7 @@ static void handle_abort(int sig)
 	was_aborted = true;
 }
 
-static void init_abort(void)
+static void init_abort()
 {
 	was_aborted = false;
 	sigemptyset(&my_sa.sa_mask);
@@ -173,13 +184,13 @@ static void init_abort(void)
 	sigaction(SIGINT, &my_sa, NULL);
 }
 
-static void exit_abort(void)
+static void exit_abort()
 {
 	my_sa.sa_handler = SIG_DFL;
 	sigaction(SIGINT, &my_sa, NULL);
 }
 
-bool mon_aborted(void)
+bool mon_aborted()
 {
 	bool ret = was_aborted;
 	was_aborted = false;
@@ -191,58 +202,52 @@ bool mon_aborted(void)
  *  Access to buffer
  */
 
-uint32 mon_read_byte(uint32 adr)
+uint32 (*mon_read_byte)(uintptr adr);
+
+uint32 mon_read_byte_buffer(uintptr adr)
 {
-	if (mon_use_real_mem)
-		return *(uint8 *)adr;
-	else
-		return mem[adr % mon_mem_size];
+	return mem[adr % mon_mem_size];
 }
 
-void mon_write_byte(uint32 adr, uint32 b)
+uint32 mon_read_byte_real(uintptr adr)
 {
-	if (mon_use_real_mem)
-		*(uint8 *)adr = b;
-	else
-		mem[adr % mon_mem_size] = b;
+	return *(uint8 *)adr;
 }
 
-uint32 mon_read_half(uint32 adr)
+void (*mon_write_byte)(uintptr adr, uint32 b);
+
+void mon_write_byte_buffer(uintptr adr, uint32 b)
 {
-	if (mon_use_real_mem)
-		return ntohs(*(uint16 *)adr);
-	else
-		return mem[adr % mon_mem_size] << 8 | mem[(adr+1) % mon_mem_size];
+	mem[adr % mon_mem_size] = b;
 }
 
-void mon_write_half(uint32 adr, uint32 w)
+void mon_write_byte_real(uintptr adr, uint32 b)
 {
-	if (mon_use_real_mem)
-		*(uint16 *)adr = htons(w);
-	else {
-		mem[adr % mon_mem_size] = w >> 8;
-		mem[(adr+1) % mon_mem_size] = w;
-	}
+	*(uint8 *)adr = b;
 }
 
-uint32 mon_read_word(uint32 adr)
+uint32 mon_read_half(uintptr adr)
 {
-	if (mon_use_real_mem)
-		return ntohl(*(uint32 *)adr);
-	else
-		return mon_read_byte(adr) << 24 | mon_read_byte(adr+1) << 16 | mon_read_byte(adr+2) << 8 | mon_read_byte(adr+3);
+	return (mon_read_byte(adr) << 8) | mon_read_byte(adr+1);
 }
 
-void mon_write_word(uint32 adr, uint32 l)
+void mon_write_half(uintptr adr, uint32 w)
 {
-	if (mon_use_real_mem)
-		*(uint32 *)adr = htonl(l);
-	else {
-		mem[adr % mon_mem_size] = l >> 24;
-		mem[(adr+1) % mon_mem_size] = l >> 16;
-		mem[(adr+2) % mon_mem_size] = l >> 8;
-		mem[(adr+3) % mon_mem_size] = l;
-	}
+	mon_write_byte(adr, w >> 8);
+	mon_write_byte(adr+1, w);
+}
+
+uint32 mon_read_word(uintptr adr)
+{
+	return (mon_read_byte(adr) << 24) | (mon_read_byte(adr+1) << 16) | (mon_read_byte(adr+2) << 8) | mon_read_byte(adr+3);
+}
+
+void mon_write_word(uintptr adr, uint32 l)
+{
+	mon_write_byte(adr, l >> 24);
+	mon_write_byte(adr+1, l >> 16);
+	mon_write_byte(adr+2, l >> 8);
+	mon_write_byte(adr+3, l);
 }
 
 
@@ -252,20 +257,36 @@ void mon_write_word(uint32 adr, uint32 l
 
 static void read_line(char *prompt)
 {
+#ifdef HAVE_LIBREADLINE
 	static char *line_read = NULL;
 
-	if (line_read) {
-		free(line_read);
-		line_read = NULL;
+	if (input)
+		free(input);
+	input = readline(prompt);
+
+	if (input) {
+		if (*input)
+			add_history(input);
+	} else {
+		// EOF, quit cxmon
+		input = (char *)malloc(2);
+		input[0] = 'x';
+		input[1] = 0;
+		fprintf(monout, "x\n");
 	}
 
-	line_read = readline(prompt);
-
-	if (line_read && *line_read)
-		add_history(line_read);
-
-	strncpy(in_ptr = input, line_read, INPUT_LENGTH);
-	input[INPUT_LENGTH-1] = 0;
+	in_ptr = input;
+#else
+	static const unsigned INPUT_LENGTH = 256;
+	if (!input)
+		input = (char *)malloc(INPUT_LENGTH);
+	fprintf(monout, prompt);
+	fflush(monout);
+	fgets(in_ptr = input, INPUT_LENGTH, monin);
+	char *s = strchr(input, '\n');
+	if (s != NULL)
+		*s = 0;
+#endif
 }
 
 
@@ -273,7 +294,7 @@ static void read_line(char *prompt)
  *  Read a character from the input line
  */
 
-static char get_char(void)
+static char get_char()
 {
 	return *in_ptr++;
 }
@@ -293,12 +314,13 @@ static void put_back(char c)
  *  Scanner: Get a token from the input line
  */
 
-enum Token mon_get_token(void)
+enum Token mon_get_token()
 {
-	char c;
+	char c = get_char();
 
 	// Skip spaces
-	while ((c = get_char()) == ' ') ;
+	while (isspace(c))
+		c = get_char();
 
 	switch (c) {
 		case 0:
@@ -371,7 +393,7 @@ enum Token mon_get_token(void)
 	}
 }
 
-static enum Token get_hex_number(uint32 &i)
+static enum Token get_hex_number(uintptr &i)
 {
 	char c = get_char();
 
@@ -380,6 +402,7 @@ static enum Token get_hex_number(uint32
 		return T_NULL;
 
 	do {
+		c = tolower(c);
 		if (c < 'a')
 			i = (i << 4) + (c - '0');
 		else
@@ -395,7 +418,7 @@ static enum Token get_hex_number(uint32
 	}
 }
 
-static enum Token get_dec_number(uint32 &i)
+static enum Token get_dec_number(uintptr &i)
 {
 	char c = get_char();
 
@@ -416,7 +439,7 @@ static enum Token get_dec_number(uint32
 	}
 }
 
-static enum Token get_char_number(uint32 &i)
+static enum Token get_char_number(uintptr &i)
 {
 	char c;
 
@@ -431,41 +454,64 @@ static enum Token get_char_number(uint32
 	return T_NULL;
 }
 
-static enum Token get_string(char *str)
+static enum Token get_string(char *&str)
 {
-	char c;
+	// Remember start of string
+	char *old_in_ptr = in_ptr;
 
+	// Determine string length
+	char c;
+	unsigned n = 0;
 	while ((c = get_char()) != 0) {
-		if (c == '"') {
-			*str = 0;
-			return T_STRING;
-		}
-		*str++ = c;
+		n++;
+		if (c == '"')
+			break;
+	}
+	if (c == 0) {
+		mon_error("Unterminated string");
+		return T_NULL;
 	}
 
-	mon_error("Unterminated string");
-	return T_NULL;
+	// Allocate new buffer (n: size needed including terminating 0)
+	str = (char *)realloc(str, n);
+
+	// Copy string to buffer
+	char *p = str;
+	in_ptr = old_in_ptr;
+	while (--n)
+		*p++ = get_char();
+	*p++ = 0;
+	get_char();  // skip closing '"'
+	return T_STRING;
 }
 
-static enum Token get_hex_or_name(uint32 &i, char *name)
+static enum Token get_hex_or_name(uintptr &i, char *&name)
 {
+	// Remember start of token
 	char *old_in_ptr = in_ptr;
-	char c;
 
 	// Try hex number first
 	if (get_hex_number(i) == T_NUMBER)
 		return T_NUMBER;
 
-	// Not a hex number, must be a variable name
+	// Not a hex number, must be a variable name; determine its length
 	in_ptr = old_in_ptr;
-	c = get_char();
+	char c = get_char();
+	unsigned n = 1;
 	do {
-		*name++ = c;
+		n++;
 		c = get_char();
 	} while (isalnum(c));
 
-	*name = 0;
-	put_back(c);
+	// Allocate new buffer (n: size needed including terminating 0)
+	name = (char *)realloc(name, n);
+
+	// Copy name to buffer
+	in_ptr = old_in_ptr;
+	char *p = name;
+	while (--n)
+		*p++ = get_char();
+	*p = 0;
 	return T_NAME;
 }
 
@@ -475,9 +521,9 @@ static enum Token get_hex_or_name(uint32
  *  true: OK, false: Error
  */
 
-bool mon_expression(uint32 *number)
+bool mon_expression(uintptr *number)
 {
-	uint32 accu, expr;
+	uintptr accu, expr;
 
 	if (!eor_expr(&accu))
 		return false;
@@ -503,9 +549,9 @@ bool mon_expression(uint32 *number)
  *  true: OK, false: Error
  */
 
-static bool eor_expr(uint32 *number)
+static bool eor_expr(uintptr *number)
 {
-	uint32 accu, expr;
+	uintptr accu, expr;
 
 	if (!and_expr(&accu))
 		return false;
@@ -531,9 +577,9 @@ static bool eor_expr(uint32 *number)
  *  true: OK, false: Error
  */
 
-static bool and_expr(uint32 *number)
+static bool and_expr(uintptr *number)
 {
-	uint32 accu, expr;
+	uintptr accu, expr;
 
 	if (!shift_expr(&accu))
 		return false;
@@ -559,9 +605,9 @@ static bool and_expr(uint32 *number)
  *  true: OK, false: Error
  */
 
-static bool shift_expr(uint32 *number)
+static bool shift_expr(uintptr *number)
 {
-	uint32 accu, expr;
+	uintptr accu, expr;
 
 	if (!add_expr(&accu))
 		return false;
@@ -594,9 +640,9 @@ static bool shift_expr(uint32 *number)
  *  true: OK, false: Error
  */
 
-static bool add_expr(uint32 *number)
+static bool add_expr(uintptr *number)
 {
-	uint32 accu, expr;
+	uintptr accu, expr;
 
 	if (!mul_expr(&accu))
 		return false;
@@ -629,9 +675,9 @@ static bool add_expr(uint32 *number)
  *  true: OK, false: Error
  */
 
-static bool mul_expr(uint32 *number)
+static bool mul_expr(uintptr *number)
 {
-	uint32 accu, fact;
+	uintptr accu, fact;
 
 	if (!factor(&accu))
 		return false;
@@ -679,7 +725,7 @@ static bool mul_expr(uint32 *number)
  *  true: OK, false: Error
  */
 
-static bool factor(uint32 *number)
+static bool factor(uintptr *number)
 {
 	switch (mon_token) {
 		case T_NUMBER:
@@ -688,13 +734,14 @@ static bool factor(uint32 *number)
 			return true;
 
 		case T_NAME:{
-			Variable *var;
-			if ((var = lookup_var(mon_name)) != NULL) {
-				*number = var->value;
+			var_map::const_iterator v = vars.find(mon_name);
+			if (v == vars.end())
+				return false;
+			else {
+				*number = v->second;
 				mon_get_token();
 				return true;
-			} else
-				return false;
+			}
 		}
 
 		case T_DOT:
@@ -754,85 +801,30 @@ static bool factor(uint32 *number)
 
 
 /*
- *  Lookup the value of a variable
- */
-
-static Variable *lookup_var(const char *s)
-{
-	// Lookup variable
-	for (Variable *var=first_var; var; var=var->next)
-		if (!strcmp(s, var->name))
-			return var;
-
-	// Not found, error
-	mon_error("Undefined variable");
-	return NULL;
-}
-
-
-/*
- *  Insert new variable (or redefine old)
- */
-
-static Variable *insert_var(const char *s)
-{
-	// Lookup variable
-	for (Variable *var=first_var; var; var=var->next)
-		if (!strcmp(s, var->name))
-			return var;
-
-	// Insert new variable
-	Variable *var = new Variable;
-	var->name = strdup(s);
-	var->next = first_var;
-	first_var = var;
-	return var;
-}
-
-
-/*
- *  Remove variable
- */
-
-static void remove_var(const char *s)
-{
-	Variable *var, *prev = (Variable *)&first_var;
-
-	// Lookup variable and remove it
-	for (var=prev->next; var; prev=var, var=var->next)
-		if (!strcmp(s, var->name)) {
-			prev->next = var->next;
-			free(var->name);
-			free(var);
-			return;
-		}
-}
-
-
-/*
  *  Set/clear/show variables
  *  set [var[=value]]
  */
 
-static void set_var(void)
+static void set_var()
 {
 	if (mon_token == T_END) {
 
 		// Show all variables
-		if (first_var == NULL)
+		if (vars.empty())
 			fprintf(monout, "No variables defined\n");
-		else
-			for (Variable *v=first_var; v; v=v->next)
-				fprintf(monout, "%s = %08lx\n", v->name, v->value);
+		else {
+			var_map::const_iterator v = vars.begin(), end = vars.end();
+			for (v=vars.begin(); v!=end; ++v)
+				fprintf(monout, "%s = %08x\n", v->first.c_str(), v->second);
+		}
 
 	} else if (mon_token == T_NAME) {
-		char var_name[256];
-		strcpy(var_name, mon_name);
+		std::string var_name = mon_name;
 		mon_get_token();
 		if (mon_token == T_ASSIGN) {
 
 			// Set variable
-			uint32 value;
+			uintptr value;
 			mon_get_token();
 			if (!mon_expression(&value))
 				return;
@@ -840,12 +832,12 @@ static void set_var(void)
 				mon_error("Too many arguments");
 				return;
 			}
-			insert_var(var_name)->value = value;
+			vars[var_name] = value;
 
 		} else if (mon_token == T_END) {
 
 			// Clear variable
-			remove_var(var_name);
+			vars.erase(var_name);
 
 		} else
 			mon_error("'=' expected");
@@ -859,15 +851,9 @@ static void set_var(void)
  *  cv
  */
 
-static void clear_vars(void)
+static void clear_vars()
 {
-	Variable *var, *next;
-	for (var=first_var; var; var=next) {
-		free(var->name);
-		next = var->next;
-		free(var);
-	}
-	first_var = NULL;
+	vars.clear();
 }
 
 
@@ -876,7 +862,7 @@ static void clear_vars(void)
  *  h
  */
 
-static void help_or_hunt(void)
+static void help_or_hunt()
 {
 	if (mon_token != T_END) {
 		hunt();
@@ -893,7 +879,7 @@ static void help_or_hunt(void)
  *  ??
  */
 
-static void mon_cmd_list(void)
+static void mon_cmd_list()
 {
 	for (int i=0; i<num_cmds; i++)
 		fprintf(monout, "%s ", cmds[i].name);
@@ -906,9 +892,9 @@ static void mon_cmd_list(void)
  *  @ [size]
  */
 
-static void reallocate(void)
+static void reallocate()
 {
-	uint32 size;
+	uintptr size;
 
 	if (mon_use_real_mem) {
 		fprintf(monerr, "Cannot reallocate buffer in real mode\n");
@@ -916,7 +902,7 @@ static void reallocate(void)
 	}
 
 	if (mon_token == T_END) {
-		fprintf(monerr, "Buffer size: %08lx bytes\n", mon_mem_size);
+		fprintf(monerr, "Buffer size: %08x bytes\n", mon_mem_size);
 		return;
 	}
 
@@ -928,7 +914,7 @@ static void reallocate(void)
 	}
 
 	if ((mem = (uint8 *)realloc(mem, size)) != NULL)
-		fprintf(monerr, "Buffer size: %08lx bytes\n", mon_mem_size = size);
+		fprintf(monerr, "Buffer size: %08x bytes\n", mon_mem_size = size);
 	else
 		fprintf(monerr, "Unable to reallocate buffer\n");
 }
@@ -941,7 +927,7 @@ static void reallocate(void)
 
 static void apply(int size)
 {
-	uint32 adr, end_adr, value;
+	uintptr adr, end_adr, value;
 	char c;
 
 	if (!mon_expression(&adr))
@@ -955,8 +941,8 @@ static void apply(int size)
 		return;
 	}
 
-	uint32 (*read_func)(uint32 adr);
-	void (*write_func)(uint32 adr, uint32 val);
+	uint32 (*read_func)(uintptr adr);
+	void (*write_func)(uintptr adr, uint32 val);
 	switch (size) {
 		case 1:
 			read_func = mon_read_byte;
@@ -970,6 +956,9 @@ static void apply(int size)
 			read_func = mon_read_word;
 			write_func = mon_write_word;
 			break;
+		default:
+			abort();
+			break;
 	}
 
 	while (adr<=end_adr) {
@@ -993,17 +982,17 @@ static void apply(int size)
 	mon_dot_address = adr;
 }
 
-static void apply_byte(void)
+static void apply_byte()
 {
 	apply(1);
 }
 
-static void apply_half(void)
+static void apply_half()
 {
 	apply(2);
 }
 
-static void apply_word(void)
+static void apply_word()
 {
 	apply(4);
 }
@@ -1013,7 +1002,7 @@ static void apply_word(void)
  *  Execute command via system() (for ls, rm, etc.)
  */
 
-static void mon_exec(void)
+static void mon_exec()
 {
 	system(input);
 }
@@ -1023,13 +1012,16 @@ static void mon_exec(void)
  *  Change current directory
  */
 
-static void mon_change_dir(void)
+void mon_change_dir()
 {
-	char c;
 	in_ptr = input;
-	while ((c = get_char()) == ' ') ;
-	while ((c = get_char()) != ' ') ;
-	while ((c = get_char()) == ' ') ;
+	char c = get_char();
+	while (isspace(c))
+		c = get_char();
+	while (isgraph(c))
+		c = get_char();
+	while (isspace(c))
+		c = get_char();
 	put_back(c);
 	if (chdir(in_ptr) != 0)
 		mon_error("Cannot change directory");
@@ -1040,43 +1032,53 @@ static void mon_change_dir(void)
  *  Initialize mon
  */
 
-void mon_init(void)
+void mon_init()
 {
 	cmds = NULL;
 	num_cmds = 0;
 	cmd_help = NULL;
 
-	mon_add_command("??", mon_cmd_list,			"??                       Show list of commands\n");
-	mon_add_command("ver", version,				"ver                      Show version\n");
-	mon_add_command("?", print_expr,			"? expression             Calculate expression\n");
-	mon_add_command("@", reallocate,			"@ [size]                 Reallocate buffer\n");
-	mon_add_command("i", ascii_dump,			"i [start [end]]          ASCII memory dump\n");
-	mon_add_command("m", memory_dump,			"m [start [end]]          Hex/ASCII memory dump\n");
-	mon_add_command("d", disassemble_ppc,		"d [start [end]]          Disassemble PowerPC code\n");
-	mon_add_command("d65", disassemble_6502,	"d65 [start [end]]        Disassemble 6502 code\n");
-	mon_add_command("d68", disassemble_680x0,	"d68 [start [end]]        Disassemble 680x0 code\n");
-	mon_add_command("d80", disassemble_8080,	"d80 [start [end]]        Disassemble 8080 code\n");
-	mon_add_command("d86", disassemble_80x86,	"d86 [start [end]]        Disassemble 80x86 code\n");
-	mon_add_command(":", modify,				": start string           Modify memory\n");
-	mon_add_command("f", fill,					"f start end string       Fill memory\n");
-	mon_add_command("y", apply_byte,			"y[b|h|w] start end expr  Apply expression to memory\n");
+	mon_add_command("??", mon_cmd_list,				"??                       Show list of commands\n");
+	mon_add_command("ver", version,					"ver                      Show version\n");
+	mon_add_command("?", print_expr,				"? expression             Calculate expression\n");
+	mon_add_command("@", reallocate,				"@ [size]                 Reallocate buffer\n");
+	mon_add_command("i", ascii_dump,				"i [start [end]]          ASCII memory dump\n");
+	mon_add_command("m", memory_dump,				"m [start [end]]          Hex/ASCII memory dump\n");
+	mon_add_command("b", binary_dump,				"b [start [end]]          Binary memory dump\n");
+	mon_add_command("d", disassemble_ppc,			"d [start [end]]          Disassemble PowerPC code\n");
+	mon_add_command("d65", disassemble_6502,		"d65 [start [end]]        Disassemble 6502 code\n");
+	mon_add_command("d68", disassemble_680x0,		"d68 [start [end]]        Disassemble 680x0 code\n");
+	mon_add_command("d80", disassemble_z80,			"d80 [start [end]]        Disassemble Z80 code\n");
+	mon_add_command("d86", disassemble_80x86_32,	"d86 [start [end]]        Disassemble 80x86 (32-bit) code\n");
+	mon_add_command("d8086", disassemble_80x86_16,	"d8086 [start [end]]      Disassemble 80x86 (16-bit) code\n");
+	mon_add_command("d8664", disassemble_x86_64,	"d8664 [start [end]]      Disassemble x86-64 code\n");
+	mon_add_command(":", modify,					": start string           Modify memory\n");
+	mon_add_command("f", fill,						"f start end string       Fill memory\n");
+	mon_add_command("y", apply_byte,				"y[b|h|w] start end expr  Apply expression to memory\n");
 	mon_add_command("yb", apply_byte, NULL);
 	mon_add_command("yh", apply_half, NULL);
 	mon_add_command("yw", apply_word, NULL);
-	mon_add_command("t", transfer,				"t start end dest         Transfer memory\n");
-	mon_add_command("c", compare,				"c start end dest         Compare memory\n");
-	mon_add_command("h", help_or_hunt,			"h start end string       Search for byte string\n");
-	mon_add_command("\\", shell_command,		"\\ \"command\"              Execute shell command\n");
-	mon_add_command("ls", mon_exec,				"ls [args]                List directory contents\n");
-	mon_add_command("rm", mon_exec,				"rm [args]                Remove file(s)\n");
-	mon_add_command("cp", mon_exec,				"cp [args]                Copy file(s)\n");
-	mon_add_command("mv", mon_exec,				"mv [args]                Move file(s)\n");
-	mon_add_command("cd", mon_change_dir,		"cd directory             Change current directory\n");
-	mon_add_command("o", redir_output,			"o [\"file\"]               Redirect output\n");
-	mon_add_command("[", load_data,				"[ start \"file\"           Load data from file\n");
-	mon_add_command("]", save_data,				"] start size \"file\"      Save data to file\n");
-	mon_add_command("set", set_var,				"set [var[=value]]        Set/clear/show variables\n");
-	mon_add_command("cv", clear_vars,			"cv                       Clear all variables\n");
+	mon_add_command("t", transfer,					"t start end dest         Transfer memory\n");
+	mon_add_command("c", compare,					"c start end dest         Compare memory\n");
+	mon_add_command("h", help_or_hunt,				"h start end string       Search for byte string\n");
+	mon_add_command("\\", shell_command,			"\\ \"command\"              Execute shell command\n");
+	mon_add_command("ls", mon_exec,					"ls [args]                List directory contents\n");
+	mon_add_command("rm", mon_exec,					"rm [args]                Remove file(s)\n");
+	mon_add_command("cp", mon_exec,					"cp [args]                Copy file(s)\n");
+	mon_add_command("mv", mon_exec,					"mv [args]                Move file(s)\n");
+	mon_add_command("cd", mon_change_dir,			"cd directory             Change current directory\n");
+	mon_add_command("o", redir_output,				"o [\"file\"]               Redirect output\n");
+	mon_add_command("[", load_data,					"[ start \"file\"           Load data from file\n");
+	mon_add_command("]", save_data,					"] start size \"file\"      Save data to file\n");
+	mon_add_command("set", set_var,					"set [var[=value]]        Set/clear/show variables\n");
+	mon_add_command("cv", clear_vars,				"cv                       Clear all variables\n");
+
+	mon_read_byte = NULL;
+	mon_write_byte = NULL;
+
+	input = NULL;
+	mon_string = NULL;
+	mon_name = NULL;
 }
 
 
@@ -1084,12 +1086,27 @@ void mon_init(void)
  *  Deinitialize mon
  */
 
-void mon_exit(void)
+void mon_exit()
 {
-	free(cmds);
-	cmds = NULL;
+	if (cmds) {
+		free(cmds);
+		cmds = NULL;
+	}
 	num_cmds = 0;
 	cmd_help = NULL;
+
+	if (input) {
+		free(input);
+		input = NULL;
+	}
+	if (mon_string) {
+		free(mon_string);
+		mon_string = NULL;
+	}
+	if (mon_name) {
+		free(mon_name);
+		mon_name = NULL;
+	}
 }
 
 
@@ -1100,26 +1117,46 @@ void mon_exit(void)
 void mon(int argc, char **argv)
 {
 	bool done = false, interactive = true;
-	char c, cmd[INPUT_LENGTH];
 
 	// Setup input/output streams
 	monin = stdin;
 	monout = stdout;
 	monerr = stdout;
 
-	if (argc) {
-		// Access real memory if mon was started as "rmon"
-		char *prgname = argv[0];
-		char *lastslash;
-		if ((lastslash = strrchr(prgname, '/')) != NULL)
-			prgname = lastslash + 1;
-		if (strcmp(prgname, "rmon") == 0)
+	// Make argc/argv point to the actual arguments
+	const char *prg_name = argv[0];
+	if (argc)
+		argc--; argv++;
+
+	// Parse arguments
+	mon_macos_mode = false;
+	mon_use_real_mem = false;
+	while (argc > 0) {
+		if (strcmp(argv[0], "-h") == 0 || strcmp(argv[0], "--help") == 0) {
+			printf("Usage: %s [-m] [-r] [command...]\n", prg_name);
+			exit(0);
+		} else if (strcmp(argv[0], "-m") == 0)
+			mon_macos_mode = true;
+		else if (strcmp(argv[0], "-r") == 0)
 			mon_use_real_mem = true;
+		else
+			break;
+		argc--; argv++;
+	}
+	interactive = (argc == 0);
 
-		// Make argc/argv point to the actual arguments
-		argc--;
-		argv++;
-		interactive = (argc == 0);
+	// Set up memory access functions if not supplied by the user
+	if (mon_read_byte == NULL) {
+		if (mon_use_real_mem)
+			mon_read_byte = mon_read_byte_real;
+		else
+			mon_read_byte = mon_read_byte_buffer;
+	}
+	if (mon_write_byte == NULL) {
+		if (mon_use_real_mem)
+			mon_write_byte = mon_write_byte_real;
+		else
+			mon_write_byte = mon_write_byte_buffer;
 	}
 
 	// Allocate buffer
@@ -1129,44 +1166,67 @@ void mon(int argc, char **argv)
 
 		// Print banner
 		if (interactive)
-			fprintf(monerr, "\n *** mon V%d.%d by Christian Bauer and Marc Hellwig ***\n"
-							" ***              Press 'h' for help              ***\n\n", VERSION_MAJOR, VERSION_MINOR);
+			fprintf(monerr, "\n *** cxmon V" VERSION " by Christian Bauer and Marc Hellwig ***\n"
+							" ***               Press 'h' for help               ***\n\n");
+	}
+
+	// Clear variables
+	vars.clear();
+
+	// In MacOS mode, pull in the lowmem globals as variables
+	if (mon_macos_mode) {
+		const lowmem_info *l = lowmem;
+		while (l->name) {
+			vars[l->name] = l->addr;
+			l++;
+		}
 	}
 
 	init_abort();
 
 	// Read and parse command line
+	char *cmd = NULL;
 	while (!done) {
 		if (interactive) {
 			char prompt[16];
-			sprintf(prompt, "[%08lx]-> ", mon_dot_address);
+			sprintf(prompt, "[%0*lx]-> ", 2 * sizeof(mon_dot_address), mon_dot_address);
 			read_line(prompt);
+			if (!input) {
+				done = true;
+				continue;
+			}
 		} else {
 			if (argc == 0) {
 				done = true;
 				break;
 			} else {
-				strncpy(in_ptr = input, argv[0], INPUT_LENGTH);
+				unsigned n = strlen(argv[0]) + 1;
+				input = (char *)realloc(input, n);
+				strcpy(in_ptr = input, argv[0]);
 				argc--;
 				argv++;
 			}
 		}
 
 		// Skip leading spaces
-		while ((c = get_char()) == ' ') ;
+		char c = get_char();
+		while (isspace(c))
+			c = get_char();
+		put_back(c);
+		if (!c)
+			continue;  // blank line
 
 		// Read command word
-		char *p = cmd;
-		do {
-			*p++ = c;
+		char *p = in_ptr;
+		while (isgraph(c))
 			c = get_char();
-		} while (isgraph(c));
-		*p = 0;
 		put_back(c);
+		unsigned n = in_ptr - p;
+		cmd = (char *)realloc(cmd, n + 1);
+		memcpy(cmd, p, n);
+		cmd[n] = 0;
 
 		// Execute command
-		if (cmd[0] == 0)				// Blank line
-			continue;
 		if (strcmp(cmd, "x") == 0) {	// Exit
 			done = true;
 			continue;
@@ -1182,6 +1242,9 @@ void mon(int argc, char **argv)
 cmd_done: ;
 	}
 
+	if (cmd)
+		free(cmd);
+
 	exit_abort();
 
 	// Free buffer