mon/src/mon.cpp

/*
 *  mon.cpp - mon main program
 *
 *  mon (C) 1997-1999 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
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "sysdeps.h"

#ifdef HAVE_READLINE_READLINE_H
extern "C" {
#include <readline/readline.h>
}
#endif

#ifdef HAVE_READLINE_HISTORY_H
extern "C" {
#include <readline/history.h>
}
#endif

#include "mon.h"
#include "mon_cmd.h"
#include "version.h"


// Buffer we're operating on
bool mon_use_real_mem = false;
uint32 mon_mem_size;
static uint8 *mem;


// Streams for input, output and error messages
FILE *monin, *monout, *monerr;

// Input line
static char input[INPUT_LENGTH];
static char *in_ptr;
char *mon_args_ptr;

// Current address, value of '.' in expressions
uint32 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


// List of installed commands
struct CmdSpec {
        const char *name;       // Name of command
        void (*func)(void);     // 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


// 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


// Prototypes
static void init_abort(void);
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_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);


/*
 *  Add command to mon
 */

void mon_add_command(const char *name, void (*func)(void), const char *help_text)
{
        num_cmds++;
        if (cmds)
                cmds = (CmdSpec *)realloc(cmds, num_cmds * sizeof(CmdSpec));
        else
                cmds = (CmdSpec *)malloc(sizeof(CmdSpec));
        cmds[num_cmds - 1].name = name;
        cmds[num_cmds - 1].func = func;
        if (help_text) {
                if (cmd_help) {
                        cmd_help = (char *)realloc(cmd_help, strlen(cmd_help) + strlen(help_text) + 1);
                        strcat(cmd_help, help_text);
                } else
                        cmd_help = strdup(help_text);
        }
}


/*
 *  Print error message
 */

void mon_error(const char *s)
{
        fprintf(monerr, "*** %s\n", s);
}


/*
 *  CTRL-C pressed?
 */

static bool was_aborted;
static struct sigaction my_sa;

#ifdef __BEOS__
static void handle_abort(int sig, void *arg, vregs *r)
#else
static void handle_abort(int sig)
#endif
{
        was_aborted = true;
}

static void init_abort(void)
{
        was_aborted = false;
        sigemptyset(&my_sa.sa_mask);
#ifdef __BEOS__
        my_sa.sa_handler = (__signal_func_ptr)handle_abort;
        my_sa.sa_userdata = 0;
#else
        my_sa.sa_handler = handle_abort;
#endif
        my_sa.sa_flags = 0;
        sigaction(SIGINT, &my_sa, NULL);
}

static void exit_abort(void)
{
        my_sa.sa_handler = SIG_DFL;
        sigaction(SIGINT, &my_sa, NULL);
}

bool mon_aborted(void)
{
        bool ret = was_aborted;
        was_aborted = false;
        return ret;
}


/*
 *  Access to buffer
 */

uint32 mon_read_byte(uint32 adr)
{
        if (mon_use_real_mem)
                return *(uint8 *)adr;
        else
                return mem[adr % mon_mem_size];
}

void mon_write_byte(uint32 adr, uint32 b)
{
        if (mon_use_real_mem)
                *(uint8 *)adr = b;
        else
                mem[adr % mon_mem_size] = b;
}

uint32 mon_read_half(uint32 adr)
{
        if (mon_use_real_mem)
                return ntohs(*(uint16 *)adr);
        else
                return mem[adr % mon_mem_size] << 8 | mem[(adr+1) % mon_mem_size];
}

void mon_write_half(uint32 adr, uint32 w)
{
        if (mon_use_real_mem)
                *(uint16 *)adr = htons(w);
        else {
                mem[adr % mon_mem_size] = w >> 8;
                mem[(adr+1) % mon_mem_size] = w;
        }
}

uint32 mon_read_word(uint32 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);
}

void mon_write_word(uint32 adr, uint32 l)
{
        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;
        }
}


/*
 *  Read a line from the keyboard
 */

