arch.h File Reference

#include <stdint.h>

Go to the source code of this file.

Classes
struct	gdb_reg

Typedefs
typedef struct gdb_reg	gdb_reg_t

Functions
gdb_reg_t *	arch_parse_reg_profile (const char *reg_profile)

Typedef Documentation

gdb_reg_t

typedef struct gdb_reg gdb_reg_t

This struct defines a generic register view

Function Documentation

arch_parse_reg_profile()

gdb_reg_t* arch_parse_reg_profile

(

const char *

reg_profile

)

Definition at line 46 of file arch.c.

                                                           {
    char *tok[PARSER_MAX_TOKENS];
    char tmp[128];
    int i, j, l;
    const char *p = reg_profile;
    RzList *gdb_regs_list = rz_list_newf(free);
    RzListIter *iter;
    gdb_reg_t *reg;
 
    // Line number
    l = 0;
    // For every line
    do {
        // Increment line number
        l++;
        // Skip comment lines
        if (*p == '#') {
            const char *q = p;
            while (*q != '\n') {
                q++;
            }
            p = q;
            continue;
        }
        j = 0;
        // For every word
        while (*p) {
            // Skip the whitespace
            while (*p == ' ' || *p == '\t') {
                p++;
            }
            // EOL ?
            if (*p == '\n') {
                break;
            }
            if (*p == '#') {
                // Place the rest of the line in the token if a comment is encountered
                for (i = 0; *p != '\n'; p++) {
                    if (i < sizeof(tmp) - 1) {
                        tmp[i++] = *p;
                    }
                }
            } else {
                // Save all characters up to a space/tab
                // Use isgraph instead of isprint because the latter considers ' ' printable
                for (i = 0; isgraph((const unsigned char)*p) && i < sizeof(tmp) - 1;) {
                    tmp[i++] = *p++;
                }
            }
            tmp[i] = '\0';
            // Limit the number of tokens
            if (j > PARSER_MAX_TOKENS - 1) {
                break;
            }
            // Save the token
            tok[j++] = strdup(tmp);
        }
        // Empty line, eww
        if (j) {
            // Do the actual parsing
            char *first = tok[0];
            // Check whether it's defining an alias or a register
            if (*first != '=') {
                reg = parse_def(tok);
                // Warn the user if something went wrong
                if (!reg) {
                    eprintf("gdb_regs: Parse error @ line %d\n", l);
                    for (i = 0; i < j; i++) {
                        free(tok[i]);
                    }
                    // Clean up
                    rz_list_free(gdb_regs_list);
                    return NULL;
                }
                rz_list_append(gdb_regs_list, reg);
            }
            // Clean up
            for (i = 0; i < j; i++) {
                free(tok[i]);
            }
        }
    } while (*p++);
 
    gdb_reg_t *gdb_regs = malloc((rz_list_length(gdb_regs_list) + 1) * sizeof(gdb_reg_t));
    if (!gdb_regs) {
        return NULL;
    }
    i = 0;
    rz_list_foreach (gdb_regs_list, iter, reg) {
        memcpy(gdb_regs + i, reg, sizeof(gdb_reg_t));
        i++;
    }
    memset(gdb_regs + i, 0, sizeof(gdb_reg_t));
 
    rz_list_free(gdb_regs_list);
    return gdb_regs;
}

References eprintf, free(), i, isgraph, malloc(), memcpy(), memset(), NULL, p, parse_def(), PARSER_MAX_TOKENS, reg, rz_list_append(), rz_list_free(), rz_list_length(), rz_list_newf(), strdup(), and autogen_x86imm::tmp.

Referenced by gdbr_set_reg_profile().