--- mon/src/mon.cpp	2000/10/15 15:07:12	1.14
+++ mon/src/mon.cpp	2002/07/17 10:00:54	1.18
@@ -1,7 +1,7 @@
 /*
  *  mon.cpp - cxmon main program
  *
- *  cxmon (C) 1997-2000 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
@@ -24,6 +24,8 @@
 #include <stdlib.h>
 #include <signal.h>
 #include <ctype.h>
+#include <string>
+#include <map>
 
 #if defined(HAVE_READLINE_H)
 extern "C" {
@@ -47,6 +49,7 @@ extern "C" {
 
 #include "mon.h"
 #include "mon_cmd.h"
+#include "mon_lowmem.h"
 
 #ifndef VERSION
 #define VERSION "2"
@@ -68,7 +71,7 @@ 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;
@@ -76,7 +79,7 @@ static uint32 colon_value;
 
 // Scanner variables
 enum Token mon_token;			// Last token read
-uint32 mon_number;				// Contains the number if mon_token==T_NUMBER
+uintptr 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
 
@@ -93,13 +96,8 @@ static char *cmd_help;		// Help text for
 
 
 // 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
@@ -109,21 +107,18 @@ static void exit_abort(void);
 static void read_line(char *prompt);		// Scanner
 static char get_char(void);
 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_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(uint32 &i, char *name);
+static enum Token get_hex_or_name(uintptr &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 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);
 
 
 /*
@@ -207,47 +202,47 @@ bool mon_aborted(void)
  *  Access to buffer
  */
 
-uint32 (*mon_read_byte)(uint32 adr);
+uint32 (*mon_read_byte)(uintptr adr);
 
-uint32 mon_read_byte_buffer(uint32 adr)
+uint32 mon_read_byte_buffer(uintptr adr)
 {
 	return mem[adr % mon_mem_size];
 }
 
-uint32 mon_read_byte_real(uint32 adr)
+uint32 mon_read_byte_real(uintptr adr)
 {
 	return *(uint8 *)adr;
 }
 
-void (*mon_write_byte)(uint32 adr, uint32 b);
+void (*mon_write_byte)(uintptr adr, uint32 b);
 
-void mon_write_byte_buffer(uint32 adr, uint32 b)
+void mon_write_byte_buffer(uintptr adr, uint32 b)
 {
 	mem[adr % mon_mem_size] = b;
 }
 
-void mon_write_byte_real(uint32 adr, uint32 b)
+void mon_write_byte_real(uintptr adr, uint32 b)
 {
 	*(uint8 *)adr = b;
 }
 
-uint32 mon_read_half(uint32 adr)
+uint32 mon_read_half(uintptr adr)
 {
 	return (mon_read_byte(adr) << 8) | mon_read_byte(adr+1);
 }
 
-void mon_write_half(uint32 adr, uint32 w)
+void mon_write_half(uintptr adr, uint32 w)
 {
 	mon_write_byte(adr, w >> 8);
 	mon_write_byte(adr+1, w);
 }
 
-uint32 mon_read_word(uint32 adr)
+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(uint32 adr, uint32 l)
+void mon_write_word(uintptr adr, uint32 l)
 {
 	mon_write_byte(adr, l >> 24);
 	mon_write_byte(adr+1, l >> 16);
@@ -390,7 +385,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();
 
@@ -399,6 +394,7 @@ static enum Token get_hex_number(uint32
 		return T_NULL;
 
 	do {
+		c = tolower(c);
 		if (c < 'a')
 			i = (i << 4) + (c - '0');
 		else
@@ -414,7 +410,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();
 
@@ -435,7 +431,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;
 
@@ -466,7 +462,7 @@ static enum Token get_string(char *str)
 	return T_NULL;
 }
 
-static enum Token get_hex_or_name(uint32 &i, char *name)
+static enum Token get_hex_or_name(uintptr &i, char *name)
 {
 	char *old_in_ptr = in_ptr;
 	char c;
@@ -494,9 +490,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;
@@ -522,9 +518,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;
@@ -550,9 +546,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;
@@ -578,9 +574,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;
@@ -613,9 +609,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;
@@ -648,9 +644,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;
@@ -698,7 +694,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:
@@ -707,13 +703,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:
@@ -773,62 +770,6 @@ 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]]
  */
@@ -838,20 +779,21 @@ static void set_var(void)
 	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 = %08x\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;
@@ -859,12 +801,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");
@@ -880,13 +822,7 @@ static void set_var(void)
 
 static void clear_vars(void)
 {
-	Variable *var, *next;
-	for (var=first_var; var; var=next) {
-		free(var->name);
-		next = var->next;
-		free(var);
-	}
-	first_var = NULL;
+	vars.clear();
 }
 
 
@@ -927,7 +863,7 @@ static void mon_cmd_list(void)
 
 static void reallocate(void)
 {
-	uint32 size;
+	uintptr size;
 
 	if (mon_use_real_mem) {
 		fprintf(monerr, "Cannot reallocate buffer in real mode\n");
@@ -960,7 +896,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))
@@ -974,8 +910,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;
@@ -1135,6 +1071,7 @@ void mon(int argc, char **argv)
 	monerr = stdout;
 
 	// Make argc/argv point to the actual arguments
+	const char *prg_name = argv[0];
 	if (argc)
 		argc--; argv++;
 
@@ -1142,7 +1079,10 @@ void mon(int argc, char **argv)
 	mon_macos_mode = false;
 	mon_use_real_mem = false;
 	while (argc > 0) {
-		if (strcmp(argv[0], "-m") == 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;
@@ -1177,13 +1117,25 @@ void mon(int argc, char **argv)
 							" ***               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
 	while (!done) {
 		if (interactive) {
 			char prompt[16];
-			sprintf(prompt, "[%08x]-> ", mon_dot_address);
+			sprintf(prompt, "[%0*lx]-> ", 2 * sizeof(mon_dot_address), mon_dot_address);
 			read_line(prompt);
 		} else {
 			if (argc == 0) {