static void read_line(char *prompt)
{
#ifdef HAVE_LIBREADLINE
        static char *line_read = NULL;

        if (line_read) {
                free(line_read);
                line_read = NULL;
        }

        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;
#else
        fprintf(monout, prompt);
        fflush(monout);
        fgets(in_ptr = input, INPUT_LENGTH, monin);
        char *s = strchr(input, '\n');
        if (s != NULL)
                *s = 0;
#endif
}


/*
 *  Read a character from the input line
 */

static char get_char(void)
{
        return *in_ptr++;
}


/*
 *  Stuff back a character into the input line
 */

static void put_back(char c)
{
        *(--in_ptr) = c;
}


/*
 *  Scanner: Get a token from the input line
 */

enum Token mon_get_token(void)
{
        char c;

        // Skip spaces
        while ((c = get_char()) == ' ') ;

        switch (c) {
                case 0:
                        return mon_token = T_END;
                case '(':
                        return mon_token = T_LPAREN;
                case ')':
                        return mon_token = T_RPAREN;
                case '.':
                        return mon_token = T_DOT;
                case ':':
                        return mon_token = T_COLON;
                case ',':
                        return mon_token = T_COMMA;
                case '+':
                        return mon_token = T_PLUS;
                case '-':
                        return mon_token = T_MINUS;
                case '*':
                        return mon_token = T_MUL;
                case '/':
                        return mon_token = T_DIV;
                case '%':
                        return mon_token = T_MOD;
                case '&':
                        return mon_token = T_AND;
                case '|':
                        return mon_token = T_OR;
                case '^':
                        return mon_token = T_EOR;
                case '<':
                        if (get_char() == '<')
                                return mon_token = T_SHIFTL;
                        else {
                                mon_error("Unrecognized token");
                                return mon_token = T_NULL;
                        }
                case '>':
                        if (get_char() == '>')
                                return mon_token = T_SHIFTR;
                        else {
                                mon_error("Unrecognized token");
                                return mon_token = T_NULL;
                        }
                case '~':
                        return mon_token = T_NOT;
                case '=':
                        return mon_token = T_ASSIGN;

                case '$':
                        if ((mon_token = get_hex_number(mon_number)) == T_NULL)
                                mon_error("'$' must be followed by hexadecimal number");
                        return mon_token;
                case '_':
                        if ((mon_token = get_dec_number(mon_number)) == T_NULL)
                                mon_error("'_' must be followed by decimal number");
                        return mon_token;
                case '\'':
                        return mon_token = get_char_number(mon_number);
                case '"':
                        return mon_token = get_string(mon_string);

                default:
                        if (isalnum(c)) {
                                put_back(c);
                                return mon_token = get_hex_or_name(mon_number, mon_name);
                        }
                        mon_error("Unrecognized token");
                        return mon_token = T_NULL;
        }
}

static enum Token get_hex_number(uint32 &i)
{
        char c = get_char();

        i = 0;
        if (!isxdigit(c))
                return T_NULL;

        do {
                if (c < 'a')
                        i = (i << 4) + (c - '0');
                else
                        i = (i << 4) + (c - 'a' + 10);
                c = get_char();
        } while (isxdigit(c));

        if (isalnum(c))
                return T_NULL;
        else {
                put_back(c);
                return T_NUMBER;
        }
}

static enum Token get_dec_number(uint32 &i)
{
        char c = get_char();

        i = 0;
        if (!isdigit(c))
                return T_NULL;

        do {
                i = (i * 10) + (c - '0');
                c = get_char();
        } while (isdigit(c));

        if (isalnum(c))
                return T_NULL;
        else {
                put_back(c);
                return T_NUMBER;
        }
}

static enum Token get_char_number(uint32 &i)
{
        char c;

        i = 0;
        while ((c = get_char()) != 0) {
                if (c == '\'')
                        return T_NUMBER;
                i = (i << 8) + (uint8)c;
        }

        mon_error("Unterminated character constant");
        return T_NULL;
}

static enum Token get_string(char *str)
{
        char c;

        while ((c = get_char()) != 0) {
                if (c == '"') {
                        *str = 0;
                        return T_STRING;
                }
                *str++ = c;
        }

