nasmlib.c

nasm的全套源代码,有些我做了些修改,以方便您更方便更容易调试成功,方便学习做编译器

    }
    return r->u.l.data[posn];
}

struct RAA *raa_write(struct RAA *r, long posn, long value)
{
    struct RAA *result;

    if (posn < 0)
        nasm_malloc_error(ERR_PANIC, "negative position in raa_write");

    while (r->stepsize * LAYERSIZ(r) <= posn) {
        /*
         * Must add a layer.
         */
        struct RAA *s;
        int i;

        s = nasm_malloc(BRANCHSIZ);
        for (i = 0; i < RAA_LAYERSIZE; i++)
            s->u.b.data[i] = NULL;
        s->layers = r->layers + 1;
        s->stepsize = LAYERSIZ(r) * r->stepsize;
        s->u.b.data[0] = r;
        r = s;
    }

    result = r;

    while (r->layers > 0) {
        ldiv_t l;
        struct RAA **s;
        l = ldiv(posn, r->stepsize);
        s = &r->u.b.data[l.quot];
        if (!*s)
            *s = real_raa_init(r->layers - 1);
        r = *s;
        posn = l.rem;
    }

    r->u.l.data[posn] = value;

    return result;
}

#define SAA_MAXLEN 8192

struct SAA *saa_init(long elem_len)
{
    struct SAA *s;

    if (elem_len > SAA_MAXLEN)
        nasm_malloc_error(ERR_PANIC | ERR_NOFILE,
                          "SAA with huge elements");

    s = nasm_malloc(sizeof(struct SAA));
    s->posn = s->start = 0L;
    s->elem_len = elem_len;
    s->length = SAA_MAXLEN - (SAA_MAXLEN % elem_len);
    s->data = nasm_malloc(s->length);
    s->next = NULL;
    s->end = s;

    return s;
}

void saa_free(struct SAA *s)
{
    struct SAA *t;

    while (s) {
        t = s->next;
        nasm_free(s->data);
        nasm_free(s);
        s = t;
    }
}

void *saa_wstruct(struct SAA *s)
{
    void *p;

    if (s->end->length - s->end->posn < s->elem_len) {
        s->end->next = nasm_malloc(sizeof(struct SAA));
        s->end->next->start = s->end->start + s->end->posn;
        s->end = s->end->next;
        s->end->length = s->length;
        s->end->next = NULL;
        s->end->posn = 0L;
        s->end->data = nasm_malloc(s->length);
    }

    p = s->end->data + s->end->posn;
    s->end->posn += s->elem_len;
    return p;
}

void saa_wbytes(struct SAA *s, const void *data, long len)
{
    const char *d = data;

    while (len > 0) {
        long l = s->end->length - s->end->posn;
        if (l > len)
            l = len;
        if (l > 0) {
            if (d) {
                memcpy(s->end->data + s->end->posn, d, l);
                d += l;
            } else
                memset(s->end->data + s->end->posn, 0, l);
            s->end->posn += l;
            len -= l;
        }
        if (len > 0) {
            s->end->next = nasm_malloc(sizeof(struct SAA));
            s->end->next->start = s->end->start + s->end->posn;
            s->end = s->end->next;
            s->end->length = s->length;
            s->end->next = NULL;
            s->end->posn = 0L;
            s->end->data = nasm_malloc(s->length);
        }
    }
}

void saa_rewind(struct SAA *s)
{
    s->rptr = s;
    s->rpos = 0L;
}

void *saa_rstruct(struct SAA *s)
{
    void *p;

    if (!s->rptr)
        return NULL;

    if (s->rptr->posn - s->rpos < s->elem_len) {
        s->rptr = s->rptr->next;
        if (!s->rptr)
            return NULL;        /* end of array */
        s->rpos = 0L;
    }

    p = s->rptr->data + s->rpos;
    s->rpos += s->elem_len;
    return p;
}

void *saa_rbytes(struct SAA *s, long *len)
{
    void *p;

    if (!s->rptr)
        return NULL;

    p = s->rptr->data + s->rpos;
    *len = s->rptr->posn - s->rpos;
    s->rptr = s->rptr->next;
    s->rpos = 0L;
    return p;
}

void saa_rnbytes(struct SAA *s, void *data, long len)
{
    char *d = data;

    while (len > 0) {
        long l;

        if (!s->rptr)
            return;

        l = s->rptr->posn - s->rpos;
        if (l > len)
            l = len;
        if (l > 0) {
            memcpy(d, s->rptr->data + s->rpos, l);
            d += l;
            s->rpos += l;
            len -= l;
        }
        if (len > 0) {
            s->rptr = s->rptr->next;
            s->rpos = 0L;
        }
    }
}

void saa_fread(struct SAA *s, long posn, void *data, long len)
{
    struct SAA *p;
    long pos;
    char *cdata = data;

    if (!s->rptr || posn < s->rptr->start)
        saa_rewind(s);
    p = s->rptr;
    while (posn >= p->start + p->posn) {
        p = p->next;
        if (!p)
            return;             /* what else can we do?! */
    }

    pos = posn - p->start;
    while (len) {
        long l = p->posn - pos;
        if (l > len)
            l = len;
        memcpy(cdata, p->data + pos, l);
        len -= l;
        cdata += l;
        p = p->next;
        if (!p)
            return;
        pos = 0L;
    }
    s->rptr = p;
}

