[ViewVC] Diff of: cebix/mon/src/mon.cpp

Comparing mon/src/mon.cpp (file contents):
Revision 1.6 by cebix, 2000-04-24T13:10:00Z vs.
Revision 1.20 by gbeauche, 2002-09-07T12:48:15Z

#	Line 1 \| Line 1
1		/*
2	<	* mon.cpp - mon main program
2	>	* mon.cpp - cxmon main program
3		*
4	<	* mon (C) 1997-2000 Christian Bauer, Marc Hellwig
4	>	* cxmon (C) 1997-2002 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
#	Line 24 \| Line 24
24		#include <stdlib.h>
25		#include <signal.h>
26		#include <ctype.h>
27	+	#include <string>
28	+	#include <map>
29
30	<	#ifdef HAVE_READLINE_READLINE_H
30	>	#if defined(HAVE_READLINE_H)
31	>	extern "C" {
32	>	#include <readline.h>
33	>	}
34	>	#elif defined(HAVE_READLINE_READLINE_H)
35		extern "C" {
36		#include <readline/readline.h>
37		}
38		#endif
39
40	<	#ifdef HAVE_READLINE_HISTORY_H
40	>	#if defined(HAVE_HISTORY_H)
41	>	extern "C" {
42	>	#include <history.h>
43	>	}
44	>	#elif defined(HAVE_READLINE_HISTORY_H)
45		extern "C" {
46		#include <readline/history.h>
47		}
#	Line 39 \| Line 49 \| extern "C" {
49
50		#include "mon.h"
51		#include "mon_cmd.h"
52	+	#include "mon_lowmem.h"
53	+
54	+	#ifndef VERSION
55	+	#define VERSION "3"
56	+	#endif
57
58
59		// Buffer we're operating on
#	Line 56 \| Line 71 \| *static char in_ptr;**
71		char *mon_args_ptr;
72
73		// Current address, value of '.' in expressions
74	<	uint32 mon_dot_address;
74	>	uintptr mon_dot_address;
75
76		// Current value of ':' in expression
77		static uint32 colon_value;
#	Line 64 \| Line 79 \| static uint32 colon_value;
79
80		// Scanner variables
81		enum Token mon_token; // Last token read
82	<	uint32 mon_number; // Contains the number if mon_token==T_NUMBER
82	>	uintptr mon_number; // Contains the number if mon_token==T_NUMBER
83		char mon_string[INPUT_LENGTH]; // Contains the string if mon_token==T_STRING
84		char mon_name[INPUT_LENGTH]; // Contains the variable name if mon_token==T_NAME
85
#	Line 81 \| Line 96 \| *static char cmd_help; // Help text for**
96
97
98		// List of variables
99	<	struct Variable {
100	<	Variable *next; // Pointer to next variable (must be first element of struct)
86	<	char *name; // Variable name
87	<	uint32 value; // Variable value
88	<	};
89	<
90	<	static Variable *first_var; // Pointer to first variable
99	>	typedef std::map<std::string, uintptr> var_map;
100	>	static var_map vars;
101
102
103		// Prototypes
#	Line 97 \| Line 107 \| static void exit_abort(void);
107		static void read_line(char *prompt); // Scanner
108		static char get_char(void);
109		static void put_back(char c);
110	<	static enum Token get_hex_number(uint32 &i);
111	<	static enum Token get_dec_number(uint32 &i);
112	<	static enum Token get_char_number(uint32 &i);
110	>	static enum Token get_hex_number(uintptr &i);
111	>	static enum Token get_dec_number(uintptr &i);
112	>	static enum Token get_char_number(uintptr &i);
113		static enum Token get_string(char *str);
114	<	static enum Token get_hex_or_name(uint32 &i, char *name);
114	>	static enum Token get_hex_or_name(uintptr &i, char *name);
115
116	<	static bool eor_expr(uint32 *number); // Parser
117	<	static bool and_expr(uint32 *number);
118	<	static bool shift_expr(uint32 *number);
119	<	static bool add_expr(uint32 *number);
120	<	static bool mul_expr(uint32 *number);
121	<	static bool factor(uint32 *number);
112	<	static Variable lookup_var(const char s);
113	<	static Variable insert_var(const char s);
114	<	static void remove_var(const char *s);
116	>	static bool eor_expr(uintptr *number); // Parser
117	>	static bool and_expr(uintptr *number);
118	>	static bool shift_expr(uintptr *number);
119	>	static bool add_expr(uintptr *number);
120	>	static bool mul_expr(uintptr *number);
121	>	static bool factor(uintptr *number);
122
123
124		/*
#	Line 195 \| Line 202 \| bool mon_aborted(void)
202		* Access to buffer
203		*/
204
205	<	uint32 (*mon_read_byte)(uint32 adr);
205	>	uint32 (*mon_read_byte)(uintptr adr);
206
207	<	uint32 mon_read_byte_buffer(uint32 adr)
207	>	uint32 mon_read_byte_buffer(uintptr adr)
208		{
209		return mem[adr % mon_mem_size];
210		}
211
212	<	uint32 mon_read_byte_real(uint32 adr)
212	>	uint32 mon_read_byte_real(uintptr adr)
213		{
214		return (uint8 )adr;
215		}
216
217	<	void (*mon_write_byte)(uint32 adr, uint32 b);
217	>	void (*mon_write_byte)(uintptr adr, uint32 b);
218
219	<	void mon_write_byte_buffer(uint32 adr, uint32 b)
219	>	void mon_write_byte_buffer(uintptr adr, uint32 b)
220		{
221		mem[adr % mon_mem_size] = b;
222		}
223
224	<	void mon_write_byte_real(uint32 adr, uint32 b)
224	>	void mon_write_byte_real(uintptr adr, uint32 b)
225		{
226		(uint8 )adr = b;
227		}
228
229	<	uint32 mon_read_half(uint32 adr)
229	>	uint32 mon_read_half(uintptr adr)
230		{
231		return (mon_read_byte(adr) << 8) \| mon_read_byte(adr+1);
232		}
233
234	<	void mon_write_half(uint32 adr, uint32 w)
234	>	void mon_write_half(uintptr adr, uint32 w)
235		{
236		mon_write_byte(adr, w >> 8);
237		mon_write_byte(adr+1, w);
238		}
239
240	<	uint32 mon_read_word(uint32 adr)
240	>	uint32 mon_read_word(uintptr adr)
241		{
242		return (mon_read_byte(adr) << 24) \| (mon_read_byte(adr+1) << 16) \| (mon_read_byte(adr+2) << 8) \| mon_read_byte(adr+3);
243		}
244
245	<	void mon_write_word(uint32 adr, uint32 l)
245	>	void mon_write_word(uintptr adr, uint32 l)
246		{
247		mon_write_byte(adr, l >> 24);
248		mon_write_byte(adr+1, l >> 16);
#	Line 378 \| Line 385 \| enum Token mon_get_token(void)
385		}
386		}
387
388	<	static enum Token get_hex_number(uint32 &i)
388	>	static enum Token get_hex_number(uintptr &i)
389		{
390		char c = get_char();
391
#	Line 387 \| Line 394 \| static enum Token get_hex_number(uint32
394		return T_NULL;
395
396		do {
397	+	c = tolower(c);
398		if (c < 'a')
399		i = (i << 4) + (c - '0');
400		else
#	Line 402 \| Line 410 \| static enum Token get_hex_number(uint32
410		}
411		}
412
413	<	static enum Token get_dec_number(uint32 &i)
413	>	static enum Token get_dec_number(uintptr &i)
414		{
415		char c = get_char();
416
#	Line 423 \| Line 431 \| static enum Token get_dec_number(uint32
431		}
432		}
433
434	<	static enum Token get_char_number(uint32 &i)
434	>	static enum Token get_char_number(uintptr &i)
435		{
436		char c;
437
#	Line 454 \| Line 462 \| *static enum Token get_string(char str)**
462		return T_NULL;
463		}
464
465	<	static enum Token get_hex_or_name(uint32 &i, char *name)
465	>	static enum Token get_hex_or_name(uintptr &i, char *name)
466		{
467		char *old_in_ptr = in_ptr;
468		char c;
#	Line 482 \| Line 490 \| static enum Token get_hex_or_name(uint32
490		* true: OK, false: Error
491		*/
492
493	<	bool mon_expression(uint32 *number)
493	>	bool mon_expression(uintptr *number)
494		{
495	<	uint32 accu, expr;
495	>	uintptr accu, expr;
496
497		if (!eor_expr(&accu))
498		return false;
#	Line 510 \| Line 518 \| *bool mon_expression(uint32 number)**
518		* true: OK, false: Error
519		*/
520
521	<	static bool eor_expr(uint32 *number)
521	>	static bool eor_expr(uintptr *number)
522		{
523	<	uint32 accu, expr;
523	>	uintptr accu, expr;
524
525		if (!and_expr(&accu))
526		return false;
#	Line 538 \| Line 546 \| *static bool eor_expr(uint32 number)**
546		* true: OK, false: Error
547		*/
548
549	<	static bool and_expr(uint32 *number)
549	>	static bool and_expr(uintptr *number)
550		{
551	<	uint32 accu, expr;
551	>	uintptr accu, expr;
552
553		if (!shift_expr(&accu))
554		return false;
#	Line 566 \| Line 574 \| *static bool and_expr(uint32 number)**
574		* true: OK, false: Error
575		*/
576
577	<	static bool shift_expr(uint32 *number)
577	>	static bool shift_expr(uintptr *number)
578		{
579	<	uint32 accu, expr;
579	>	uintptr accu, expr;
580
581		if (!add_expr(&accu))
582		return false;
#	Line 601 \| Line 609 \| *static bool shift_expr(uint32 number)**
609		* true: OK, false: Error
610		*/
611
612	<	static bool add_expr(uint32 *number)
612	>	static bool add_expr(uintptr *number)
613		{
614	<	uint32 accu, expr;
614	>	uintptr accu, expr;
615
616		if (!mul_expr(&accu))
617		return false;
#	Line 636 \| Line 644 \| *static bool add_expr(uint32 number)**
644		* true: OK, false: Error
645		*/
646
647	<	static bool mul_expr(uint32 *number)
647	>	static bool mul_expr(uintptr *number)
648		{
649	<	uint32 accu, fact;
649	>	uintptr accu, fact;
650
651		if (!factor(&accu))
652		return false;
#	Line 686 \| Line 694 \| *static bool mul_expr(uint32 number)**
694		* true: OK, false: Error
695		*/
696
697	<	static bool factor(uint32 *number)
697	>	static bool factor(uintptr *number)
698		{
699		switch (mon_token) {
700		case T_NUMBER:
#	Line 695 \| Line 703 \| *static bool factor(uint32 number)**
703		return true;
704
705		case T_NAME:{
706	<	Variable *var;
707	<	if ((var = lookup_var(mon_name)) != NULL) {
708	<	*number = var->value;
706	>	var_map::const_iterator v = vars.find(mon_name);
707	>	if (v == vars.end())
708	>	return false;
709	>	else {
710	>	*number = v->second;
711		mon_get_token();
712		return true;
713	<	} else
704	<	return false;
713	>	}
714		}
715
716		case T_DOT:
#	Line 761 \| Line 770 \| *static bool factor(uint32 number)**
770
771
772		/*
764	–	* Lookup the value of a variable
765	–	*/
766	–
767	–	static Variable lookup_var(const char s)
768	–	{
769	–	// Lookup variable
770	–	for (Variable *var=first_var; var; var=var->next)
771	–	if (!strcmp(s, var->name))
772	–	return var;
773	–
774	–	// Not found, error
775	–	mon_error("Undefined variable");
776	–	return NULL;
777	–	}
778	–
779	–
780	–	/*
781	–	* Insert new variable (or redefine old)
782	–	*/
783	–
784	–	static Variable insert_var(const char s)
785	–	{
786	–	// Lookup variable
787	–	for (Variable *var=first_var; var; var=var->next)
788	–	if (!strcmp(s, var->name))
789	–	return var;
790	–
791	–	// Insert new variable
792	–	Variable *var = new Variable;
793	–	var->name = strdup(s);
794	–	var->next = first_var;
795	–	first_var = var;
796	–	return var;
797	–	}
798	–
799	–
800	–	/*
801	–	* Remove variable
802	–	*/
803	–
804	–	static void remove_var(const char *s)
805	–	{
806	–	Variable var, prev = (Variable *)&first_var;
807	–
808	–	// Lookup variable and remove it
809	–	for (var=prev->next; var; prev=var, var=var->next)
810	–	if (!strcmp(s, var->name)) {
811	–	prev->next = var->next;
812	–	free(var->name);
813	–	free(var);
814	–	return;
815	–	}
816	–	}
817	–
818	–
819	–	/*
773		* Set/clear/show variables
774		* set [var[=value]]
775		*/
#	Line 826 \| Line 779 \| static void set_var(void)
779		if (mon_token == T_END) {
780
781		// Show all variables
782	<	if (first_var == NULL)
782	>	if (vars.empty())
783		fprintf(monout, "No variables defined\n");
784	<	else
785	<	for (Variable *v=first_var; v; v=v->next)
786	<	fprintf(monout, "%s = %08x\n", v->name, v->value);
784	>	else {
785	>	var_map::const_iterator v = vars.begin(), end = vars.end();
786	>	for (v=vars.begin(); v!=end; ++v)
787	>	fprintf(monout, "%s = %08x\n", v->first.c_str(), v->second);
788	>	}
789
790		} else if (mon_token == T_NAME) {
791	<	char var_name[256];
837	<	strcpy(var_name, mon_name);
791	>	std::string var_name = mon_name;
792		mon_get_token();
793		if (mon_token == T_ASSIGN) {
794
795		// Set variable
796	<	uint32 value;
796	>	uintptr value;
797		mon_get_token();
798		if (!mon_expression(&value))
799		return;
#	Line 847 \| Line 801 \| static void set_var(void)
801		mon_error("Too many arguments");
802		return;
803		}
804	<	insert_var(var_name)->value = value;
804	>	vars[var_name] = value;
805
806		} else if (mon_token == T_END) {
807
808		// Clear variable
809	<	remove_var(var_name);
809	>	vars.erase(var_name);
810
811		} else
812		mon_error("'=' expected");
#	Line 868 \| Line 822 \| static void set_var(void)
822
823		static void clear_vars(void)
824		{
825	<	Variable var, next;
872	<	for (var=first_var; var; var=next) {
873	<	free(var->name);
874	<	next = var->next;
875	<	free(var);
876	<	}
877	<	first_var = NULL;
825	>	vars.clear();
826		}
827
828
#	Line 915 \| Line 863 \| static void mon_cmd_list(void)
863
864		static void reallocate(void)
865		{
866	<	uint32 size;
866	>	uintptr size;
867
868		if (mon_use_real_mem) {
869		fprintf(monerr, "Cannot reallocate buffer in real mode\n");
#	Line 948 \| Line 896 \| static void reallocate(void)
896
897		static void apply(int size)
898		{
899	<	uint32 adr, end_adr, value;
899	>	uintptr adr, end_adr, value;
900		char c;
901
902		if (!mon_expression(&adr))
#	Line 962 \| Line 910 \| static void apply(int size)
910		return;
911		}
912
913	<	uint32 (*read_func)(uint32 adr);
914	<	void (*write_func)(uint32 adr, uint32 val);
913	>	uint32 (*read_func)(uintptr adr);
914	>	void (*write_func)(uintptr adr, uint32 val);
915		switch (size) {
916		case 1:
917		read_func = mon_read_byte;
#	Line 1056 \| Line 1004 \| void mon_init(void)
1004		num_cmds = 0;
1005		cmd_help = NULL;
1006
1007	<	mon_add_command("??", mon_cmd_list, "?? Show list of commands\n");
1008	<	mon_add_command("ver", version, "ver Show version\n");
1009	<	mon_add_command("?", print_expr, "? expression Calculate expression\n");
1010	<	mon_add_command("@", reallocate, "@ [size] Reallocate buffer\n");
1011	<	mon_add_command("i", ascii_dump, "i [start [end]] ASCII memory dump\n");
1012	<	mon_add_command("m", memory_dump, "m [start [end]] Hex/ASCII memory dump\n");
1013	<	mon_add_command("b", binary_dump, "b [start [end]] Binary memory dump\n");
1014	<	mon_add_command("d", disassemble_ppc, "d [start [end]] Disassemble PowerPC code\n");
1015	<	mon_add_command("d65", disassemble_6502, "d65 [start [end]] Disassemble 6502 code\n");
1016	<	mon_add_command("d68", disassemble_680x0, "d68 [start [end]] Disassemble 680x0 code\n");
1017	<	mon_add_command("d80", disassemble_8080, "d80 [start [end]] Disassemble 8080 code\n");
1018	<	mon_add_command("d86", disassemble_80x86, "d86 [start [end]] Disassemble 80x86 code\n");
1019	<	mon_add_command(":", modify, ": start string Modify memory\n");
1020	<	mon_add_command("f", fill, "f start end string Fill memory\n");
1021	<	mon_add_command("y", apply_byte, "y[b\|h\|w] start end expr Apply expression to memory\n");
1007	>	mon_add_command("??", mon_cmd_list, "?? Show list of commands\n");
1008	>	mon_add_command("ver", version, "ver Show version\n");
1009	>	mon_add_command("?", print_expr, "? expression Calculate expression\n");
1010	>	mon_add_command("@", reallocate, "@ [size] Reallocate buffer\n");
1011	>	mon_add_command("i", ascii_dump, "i [start [end]] ASCII memory dump\n");
1012	>	mon_add_command("m", memory_dump, "m [start [end]] Hex/ASCII memory dump\n");
1013	>	mon_add_command("b", binary_dump, "b [start [end]] Binary memory dump\n");
1014	>	mon_add_command("d", disassemble_ppc, "d [start [end]] Disassemble PowerPC code\n");
1015	>	mon_add_command("d65", disassemble_6502, "d65 [start [end]] Disassemble 6502 code\n");
1016	>	mon_add_command("d68", disassemble_680x0, "d68 [start [end]] Disassemble 680x0 code\n");
1017	>	mon_add_command("d80", disassemble_z80, "d80 [start [end]] Disassemble Z80 code\n");
1018	>	mon_add_command("d86", disassemble_80x86_32, "d86 [start [end]] Disassemble 80x86 (32-bit) code\n");
1019	>	mon_add_command("d8086", disassemble_80x86_16, "d8086 [start [end]] Disassemble 80x86 (16-bit) code\n");
1020	>	mon_add_command("d8664", disassemble_x86_64, "d8664 [start [end]] Disassemble x86-64 code\n");
1021	>	mon_add_command(":", modify, ": start string Modify memory\n");
1022	>	mon_add_command("f", fill, "f start end string Fill memory\n");
1023	>	mon_add_command("y", apply_byte, "y[b\|h\|w] start end expr Apply expression to memory\n");
1024		mon_add_command("yb", apply_byte, NULL);
1025		mon_add_command("yh", apply_half, NULL);
1026		mon_add_command("yw", apply_word, NULL);
1027	<	mon_add_command("t", transfer, "t start end dest Transfer memory\n");
1028	<	mon_add_command("c", compare, "c start end dest Compare memory\n");
1029	<	mon_add_command("h", help_or_hunt, "h start end string Search for byte string\n");
1030	<	mon_add_command("\\", shell_command, "\\ \"command\" Execute shell command\n");
1031	<	mon_add_command("ls", mon_exec, "ls [args] List directory contents\n");
1032	<	mon_add_command("rm", mon_exec, "rm [args] Remove file(s)\n");
1033	<	mon_add_command("cp", mon_exec, "cp [args] Copy file(s)\n");
1034	<	mon_add_command("mv", mon_exec, "mv [args] Move file(s)\n");
1035	<	mon_add_command("cd", mon_change_dir, "cd directory Change current directory\n");
1036	<	mon_add_command("o", redir_output, "o [\"file\"] Redirect output\n");
1037	<	mon_add_command("[", load_data, "[ start \"file\" Load data from file\n");
1038	<	mon_add_command("]", save_data, "] start size \"file\" Save data to file\n");
1039	<	mon_add_command("set", set_var, "set [var[=value]] Set/clear/show variables\n");
1040	<	mon_add_command("cv", clear_vars, "cv Clear all variables\n");
1027	>	mon_add_command("t", transfer, "t start end dest Transfer memory\n");
1028	>	mon_add_command("c", compare, "c start end dest Compare memory\n");
1029	>	mon_add_command("h", help_or_hunt, "h start end string Search for byte string\n");
1030	>	mon_add_command("\\", shell_command, "\\ \"command\" Execute shell command\n");
1031	>	mon_add_command("ls", mon_exec, "ls [args] List directory contents\n");
1032	>	mon_add_command("rm", mon_exec, "rm [args] Remove file(s)\n");
1033	>	mon_add_command("cp", mon_exec, "cp [args] Copy file(s)\n");
1034	>	mon_add_command("mv", mon_exec, "mv [args] Move file(s)\n");
1035	>	mon_add_command("cd", mon_change_dir, "cd directory Change current directory\n");
1036	>	mon_add_command("o", redir_output, "o [\"file\"] Redirect output\n");
1037	>	mon_add_command("[", load_data, "[ start \"file\" Load data from file\n");
1038	>	mon_add_command("]", save_data, "] start size \"file\" Save data to file\n");
1039	>	mon_add_command("set", set_var, "set [var[=value]] Set/clear/show variables\n");
1040	>	mon_add_command("cv", clear_vars, "cv Clear all variables\n");
1041
1042		mon_read_byte = NULL;
1043		mon_write_byte = NULL;
#	Line 1121 \| Line 1071 \| void mon(int argc, char argv)**
1071		monout = stdout;
1072		monerr = stdout;
1073
1074	<	if (argc) {
1075	<	// Access real memory if mon was started as "rmon"
1076	<	char *prgname = argv[0];
1077	<	char *lastslash;
1078	<	if ((lastslash = strrchr(prgname, '/')) != NULL)
1079	<	prgname = lastslash + 1;
1080	<	if (strcmp(prgname, "rmon") == 0)
1074	>	// Make argc/argv point to the actual arguments
1075	>	const char *prg_name = argv[0];
1076	>	if (argc)
1077	>	argc--; argv++;
1078	>
1079	>	// Parse arguments
1080	>	mon_macos_mode = false;
1081	>	mon_use_real_mem = false;
1082	>	while (argc > 0) {
1083	>	if (strcmp(argv[0], "-h") == 0 \|\| strcmp(argv[0], "--help") == 0) {
1084	>	printf("Usage: %s [-m] [-r] [command...]\n", prg_name);
1085	>	exit(0);
1086	>	} else if (strcmp(argv[0], "-m") == 0)
1087	>	mon_macos_mode = true;
1088	>	else if (strcmp(argv[0], "-r") == 0)
1089		mon_use_real_mem = true;
1090	<
1091	<	// Make argc/argv point to the actual arguments
1092	<	argc--;
1135	<	argv++;
1136	<	interactive = (argc == 0);
1090	>	else
1091	>	break;
1092	>	argc--; argv++;
1093		}
1094	+	interactive = (argc == 0);
1095
1096		// Set up memory access functions if not supplied by the user
1097		if (mon_read_byte == NULL) {
#	Line 1157 \| Line 1114 \| void mon(int argc, char argv)**
1114
1115		// Print banner
1116		if (interactive)
1117	<	fprintf(monerr, "\n * mon V" VERSION " by Christian Bauer and Marc Hellwig *\n"
1118	<	" * Press 'h' for help *\n\n");
1117	>	fprintf(monerr, "\n * cxmon V" VERSION " by Christian Bauer and Marc Hellwig *\n"
1118	>	" * Press 'h' for help *\n\n");
1119	>	}
1120	>
1121	>	// Clear variables
1122	>	vars.clear();
1123	>
1124	>	// In MacOS mode, pull in the lowmem globals as variables
1125	>	if (mon_macos_mode) {
1126	>	const lowmem_info *l = lowmem;
1127	>	while (l->name) {
1128	>	vars[l->name] = l->addr;
1129	>	l++;
1130	>	}
1131		}
1132
1133		init_abort();
#	Line 1167 \| Line 1136 \| void mon(int argc, char argv)**
1136		while (!done) {
1137		if (interactive) {
1138		char prompt[16];
1139	<	sprintf(prompt, "[%08x]-> ", mon_dot_address);
1139	>	sprintf(prompt, "[%0lx]-> ", 2 sizeof(mon_dot_address), mon_dot_address);
1140		read_line(prompt);
1141		} else {
1142		if (argc == 0) {

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing mon/src/mon.cpp (file contents): Revision 1.6 by cebix, 2000-04-24T13:10:00Z vs. Revision 1.20 by gbeauche, 2002-09-07T12:48:15Z

Diff Legend

Comparing mon/src/mon.cpp (file contents):
Revision 1.6 by cebix, 2000-04-24T13:10:00Z vs.
Revision 1.20 by gbeauche, 2002-09-07T12:48:15Z