        mon_error("Unterminated string");
        return T_NULL;
}

static enum Token get_hex_or_name(uint32 &i, char *name)
{
        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
        in_ptr = old_in_ptr;
        c = get_char();
        do {
                *name++ = c;
                c = get_char();
        } while (isalnum(c));

        *name = 0;
        put_back(c);
        return T_NAME;
}


/*
 *  expression = eor_expr {OR eor_expr}
 *  true: OK, false: Error
 */

bool mon_expression(uint32 *number)
{
        uint32 accu, expr;

        if (!eor_expr(&accu))
                return false;

        for (;;)
                switch (mon_token) {
                        case T_OR:
                                mon_get_token();
                                if (!eor_expr(&expr))
                                        return false;
                                accu |= expr;
                                break;

                        default:
                                *number = accu;
                                return true;
                }
}


/*
 *  eor_expr = and_expr {EOR and_expr}
 *  true: OK, false: Error
 */

static bool eor_expr(uint32 *number)
{
        uint32 accu, expr;

        if (!and_expr(&accu))
                return false;

        for (;;)
                switch (mon_token) {
                        case T_EOR:
                                mon_get_token();
                                if (!and_expr(&expr))
                                        return false;
                                accu ^= expr;
                                break;

                        default:
                                *number = accu;
                                return true;
                }
}


/*
 *  and_expr = shift_expr {AND shift_expr}
 *  true: OK, false: Error
 */

static bool and_expr(uint32 *number)
{
        uint32 accu, expr;

        if (!shift_expr(&accu))
                return false;

        for (;;)
                switch (mon_token) {
                        case T_AND:
                                mon_get_token();
                                if (!shift_expr(&expr))
                                        return false;
                                accu &= expr;
                                break;

                        default:
                                *number = accu;
                                return true;
                }
}


/*
 *  shift_expr = add_expr {(SHIFTL | SHIFTR) add_expr}
 *  true: OK, false: Error
 */

static bool shift_expr(uint32 *number)
{
        uint32 accu, expr;

        if (!add_expr(&accu))
                return false;

        for (;;)
                switch (mon_token) {
                        case T_SHIFTL:
                                mon_get_token();
                                if (!add_expr(&expr))
                                        return false;
                                accu <<= expr;
                                break;

                        case T_SHIFTR:
                                mon_get_token();
                                if (!add_expr(&expr))
                                        return false;
                                accu >>= expr;
                                break;

                        default:
                                *number = accu;
                                return true;
                }
}


/*
 *  add_expr = mul_expr {(PLUS | MINUS) mul_expr}
 *  true: OK, false: Error
 */

static bool add_expr(uint32 *number)
{
        uint32 accu, expr;

        if (!mul_expr(&accu))
                return false;

        for (;;)
                switch (mon_token) {
                        case T_PLUS:
                                mon_get_token();
                                if (!mul_expr(&expr))
                                        return false;
                                accu += expr;
                                break;

                        case T_MINUS:
                                mon_get_token();
                                if (!mul_expr(&expr))
                                        return false;
                                accu -= expr;
                                break;

                        default:
                                *number = accu;
                                return true;
                }
}


/*
 *  mul_expr = factor {(MUL | DIV | MOD) factor}
 *  true: OK, false: Error
 */

static bool mul_expr(uint32 *number)
{
        uint32 accu, fact;

        if (!factor(&accu))
                return false;

        for (;;)
                switch (mon_token) {
                        case T_MUL:
                                mon_get_token();
                                if (!factor(&fact))
                                        return false;
                                accu *= fact;
                                break;

                        case T_DIV:
                                mon_get_token();
                                if (!factor(&fact))
                                        return false;
                                if (fact == 0) {
                                        mon_error("Division by 0");
                                        return false;
                                }
                                accu /= fact;
                                break;

                        case T_MOD:
                                mon_get_token();
                                if (!factor(&fact))
                                        return false;
                                if (fact == 0) {
                                        mon_error("Division by 0");
                                        return false;
                                }
                                accu %= fact;
                                break;

                        default:
                                *number = accu;
                                return true;
                }
}