void saa_fwrite(struct SAA *s, long posn, void *data, long len)
{
    struct SAA *p;
    long pos;
    char *cdata = data;

    if (!s->rptr || posn < s->rptr->start)
        saa_rewind(s);
    p = s->rptr;
    while (posn >= p->start + p->posn) {
        p = p->next;
        if (!p)
            return;             /* what else can we do?! */
    }

    pos = posn - p->start;
    while (len) {
        long l = p->posn - pos;
        if (l > len)
            l = len;
        memcpy(p->data + pos, cdata, l);
        len -= l;
        cdata += l;
        p = p->next;
        if (!p)
            return;
        pos = 0L;
    }
    s->rptr = p;
}

void saa_fpwrite(struct SAA *s, FILE * fp)
{
    char *data;
    long len;

    saa_rewind(s);
    while ((data = saa_rbytes(s, &len)))
        fwrite(data, 1, len, fp);
}

/*
 * Register, instruction, condition-code and prefix keywords used
 * by the scanner.
 */
#include "names.c"
static const char *special_names[] = {
    "byte", "dword", "far", "long", "near", "nosplit", "qword",
    "short", "strict", "to", "tword", "word"
};
static const char *prefix_names[] = {
    "a16", "a32", "lock", "o16", "o32", "rep", "repe", "repne",
    "repnz", "repz", "times"
};

/*
 * Standard scanner routine used by parser.c and some output
 * formats. It keeps a succession of temporary-storage strings in
 * stdscan_tempstorage, which can be cleared using stdscan_reset.
 */
static char **stdscan_tempstorage = NULL;
static int stdscan_tempsize = 0, stdscan_templen = 0;
#define STDSCAN_TEMP_DELTA 256

static void stdscan_pop(void)
{
    nasm_free(stdscan_tempstorage[--stdscan_templen]);
}

void stdscan_reset(void)
{
    while (stdscan_templen > 0)
        stdscan_pop();
}

/*
 * Unimportant cleanup is done to avoid confusing people who are trying
 * to debug real memory leaks
 */
void nasmlib_cleanup(void)
{
    stdscan_reset();
    nasm_free(stdscan_tempstorage);
}

static char *stdscan_copy(char *p, int len)
{
    char *text;

    text = nasm_malloc(len + 1);
    strncpy(text, p, len);
    text[len] = '\0';

    if (stdscan_templen >= stdscan_tempsize) {
        stdscan_tempsize += STDSCAN_TEMP_DELTA;
        stdscan_tempstorage = nasm_realloc(stdscan_tempstorage,
                                           stdscan_tempsize *
                                           sizeof(char *));
    }
    stdscan_tempstorage[stdscan_templen++] = text;

    return text;
}

char *stdscan_bufptr = NULL;
int stdscan(void *private_data, struct tokenval *tv)
{
    char ourcopy[MAX_KEYWORD + 1], *r, *s;

    (void)private_data;         /* Don't warn that this parameter is unused */

    while (isspace(*stdscan_bufptr))
        stdscan_bufptr++;
    if (!*stdscan_bufptr)
        return tv->t_type = 0;

    /* we have a token; either an id, a number or a char */
    if (isidstart(*stdscan_bufptr) ||
        (*stdscan_bufptr == '$' && isidstart(stdscan_bufptr[1]))) {
        /* now we've got an identifier */
        int i;
        int is_sym = FALSE;

        if (*stdscan_bufptr == '$') {
            is_sym = TRUE;
            stdscan_bufptr++;
        }

        r = stdscan_bufptr++;
        /* read the entire buffer to advance the buffer pointer but... */
        while (isidchar(*stdscan_bufptr))
            stdscan_bufptr++;

        /* ... copy only up to IDLEN_MAX-1 characters */
        tv->t_charptr = stdscan_copy(r, stdscan_bufptr - r < IDLEN_MAX ?
                                     stdscan_bufptr - r : IDLEN_MAX - 1);

        if (is_sym || stdscan_bufptr - r > MAX_KEYWORD)
            return tv->t_type = TOKEN_ID;       /* bypass all other checks */

        for (s = tv->t_charptr, r = ourcopy; *s; s++)
            *r++ = tolower(*s);
        *r = '\0';
        /* right, so we have an identifier sitting in temp storage. now,
         * is it actually a register or instruction name, or what? */
        if ((tv->t_integer = bsi(ourcopy, reg_names,
                                 elements(reg_names))) >= 0) {
            tv->t_integer += EXPR_REG_START;
            return tv->t_type = TOKEN_REG;
        } else if ((tv->t_integer = bsi(ourcopy, insn_names,
                                        elements(insn_names))) >= 0) {
            return tv->t_type = TOKEN_INSN;
        }
        for (i = 0; i < elements(icn); i++)
            if (!strncmp(ourcopy, icn[i], strlen(icn[i]))) {
                char *p = ourcopy + strlen(icn[i]);
                tv->t_integer = ico[i];
                if ((tv->t_inttwo = bsi(p, conditions,