ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/mon/src/mon.cpp
(Generate patch)

Comparing mon/src/mon.cpp (file contents):
Revision 1.10 by cebix, 2000-09-25T12:44:31Z vs.
Revision 1.19 by cebix, 2002-08-03T14:54:28Z

# 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   #if defined(HAVE_READLINE_H)
31   extern "C" {
# Line 47 | 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 "2"
55 > #define VERSION "3"
56   #endif
57  
58  
# Line 68 | 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 76 | 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 93 | 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)
98 <        char *name;             // Variable name
99 <        uint32 value;   // Variable value
100 < };
101 <
102 < 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 109 | 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);
124 < static Variable *lookup_var(const char *s);
125 < static Variable *insert_var(const char *s);
126 < 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 207 | 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 390 | 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 399 | 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 414 | 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 435 | 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 466 | 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 494 | 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 522 | 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 550 | 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 578 | 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 613 | 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 648 | 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 698 | 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 707 | 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
716 <                                return false;
713 >                        }
714                  }
715  
716                  case T_DOT:
# Line 773 | Line 770 | static bool factor(uint32 *number)
770  
771  
772   /*
776 – *  Lookup the value of a variable
777 – */
778 –
779 – static Variable *lookup_var(const char *s)
780 – {
781 –        // Lookup variable
782 –        for (Variable *var=first_var; var; var=var->next)
783 –                if (!strcmp(s, var->name))
784 –                        return var;
785 –
786 –        // Not found, error
787 –        mon_error("Undefined variable");
788 –        return NULL;
789 – }
790 –
791 –
792 – /*
793 – *  Insert new variable (or redefine old)
794 – */
795 –
796 – static Variable *insert_var(const char *s)
797 – {
798 –        // Lookup variable
799 –        for (Variable *var=first_var; var; var=var->next)
800 –                if (!strcmp(s, var->name))
801 –                        return var;
802 –
803 –        // Insert new variable
804 –        Variable *var = new Variable;
805 –        var->name = strdup(s);
806 –        var->next = first_var;
807 –        first_var = var;
808 –        return var;
809 – }
810 –
811 –
812 – /*
813 – *  Remove variable
814 – */
815 –
816 – static void remove_var(const char *s)
817 – {
818 –        Variable *var, *prev = (Variable *)&first_var;
819 –
820 –        // Lookup variable and remove it
821 –        for (var=prev->next; var; prev=var, var=var->next)
822 –                if (!strcmp(s, var->name)) {
823 –                        prev->next = var->next;
824 –                        free(var->name);
825 –                        free(var);
826 –                        return;
827 –                }
828 – }
829 –
830 –
831 – /*
773   *  Set/clear/show variables
774   *  set [var[=value]]
775   */
# Line 838 | 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];
849 <                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 859 | 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 880 | Line 822 | static void set_var(void)
822  
823   static void clear_vars(void)
824   {
825 <        Variable *var, *next;
884 <        for (var=first_var; var; var=next) {
885 <                free(var->name);
886 <                next = var->next;
887 <                free(var);
888 <        }
889 <        first_var = NULL;
825 >        vars.clear();
826   }
827  
828  
# Line 927 | 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 960 | 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 974 | 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 1068 | 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(":", modify,                                    ": start string           Modify memory\n");
1021 >        mon_add_command("f", fill,                                              "f start end string       Fill memory\n");
1022 >        mon_add_command("y", apply_byte,                                "y[b|h|w] start end expr  Apply expression to memory\n");
1023          mon_add_command("yb", apply_byte, NULL);
1024          mon_add_command("yh", apply_half, NULL);
1025          mon_add_command("yw", apply_word, NULL);
1026 <        mon_add_command("t", transfer,                          "t start end dest         Transfer memory\n");
1027 <        mon_add_command("c", compare,                           "c start end dest         Compare memory\n");
1028 <        mon_add_command("h", help_or_hunt,                      "h start end string       Search for byte string\n");
1029 <        mon_add_command("\\", shell_command,            "\\ \"command\"              Execute shell command\n");
1030 <        mon_add_command("ls", mon_exec,                         "ls [args]                List directory contents\n");
1031 <        mon_add_command("rm", mon_exec,                         "rm [args]                Remove file(s)\n");
1032 <        mon_add_command("cp", mon_exec,                         "cp [args]                Copy file(s)\n");
1033 <        mon_add_command("mv", mon_exec,                         "mv [args]                Move file(s)\n");
1034 <        mon_add_command("cd", mon_change_dir,           "cd directory             Change current directory\n");
1035 <        mon_add_command("o", redir_output,                      "o [\"file\"]               Redirect output\n");
1036 <        mon_add_command("[", load_data,                         "[ start \"file\"           Load data from file\n");
1037 <        mon_add_command("]", save_data,                         "] start size \"file\"      Save data to file\n");
1038 <        mon_add_command("set", set_var,                         "set [var[=value]]        Set/clear/show variables\n");
1039 <        mon_add_command("cv", clear_vars,                       "cv                       Clear all variables\n");
1026 >        mon_add_command("t", transfer,                                  "t start end dest         Transfer memory\n");
1027 >        mon_add_command("c", compare,                                   "c start end dest         Compare memory\n");
1028 >        mon_add_command("h", help_or_hunt,                              "h start end string       Search for byte string\n");
1029 >        mon_add_command("\\", shell_command,                    "\\ \"command\"              Execute shell command\n");
1030 >        mon_add_command("ls", mon_exec,                                 "ls [args]                List directory contents\n");
1031 >        mon_add_command("rm", mon_exec,                                 "rm [args]                Remove file(s)\n");
1032 >        mon_add_command("cp", mon_exec,                                 "cp [args]                Copy file(s)\n");
1033 >        mon_add_command("mv", mon_exec,                                 "mv [args]                Move file(s)\n");
1034 >        mon_add_command("cd", mon_change_dir,                   "cd directory             Change current directory\n");
1035 >        mon_add_command("o", redir_output,                              "o [\"file\"]               Redirect output\n");
1036 >        mon_add_command("[", load_data,                                 "[ start \"file\"           Load data from file\n");
1037 >        mon_add_command("]", save_data,                                 "] start size \"file\"      Save data to file\n");
1038 >        mon_add_command("set", set_var,                                 "set [var[=value]]        Set/clear/show variables\n");
1039 >        mon_add_command("cv", clear_vars,                               "cv                       Clear all variables\n");
1040  
1041          mon_read_byte = NULL;
1042          mon_write_byte = NULL;
# Line 1133 | Line 1070 | void mon(int argc, char **argv)
1070          monout = stdout;
1071          monerr = stdout;
1072  
1073 <        if (argc) {
1074 <                // Access real memory if mon was started as "rmon"
1075 <                char *prgname = argv[0];
1076 <                char *lastslash;
1077 <                if ((lastslash = strrchr(prgname, '/')) != NULL)
1078 <                        prgname = lastslash + 1;
1079 <                if (strcmp(prgname, "rmon") == 0)
1073 >        // Make argc/argv point to the actual arguments
1074 >        const char *prg_name = argv[0];
1075 >        if (argc)
1076 >                argc--; argv++;
1077 >
1078 >        // Parse arguments
1079 >        mon_macos_mode = false;
1080 >        mon_use_real_mem = false;
1081 >        while (argc > 0) {
1082 >                if (strcmp(argv[0], "-h") == 0 || strcmp(argv[0], "--help") == 0) {
1083 >                        printf("Usage: %s [-m] [-r] [command...]\n", prg_name);
1084 >                        exit(0);
1085 >                } else if (strcmp(argv[0], "-m") == 0)
1086 >                        mon_macos_mode = true;
1087 >                else if (strcmp(argv[0], "-r") == 0)
1088                          mon_use_real_mem = true;
1089 <
1090 <                // Make argc/argv point to the actual arguments
1091 <                argc--;
1147 <                argv++;
1148 <                interactive = (argc == 0);
1089 >                else
1090 >                        break;
1091 >                argc--; argv++;
1092          }
1093 +        interactive = (argc == 0);
1094  
1095          // Set up memory access functions if not supplied by the user
1096          if (mon_read_byte == NULL) {
# Line 1169 | Line 1113 | void mon(int argc, char **argv)
1113  
1114                  // Print banner
1115                  if (interactive)
1116 <                        fprintf(monerr, "\n *** mon V" VERSION " by Christian Bauer and Marc Hellwig ***\n"
1117 <                                                        " ***              Press 'h' for help              ***\n\n");
1116 >                        fprintf(monerr, "\n *** cxmon V" VERSION " by Christian Bauer and Marc Hellwig ***\n"
1117 >                                                        " ***               Press 'h' for help               ***\n\n");
1118 >        }
1119 >
1120 >        // Clear variables
1121 >        vars.clear();
1122 >
1123 >        // In MacOS mode, pull in the lowmem globals as variables
1124 >        if (mon_macos_mode) {
1125 >                const lowmem_info *l = lowmem;
1126 >                while (l->name) {
1127 >                        vars[l->name] = l->addr;
1128 >                        l++;
1129 >                }
1130          }
1131  
1132          init_abort();
# Line 1179 | Line 1135 | void mon(int argc, char **argv)
1135          while (!done) {
1136                  if (interactive) {
1137                          char prompt[16];
1138 <                        sprintf(prompt, "[%08x]-> ", mon_dot_address);
1138 >                        sprintf(prompt, "[%0*lx]-> ", 2 * sizeof(mon_dot_address), mon_dot_address);
1139                          read_line(prompt);
1140                  } else {
1141                          if (argc == 0) {

Diff Legend

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