/*
 *  factor = NUMBER | NAME | DOT | COLON | (PLUS | MINUS | NOT) factor | LPAREN expression RPAREN
 *  true: OK, false: Error
 */

static bool factor(uint32 *number)
{
        switch (mon_token) {
                case T_NUMBER:
                        *number = mon_number;
                        mon_get_token();
                        return true;

                case T_NAME:{
                        Variable *var;
                        if ((var = lookup_var(mon_name)) != NULL) {
                                *number = var->value;
                                mon_get_token();
                                return true;
                        } else
                                return false;
                }

                case T_DOT:
                        *number = mon_dot_address;
                        mon_get_token();
                        return true;

                case T_COLON:
                        *number = colon_value;
                        mon_get_token();
                        return true;

                case T_PLUS:
                        mon_get_token();
                        return factor(number);

                case T_MINUS:
                        mon_get_token();
                        if (factor(number)) {
                                *number = -*number;
                                return true;
                        } else
                                return false;

                case T_NOT:
                        mon_get_token();
                        if (factor(number)) {
                                *number = ~*number;
                                return true;
                        } else
                                return false;

                case T_LPAREN:
                        mon_get_token();
                        if (mon_expression(number))
                                if (mon_token == T_RPAREN) {
                                        mon_get_token();
                                        return true;
                                } else {
                                        mon_error("Missing ')'");
                                        return false;
                                }
                        else {
                                mon_error("Error in expression");
                                return false;
                        }

                case T_END:
                        mon_error("Required argument missing");
                        return false;

                default:
                        mon_error("'(' or number expected");
                        return false;
        }
}


/*
 *  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)
{
        if (mon_token == T_END) {

                // Show all variables
                if (first_var == NULL)
                        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 if (mon_token == T_NAME) {
                char var_name[256];
                strcpy(var_name, mon_name);
                mon_get_token();
                if (mon_token == T_ASSIGN) {

                        // Set variable
                        uint32 value;
                        mon_get_token();
                        if (!mon_expression(&value))
                                return;
                        if (mon_token != T_END) {
                                mon_error("Too many arguments");
                                return;
                        }
                        insert_var(var_name)->value = value;

                } else if (mon_token == T_END) {

                        // Clear variable
                        remove_var(var_name);

                } else
                        mon_error("'=' expected");
        } else
                mon_error("Variable name expected");
}


/*
 *  Clear all variables
 *  cv
 */

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;
}


/*
 *  Display help
 *  h
 */

static void help_or_hunt(void)
{
        if (mon_token != T_END) {
                hunt();
                return;
        }
        fprintf(monout, "x                        Quit mon\n"
                                        "h                        This help text\n");
        fprintf(monout, cmd_help);
}


/*
 *  Display command list
 *  ??
 */

static void mon_cmd_list(void)
{
        for (int i=0; i<num_cmds; i++)
                fprintf(monout, "%s ", cmds[i].name);
        fprintf(monout, "\n");
}


/*
 *  Reallocate buffer
 *  @ [size]
 */

static void reallocate(void)
{
        uint32 size;

        if (mon_use_real_mem) {
                fprintf(monerr, "Cannot reallocate buffer in real mode\n");
                return;
        }

        if (mon_token == T_END) {
                fprintf(monerr, "Buffer size: %08x bytes\n", mon_mem_size);
                return;
        }

        if (!mon_expression(&size))
                return;
        if (mon_token != T_END) {
                mon_error("Too many arguments");
                return;
        }

        if ((mem = (uint8 *)realloc(mem, size)) != NULL)
                fprintf(monerr, "Buffer size: %08x bytes\n", mon_mem_size = size);
        else
                fprintf(monerr, "Unable to reallocate buffer\n");
}


/*
 *  Apply expression to memory
 *  y[b|h|w] start end expression
 */

static void apply(int size)
{
        uint32 adr, end_adr, value;
        char c;

        if (!mon_expression(&adr))
                return;
        if (!mon_expression(&end_adr))
                return;
        if (!mon_expression(&value))
                return;
        if (mon_token != T_END) {
                mon_error("Too many arguments");
                return;
        }

        uint32 (*read_func)(uint32 adr);
        void (*write_func)(uint32 adr, uint32 val);
        switch (size) {
                case 1:
                        read_func = mon_read_byte;
                        write_func = mon_write_byte;
                        break;
                case 2:
                        read_func = mon_read_half;
                        write_func = mon_write_half;
                        break;
                case 4:
                        read_func = mon_read_word;
                        write_func = mon_write_word;
                        break;
                default:
                        abort();
                        break;
        }

        while (adr<=end_adr) {
                colon_value = read_func(adr);
                mon_dot_address = adr;

                in_ptr = input;
                while ((c = get_char()) == ' ') ;
                while ((c = get_char()) != ' ') ;
                while ((c = get_char()) == ' ') ;
                put_back(c);
                mon_get_token();
                mon_expression(&value); // Skip start address
                mon_expression(&value); // Skip end address
                mon_expression(&value);

                write_func(adr, value);
                adr += size;
        }

        mon_dot_address = adr;
}

static void apply_byte(void)
{
        apply(1);
}

static void apply_half(void)
{
        apply(2);
}

static void apply_word(void)
{
        apply(4);
}


/*
 *  Execute command via system() (for ls, rm, etc.)
 */

static void mon_exec(void)
{
        system(input);
}


/*
 *  Change current directory
 */

static void mon_change_dir(void)
{
        char c;
        in_ptr = input;
        while ((c = get_char()) == ' ') ;
        while ((c = get_char()) != ' ') ;
        while ((c = get_char()) == ' ') ;
        put_back(c);
        if (chdir(in_ptr) != 0)
                mon_error("Cannot change directory");
}


/*
 *  Initialize mon
 */

void mon_init(void)
{
        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("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");
}


/*
 *  Deinitialize mon
 */

void mon_exit(void)
{
        free(cmds);
        cmds = NULL;
        num_cmds = 0;
        cmd_help = NULL;
}


/*
 *  Main function, read-execute loop
 */

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)
                        mon_use_real_mem = true;

                // Make argc/argv point to the actual arguments
                argc--;
                argv++;
                interactive = (argc == 0);
        }

        // Allocate buffer
        if (!mon_use_real_mem) {
                mon_mem_size = 0x100000;
                mem = (uint8 *)malloc(mon_mem_size);

                // 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);
        }

        init_abort();

        // Read and parse command line
        while (!done) {
                if (interactive) {
                        char prompt[16];
                        sprintf(prompt, "[%08x]-> ", mon_dot_address);
                        read_line(prompt);
                } else {
                        if (argc == 0) {
                                done = true;
                                break;
                        } else {
                                strncpy(in_ptr = input, argv[0], INPUT_LENGTH);
                                argc--;
                                argv++;
                        }
                }

                // Skip leading spaces
                while ((c = get_char()) == ' ') ;

                // Read command word
                char *p = cmd;
                do {
                        *p++ = c;
                        c = get_char();
                } while (isgraph(c));
                *p = 0;
                put_back(c);

                // Execute command
                if (cmd[0] == 0)                                // Blank line
                        continue;
                if (strcmp(cmd, "x") == 0) {    // Exit
                        done = true;
                        continue;
                }
                for (int i=0; i<num_cmds; i++) {
                        if (strcmp(cmd, cmds[i].name) == 0) {
                                mon_get_token();
                                cmds[i].func();
                                goto cmd_done;
                        }
                }
                mon_error("Unknown command");
cmd_done: ;
        }

        exit_abort();

        // Free buffer
        if (!mon_use_real_mem)
                free(mem);

        // Close output file if redirected
        if (monout != monerr)
                fclose(monout);
}
Revision:	1.4
Committed:	1999-10-05T18:19:55Z (25 years, 1 month ago) by cebix
Branch:	MAIN
Changes since 1.3:	+9 -0 lines
Log Message:	- should now compile on systems without libreadline