diff options
Diffstat (limited to 'nasmlib.c')
| -rw-r--r-- | nasmlib.c | 1087 |
1 files changed, 553 insertions, 534 deletions
@@ -13,7 +13,7 @@ #include "nasm.h" #include "nasmlib.h" -#include "insns.h" /* For MAX_KEYWORD */ +#include "insns.h" /* For MAX_KEYWORD */ static efunc nasm_malloc_error; @@ -21,143 +21,142 @@ static efunc nasm_malloc_error; static FILE *logfp; #endif -void nasm_set_malloc_error (efunc error) +void nasm_set_malloc_error(efunc error) { nasm_malloc_error = error; #ifdef LOGALLOC - logfp = fopen ("malloc.log", "w"); - setvbuf (logfp, NULL, _IOLBF, BUFSIZ); - fprintf (logfp, "null pointer is %p\n", NULL); + logfp = fopen("malloc.log", "w"); + setvbuf(logfp, NULL, _IOLBF, BUFSIZ); + fprintf(logfp, "null pointer is %p\n", NULL); #endif } #ifdef LOGALLOC -void *nasm_malloc_log (char *file, int line, size_t size) +void *nasm_malloc_log(char *file, int line, size_t size) #else -void *nasm_malloc (size_t size) +void *nasm_malloc(size_t size) #endif { void *p = malloc(size); if (!p) - nasm_malloc_error (ERR_FATAL | ERR_NOFILE, "out of memory"); + nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory"); #ifdef LOGALLOC else - fprintf(logfp, "%s %d malloc(%ld) returns %p\n", - file, line, (long)size, p); + fprintf(logfp, "%s %d malloc(%ld) returns %p\n", + file, line, (long)size, p); #endif return p; } #ifdef LOGALLOC -void *nasm_realloc_log (char *file, int line, void *q, size_t size) +void *nasm_realloc_log(char *file, int line, void *q, size_t size) #else -void *nasm_realloc (void *q, size_t size) +void *nasm_realloc(void *q, size_t size) #endif { void *p = q ? realloc(q, size) : malloc(size); if (!p) - nasm_malloc_error (ERR_FATAL | ERR_NOFILE, "out of memory"); + nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory"); #ifdef LOGALLOC else if (q) - fprintf(logfp, "%s %d realloc(%p,%ld) returns %p\n", - file, line, q, (long)size, p); + fprintf(logfp, "%s %d realloc(%p,%ld) returns %p\n", + file, line, q, (long)size, p); else - fprintf(logfp, "%s %d malloc(%ld) returns %p\n", - file, line, (long)size, p); + fprintf(logfp, "%s %d malloc(%ld) returns %p\n", + file, line, (long)size, p); #endif return p; } #ifdef LOGALLOC -void nasm_free_log (char *file, int line, void *q) +void nasm_free_log(char *file, int line, void *q) #else -void nasm_free (void *q) +void nasm_free(void *q) #endif { if (q) { - free (q); + free(q); #ifdef LOGALLOC - fprintf(logfp, "%s %d free(%p)\n", - file, line, q); + fprintf(logfp, "%s %d free(%p)\n", file, line, q); #endif } } #ifdef LOGALLOC -char *nasm_strdup_log (char *file, int line, const char *s) +char *nasm_strdup_log(char *file, int line, const char *s) #else -char *nasm_strdup (const char *s) +char *nasm_strdup(const char *s) #endif { char *p; - int size = strlen(s)+1; + int size = strlen(s) + 1; p = malloc(size); if (!p) - nasm_malloc_error (ERR_FATAL | ERR_NOFILE, "out of memory"); + nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory"); #ifdef LOGALLOC else - fprintf(logfp, "%s %d strdup(%ld) returns %p\n", - file, line, (long)size, p); + fprintf(logfp, "%s %d strdup(%ld) returns %p\n", + file, line, (long)size, p); #endif - strcpy (p, s); + strcpy(p, s); return p; } #ifdef LOGALLOC -char *nasm_strndup_log (char *file, int line, char *s, size_t len) +char *nasm_strndup_log(char *file, int line, char *s, size_t len) #else -char *nasm_strndup (char *s, size_t len) +char *nasm_strndup(char *s, size_t len) #endif { char *p; - int size = len+1; + int size = len + 1; p = malloc(size); if (!p) - nasm_malloc_error (ERR_FATAL | ERR_NOFILE, "out of memory"); + nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory"); #ifdef LOGALLOC else - fprintf(logfp, "%s %d strndup(%ld) returns %p\n", - file, line, (long)size, p); + fprintf(logfp, "%s %d strndup(%ld) returns %p\n", + file, line, (long)size, p); #endif - strncpy (p, s, len); + strncpy(p, s, len); p[len] = '\0'; return p; } #if !defined(stricmp) && !defined(strcasecmp) -int nasm_stricmp (const char *s1, const char *s2) +int nasm_stricmp(const char *s1, const char *s2) { while (*s1 && tolower(*s1) == tolower(*s2)) - s1++, s2++; + s1++, s2++; if (!*s1 && !*s2) - return 0; + return 0; else if (tolower(*s1) < tolower(*s2)) - return -1; + return -1; else - return 1; + return 1; } #endif #if !defined(strnicmp) && !defined(strncasecmp) -int nasm_strnicmp (const char *s1, const char *s2, int n) +int nasm_strnicmp(const char *s1, const char *s2, int n) { while (n > 0 && *s1 && tolower(*s1) == tolower(*s2)) - s1++, s2++, n--; - if ((!*s1 && !*s2) || n==0) - return 0; + s1++, s2++, n--; + if ((!*s1 && !*s2) || n == 0) + return 0; else if (tolower(*s1) < tolower(*s2)) - return -1; + return -1; else - return 1; + return 1; } #endif #define lib_isnumchar(c) ( isalnum(c) || (c) == '$') #define numvalue(c) ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0') -long readnum (char *str, int *error) +long readnum(char *str, int *error) { char *r = str, *q; long radix; @@ -168,39 +167,40 @@ long readnum (char *str, int *error) *error = FALSE; - while (isspace(*r)) r++; /* find start of number */ + while (isspace(*r)) + r++; /* find start of number */ /* * If the number came from make_tok_num (as a result of an %assign), it * might have a '-' built into it (rather than in a preceeding token). */ - if (*r == '-') - { - r++; - sign = -1; + if (*r == '-') { + r++; + sign = -1; } q = r; - while (lib_isnumchar(*q)) q++; /* find end of number */ + while (lib_isnumchar(*q)) + q++; /* find end of number */ /* * If it begins 0x, 0X or $, or ends in H, it's in hex. if it * ends in Q, it's octal. if it ends in B, it's binary. * Otherwise, it's ordinary decimal. */ - if (*r=='0' && (r[1]=='x' || r[1]=='X')) - radix = 16, r += 2; - else if (*r=='$') - radix = 16, r++; - else if (q[-1]=='H' || q[-1]=='h') - radix = 16 , q--; - else if (q[-1]=='Q' || q[-1]=='q' || q[-1]=='O' || q[-1]=='o') - radix = 8 , q--; - else if (q[-1]=='B' || q[-1]=='b') - radix = 2 , q--; + if (*r == '0' && (r[1] == 'x' || r[1] == 'X')) + radix = 16, r += 2; + else if (*r == '$') + radix = 16, r++; + else if (q[-1] == 'H' || q[-1] == 'h') + radix = 16, q--; + else if (q[-1] == 'Q' || q[-1] == 'q' || q[-1] == 'O' || q[-1] == 'o') + radix = 8, q--; + else if (q[-1] == 'B' || q[-1] == 'b') + radix = 2, q--; else - radix = 10; + radix = 10; /* * If this number has been found for us by something other than @@ -209,8 +209,8 @@ long readnum (char *str, int *error) * now. */ if (r >= q) { - *error = TRUE; - return 0; + *error = TRUE; + return 0; } /* @@ -219,7 +219,7 @@ long readnum (char *str, int *error) * cheat: since we know that all radices we use are even, we * can divide 2**31 by radix/2 instead. */ - checklimit = 0x80000000UL / (radix>>1); + checklimit = 0x80000000UL / (radix >> 1); /* * Calculate the highest allowable value for the last digit @@ -229,30 +229,28 @@ long readnum (char *str, int *error) result = 0; while (*r && r < q) { - if (*r<'0' || (*r>'9' && *r<'A') || (digit = numvalue(*r)) >= radix) - { - *error = TRUE; - return 0; - } - if (result > checklimit || - (result == checklimit && digit >= last)) - { - warn = TRUE; - } - - result = radix * result + digit; - r++; + if (*r < '0' || (*r > '9' && *r < 'A') + || (digit = numvalue(*r)) >= radix) { + *error = TRUE; + return 0; + } + if (result > checklimit || (result == checklimit && digit >= last)) { + warn = TRUE; + } + + result = radix * result + digit; + r++; } if (warn) - nasm_malloc_error (ERR_WARNING | ERR_PASS1 | ERR_WARN_NOV, - "numeric constant %s does not fit in 32 bits", - str); + nasm_malloc_error(ERR_WARNING | ERR_PASS1 | ERR_WARN_NOV, + "numeric constant %s does not fit in 32 bits", + str); - return result*sign; + return result * sign; } -long readstrnum (char *str, int length, int *warn) +long readstrnum(char *str, int length, int *warn) { long charconst = 0; int i; @@ -260,67 +258,69 @@ long readstrnum (char *str, int length, int *warn) *warn = FALSE; str += length; - for (i=0; i<length; i++) { - if (charconst & 0xff000000UL) { - *warn = TRUE; - } - charconst = (charconst<<8) + (unsigned char) *--str; + for (i = 0; i < length; i++) { + if (charconst & 0xff000000UL) { + *warn = TRUE; + } + charconst = (charconst << 8) + (unsigned char)*--str; } return charconst; } static long next_seg; -void seg_init(void) +void seg_init(void) { next_seg = 0; } -long seg_alloc(void) +long seg_alloc(void) { return (next_seg += 2) - 2; } -void fwriteshort (int data, FILE *fp) +void fwriteshort(int data, FILE * fp) { - fputc ((int) (data & 255), fp); - fputc ((int) ((data >> 8) & 255), fp); + fputc((int)(data & 255), fp); + fputc((int)((data >> 8) & 255), fp); } -void fwritelong (long data, FILE *fp) +void fwritelong(long data, FILE * fp) { - fputc ((int) (data & 255), fp); - fputc ((int) ((data >> 8) & 255), fp); - fputc ((int) ((data >> 16) & 255), fp); - fputc ((int) ((data >> 24) & 255), fp); + fputc((int)(data & 255), fp); + fputc((int)((data >> 8) & 255), fp); + fputc((int)((data >> 16) & 255), fp); + fputc((int)((data >> 24) & 255), fp); } -void standard_extension (char *inname, char *outname, char *extension, - efunc error) +void standard_extension(char *inname, char *outname, char *extension, + efunc error) { char *p, *q; - if (*outname) /* file name already exists, */ - return; /* so do nothing */ + if (*outname) /* file name already exists, */ + return; /* so do nothing */ q = inname; p = outname; - while (*q) *p++ = *q++; /* copy, and find end of string */ - *p = '\0'; /* terminate it */ - while (p > outname && *--p != '.');/* find final period (or whatever) */ - if (*p != '.') while (*p) p++; /* go back to end if none found */ - if (!strcmp(p, extension)) { /* is the extension already there? */ - if (*extension) - error(ERR_WARNING | ERR_NOFILE, - "file name already ends in `%s': " - "output will be in `nasm.out'", - extension); - else - error(ERR_WARNING | ERR_NOFILE, - "file name already has no extension: " - "output will be in `nasm.out'"); - strcpy(outname, "nasm.out"); + while (*q) + *p++ = *q++; /* copy, and find end of string */ + *p = '\0'; /* terminate it */ + while (p > outname && *--p != '.') ; /* find final period (or whatever) */ + if (*p != '.') + while (*p) + p++; /* go back to end if none found */ + if (!strcmp(p, extension)) { /* is the extension already there? */ + if (*extension) + error(ERR_WARNING | ERR_NOFILE, + "file name already ends in `%s': " + "output will be in `nasm.out'", extension); + else + error(ERR_WARNING | ERR_NOFILE, + "file name already has no extension: " + "output will be in `nasm.out'"); + strcpy(outname, "nasm.out"); } else - strcpy(p, extension); + strcpy(p, extension); } #define LEAFSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_LEAF)) @@ -328,94 +328,94 @@ void standard_extension (char *inname, char *outname, char *extension, #define LAYERSIZ(r) ( (r)->layers==0 ? RAA_BLKSIZE : RAA_LAYERSIZE ) -static struct RAA *real_raa_init (int layers) +static struct RAA *real_raa_init(int layers) { struct RAA *r; int i; if (layers == 0) { - r = nasm_malloc (LEAFSIZ); - r->layers = 0; - memset (r->u.l.data, 0, sizeof(r->u.l.data)); - r->stepsize = 1L; + r = nasm_malloc(LEAFSIZ); + r->layers = 0; + memset(r->u.l.data, 0, sizeof(r->u.l.data)); + r->stepsize = 1L; } else { - r = nasm_malloc (BRANCHSIZ); - r->layers = layers; - for ( i = 0 ; i < RAA_LAYERSIZE ; i++ ) - r->u.b.data[i] = NULL; - r->stepsize = RAA_BLKSIZE; - while (--layers) - r->stepsize *= RAA_LAYERSIZE; + r = nasm_malloc(BRANCHSIZ); + r->layers = layers; + for (i = 0; i < RAA_LAYERSIZE; i++) + r->u.b.data[i] = NULL; + r->stepsize = RAA_BLKSIZE; + while (--layers) + r->stepsize *= RAA_LAYERSIZE; } return r; } -struct RAA *raa_init (void) +struct RAA *raa_init(void) { - return real_raa_init (0); + return real_raa_init(0); } -void raa_free (struct RAA *r) +void raa_free(struct RAA *r) { if (r->layers == 0) - nasm_free (r); + nasm_free(r); else { - struct RAA **p; - for (p = r->u.b.data; p - r->u.b.data < RAA_LAYERSIZE; p++) - if (*p) - raa_free (*p); + struct RAA **p; + for (p = r->u.b.data; p - r->u.b.data < RAA_LAYERSIZE; p++) + if (*p) + raa_free(*p); } } -long raa_read (struct RAA *r, long posn) +long raa_read(struct RAA *r, long posn) { if (posn >= r->stepsize * LAYERSIZ(r)) - return 0; /* Return 0 for undefined entries */ + return 0; /* Return 0 for undefined entries */ while (r->layers > 0) { - ldiv_t l; - l = ldiv (posn, r->stepsize); - r = r->u.b.data[l.quot]; - posn = l.rem; - if (!r) - return 0; /* Return 0 for undefined entries */ + ldiv_t l; + l = ldiv(posn, r->stepsize); + r = r->u.b.data[l.quot]; + posn = l.rem; + if (!r) + return 0; /* Return 0 for undefined entries */ } return r->u.l.data[posn]; } -struct RAA *raa_write (struct RAA *r, long posn, long value) +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"); + 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; + /* + * 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; + 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; @@ -425,48 +425,49 @@ struct RAA *raa_write (struct RAA *r, long posn, long value) #define SAA_MAXLEN 8192 -struct SAA *saa_init (long elem_len) +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"); + nasm_malloc_error(ERR_PANIC | ERR_NOFILE, + "SAA with huge elements"); - s = nasm_malloc (sizeof(struct SAA)); + 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->data = nasm_malloc(s->length); s->next = NULL; s->end = s; return s; } -void saa_free (struct SAA *s) +void saa_free(struct SAA *s) { struct SAA *t; while (s) { - t = s->next; - nasm_free (s->data); - nasm_free (s); - s = t; + t = s->next; + nasm_free(s->data); + nasm_free(s); + s = t; } } -void *saa_wstruct (struct SAA *s) +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); + 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; @@ -474,53 +475,53 @@ void *saa_wstruct (struct SAA *s) return p; } -void saa_wbytes (struct SAA *s, const void *data, long len) +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); - } + 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) +void saa_rewind(struct SAA *s) { s->rptr = s; s->rpos = 0L; } -void *saa_rstruct (struct SAA *s) +void *saa_rstruct(struct SAA *s) { void *p; if (!s->rptr) - return NULL; + 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; + s->rptr = s->rptr->next; + if (!s->rptr) + return NULL; /* end of array */ + s->rpos = 0L; } p = s->rptr->data + s->rpos; @@ -528,12 +529,12 @@ void *saa_rstruct (struct SAA *s) return p; } -void *saa_rbytes (struct SAA *s, long *len) +void *saa_rbytes(struct SAA *s, long *len) { void *p; if (!s->rptr) - return NULL; + return NULL; p = s->rptr->data + s->rpos; *len = s->rptr->posn - s->rpos; @@ -542,102 +543,102 @@ void *saa_rbytes (struct SAA *s, long *len) return p; } -void saa_rnbytes (struct SAA *s, void *data, long len) +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; - } + 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) +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); + saa_rewind(s); p = s->rptr; while (posn >= p->start + p->posn) { - p = p->next; - if (!p) - return; /* what else can we do?! */ + 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; + 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) +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); + saa_rewind(s); p = s->rptr; while (posn >= p->start + p->posn) { - p = p->next; - if (!p) - return; /* what else can we do?! */ + 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; + 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) +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); + saa_rewind(s); + while ((data = saa_rbytes(s, &len))) + fwrite(data, 1, len, fp); } /* @@ -654,7 +655,6 @@ static const char *prefix_names[] = { "repnz", "repz", "times" }; - /* * Standard scanner routine used by parser.c and some output * formats. It keeps a succession of temporary-storage strings in @@ -664,39 +664,40 @@ static char **stdscan_tempstorage = NULL; static int stdscan_tempsize = 0, stdscan_templen = 0; #define STDSCAN_TEMP_DELTA 256 -static void stdscan_pop(void) +static void stdscan_pop(void) { - nasm_free (stdscan_tempstorage[--stdscan_templen]); + nasm_free(stdscan_tempstorage[--stdscan_templen]); } -void stdscan_reset(void) +void stdscan_reset(void) { while (stdscan_templen > 0) - stdscan_pop(); + stdscan_pop(); } /* * Unimportant cleanup is done to avoid confusing people who are trying * to debug real memory leaks */ -void nasmlib_cleanup (void) +void nasmlib_cleanup(void) { stdscan_reset(); - nasm_free (stdscan_tempstorage); + nasm_free(stdscan_tempstorage); } -static char *stdscan_copy(char *p, int len) +static char *stdscan_copy(char *p, int len) { char *text; - text = nasm_malloc(len+1); - strncpy (text, p, len); + 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_tempsize += STDSCAN_TEMP_DELTA; + stdscan_tempstorage = nasm_realloc(stdscan_tempstorage, + stdscan_tempsize * + sizeof(char *)); } stdscan_tempstorage[stdscan_templen++] = text; @@ -704,185 +705,188 @@ static char *stdscan_copy(char *p, int len) } char *stdscan_bufptr = NULL; -int stdscan (void *private_data, struct tokenval *tv) +int stdscan(void *private_data, struct tokenval *tv) { - char ourcopy[MAX_KEYWORD+1], *r, *s; + char ourcopy[MAX_KEYWORD + 1], *r, *s; - (void) private_data; /* Don't warn that this parameter is unused */ + (void)private_data; /* Don't warn that this parameter is unused */ - while (isspace(*stdscan_bufptr)) stdscan_bufptr++; + while (isspace(*stdscan_bufptr)) + stdscan_bufptr++; if (!*stdscan_bufptr) - return tv->t_type = 0; + 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, - elements(conditions)))>=0) - return tv->t_type = TOKEN_INSN; - } - if ((tv->t_integer=bsi(ourcopy, prefix_names, - elements(prefix_names)))>=0) { - tv->t_integer += PREFIX_ENUM_START; - return tv->t_type = TOKEN_PREFIX; - } - if ((tv->t_integer=bsi(ourcopy, special_names, - elements(special_names)))>=0) - return tv->t_type = TOKEN_SPECIAL; - if (!nasm_stricmp(ourcopy, "seg")) - return tv->t_type = TOKEN_SEG; - if (!nasm_stricmp(ourcopy, "wrt")) - return tv->t_type = TOKEN_WRT; - return tv->t_type = TOKEN_ID; + (*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, + elements(conditions))) >= 0) + return tv->t_type = TOKEN_INSN; + } + if ((tv->t_integer = bsi(ourcopy, prefix_names, + elements(prefix_names))) >= 0) { + tv->t_integer += PREFIX_ENUM_START; + return tv->t_type = TOKEN_PREFIX; + } + if ((tv->t_integer = bsi(ourcopy, special_names, + elements(special_names))) >= 0) + return tv->t_type = TOKEN_SPECIAL; + if (!nasm_stricmp(ourcopy, "seg")) + return tv->t_type = TOKEN_SEG; + if (!nasm_stricmp(ourcopy, "wrt")) + return tv->t_type = TOKEN_WRT; + return tv->t_type = TOKEN_ID; } else if (*stdscan_bufptr == '$' && !isnumchar(stdscan_bufptr[1])) { - /* - * It's a $ sign with no following hex number; this must - * mean it's a Here token ($), evaluating to the current - * assembly location, or a Base token ($$), evaluating to - * the base of the current segment. - */ - stdscan_bufptr++; - if (*stdscan_bufptr == '$') { - stdscan_bufptr++; - return tv->t_type = TOKEN_BASE; - } - return tv->t_type = TOKEN_HERE; - } else if (isnumstart(*stdscan_bufptr)) { /* now we've got a number */ - int rn_error; - - r = stdscan_bufptr++; - while (isnumchar(*stdscan_bufptr)) - stdscan_bufptr++; - - if (*stdscan_bufptr == '.') { - /* - * a floating point constant - */ - stdscan_bufptr++; - while (isnumchar(*stdscan_bufptr) || - ((stdscan_bufptr[-1] == 'e' || stdscan_bufptr[-1] == 'E') - && (*stdscan_bufptr == '-' || *stdscan_bufptr == '+')) ) - { - stdscan_bufptr++; - } - tv->t_charptr = stdscan_copy(r, stdscan_bufptr - r); - return tv->t_type = TOKEN_FLOAT; - } - r = stdscan_copy(r, stdscan_bufptr - r); - tv->t_integer = readnum(r, &rn_error); - stdscan_pop(); - if (rn_error) - return tv->t_type = TOKEN_ERRNUM;/* some malformation occurred */ - tv->t_charptr = NULL; - return tv->t_type = TOKEN_NUM; - } else if (*stdscan_bufptr == '\'' || - *stdscan_bufptr == '"') {/* a char constant */ - char quote = *stdscan_bufptr++, *r; - int rn_warn; - r = tv->t_charptr = stdscan_bufptr; - while (*stdscan_bufptr && *stdscan_bufptr != quote) stdscan_bufptr++; - tv->t_inttwo = stdscan_bufptr - r; /* store full version */ - if (!*stdscan_bufptr) - return tv->t_type = TOKEN_ERRNUM; /* unmatched quotes */ - stdscan_bufptr++; /* skip over final quote */ - tv->t_integer = readstrnum(r, tv->t_inttwo, &rn_warn); - /* FIXME: rn_warn is not checked! */ - return tv->t_type = TOKEN_NUM; - } else if (*stdscan_bufptr == ';') { /* a comment has happened - stay */ - return tv->t_type = 0; + /* + * It's a $ sign with no following hex number; this must + * mean it's a Here token ($), evaluating to the current + * assembly location, or a Base token ($$), evaluating to + * the base of the current segment. + */ + stdscan_bufptr++; + if (*stdscan_bufptr == '$') { + stdscan_bufptr++; + return tv->t_type = TOKEN_BASE; + } + return tv->t_type = TOKEN_HERE; + } else if (isnumstart(*stdscan_bufptr)) { /* now we've got a number */ + int rn_error; + + r = stdscan_bufptr++; + while (isnumchar(*stdscan_bufptr)) + stdscan_bufptr++; + + if (*stdscan_bufptr == '.') { + /* + * a floating point constant + */ + stdscan_bufptr++; + while (isnumchar(*stdscan_bufptr) || + ((stdscan_bufptr[-1] == 'e' + || stdscan_bufptr[-1] == 'E') + && (*stdscan_bufptr == '-' || *stdscan_bufptr == '+'))) { + stdscan_bufptr++; + } + tv->t_charptr = stdscan_copy(r, stdscan_bufptr - r); + return tv->t_type = TOKEN_FLOAT; + } + r = stdscan_copy(r, stdscan_bufptr - r); + tv->t_integer = readnum(r, &rn_error); + stdscan_pop(); + if (rn_error) + return tv->t_type = TOKEN_ERRNUM; /* some malformation occurred */ + tv->t_charptr = NULL; + return tv->t_type = TOKEN_NUM; + } else if (*stdscan_bufptr == '\'' || *stdscan_bufptr == '"') { /* a char constant */ + char quote = *stdscan_bufptr++, *r; + int rn_warn; + r = tv->t_charptr = stdscan_bufptr; + while (*stdscan_bufptr && *stdscan_bufptr != quote) + stdscan_bufptr++; + tv->t_inttwo = stdscan_bufptr - r; /* store full version */ + if (!*stdscan_bufptr) + return tv->t_type = TOKEN_ERRNUM; /* unmatched quotes */ + stdscan_bufptr++; /* skip over final quote */ + tv->t_integer = readstrnum(r, tv->t_inttwo, &rn_warn); + /* FIXME: rn_warn is not checked! */ + return tv->t_type = TOKEN_NUM; + } else if (*stdscan_bufptr == ';') { /* a comment has happened - stay */ + return tv->t_type = 0; } else if (stdscan_bufptr[0] == '>' && stdscan_bufptr[1] == '>') { - stdscan_bufptr += 2; - return tv->t_type = TOKEN_SHR; + stdscan_bufptr += 2; + return tv->t_type = TOKEN_SHR; } else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '<') { - stdscan_bufptr += 2; - return tv->t_type = TOKEN_SHL; + stdscan_bufptr += 2; + return tv->t_type = TOKEN_SHL; } else if (stdscan_bufptr[0] == '/' && stdscan_bufptr[1] == '/') { - stdscan_bufptr += 2; - return tv->t_type = TOKEN_SDIV; + stdscan_bufptr += 2; + return tv->t_type = TOKEN_SDIV; } else if (stdscan_bufptr[0] == '%' && stdscan_bufptr[1] == '%') { - stdscan_bufptr += 2; - return tv->t_type = TOKEN_SMOD; + stdscan_bufptr += 2; + return tv->t_type = TOKEN_SMOD; } else if (stdscan_bufptr[0] == '=' && stdscan_bufptr[1] == '=') { - stdscan_bufptr += 2; - return tv->t_type = TOKEN_EQ; + stdscan_bufptr += 2; + return tv->t_type = TOKEN_EQ; } else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '>') { - stdscan_bufptr += 2; - return tv->t_type = TOKEN_NE; + stdscan_bufptr += 2; + return tv->t_type = TOKEN_NE; } else if (stdscan_bufptr[0] == '!' && stdscan_bufptr[1] == '=') { - stdscan_bufptr += 2; - return tv->t_type = TOKEN_NE; + stdscan_bufptr += 2; + return tv->t_type = TOKEN_NE; } else if (stdscan_bufptr[0] == '<' && stdscan_bufptr[1] == '=') { - stdscan_bufptr += 2; - return tv->t_type = TOKEN_LE; + stdscan_bufptr += 2; + return tv->t_type = TOKEN_LE; } else if (stdscan_bufptr[0] == '>' && stdscan_bufptr[1] == '=') { - stdscan_bufptr += 2; - return tv->t_type = TOKEN_GE; + stdscan_bufptr += 2; + return tv->t_type = TOKEN_GE; } else if (stdscan_bufptr[0] == '&' && stdscan_bufptr[1] == '&') { - stdscan_bufptr += 2; - return tv->t_type = TOKEN_DBL_AND; + stdscan_bufptr += 2; + return tv->t_type = TOKEN_DBL_AND; } else if (stdscan_bufptr[0] == '^' && stdscan_bufptr[1] == '^') { - stdscan_bufptr += 2; - return tv->t_type = TOKEN_DBL_XOR; + stdscan_bufptr += 2; + return tv->t_type = TOKEN_DBL_XOR; } else if (stdscan_bufptr[0] == '|' && stdscan_bufptr[1] == '|') { - stdscan_bufptr += 2; - return tv->t_type = TOKEN_DBL_OR; - } else /* just an ordinary char */ - return tv->t_type = (unsigned char) (*stdscan_bufptr++); + stdscan_bufptr += 2; + return tv->t_type = TOKEN_DBL_OR; + } else /* just an ordinary char */ + return tv->t_type = (unsigned char)(*stdscan_bufptr++); } /* * Return TRUE if the argument is a simple scalar. (Or a far- * absolute, which counts.) */ -int is_simple (expr *vect) +int is_simple(expr * vect) { while (vect->type && !vect->value) - vect++; + vect++; if (!vect->type) - return 1; + return 1; if (vect->type != EXPR_SIMPLE) - return 0; + return 0; do { - vect++; + vect++; } while (vect->type && !vect->value); - if (vect->type && vect->type < EXPR_SEGBASE+SEG_ABS) return 0; + if (vect->type && vect->type < EXPR_SEGBASE + SEG_ABS) + return 0; return 1; } @@ -890,18 +894,19 @@ int is_simple (expr *vect) * Return TRUE if the argument is a simple scalar, _NOT_ a far- * absolute. */ -int is_really_simple (expr *vect) +int is_really_simple(expr * vect) { while (vect->type && !vect->value) - vect++; + vect++; if (!vect->type) - return 1; + return 1; if (vect->type != EXPR_SIMPLE) - return 0; + return 0; do { - vect++; + vect++; } while (vect->type && !vect->value); - if (vect->type) return 0; + if (vect->type) + return 0; return 1; } @@ -909,45 +914,45 @@ int is_really_simple (expr *vect) * Return TRUE if the argument is relocatable (i.e. a simple * scalar, plus at most one segment-base, plus possibly a WRT). */ -int is_reloc (expr *vect) +int is_reloc(expr * vect) { - while (vect->type && !vect->value) /* skip initial value-0 terms */ - vect++; - if (!vect->type) /* trivially return TRUE if nothing */ - return 1; /* is present apart from value-0s */ - if (vect->type < EXPR_SIMPLE) /* FALSE if a register is present */ - return 0; - if (vect->type == EXPR_SIMPLE) { /* skip over a pure number term... */ - do { - vect++; - } while (vect->type && !vect->value); - if (!vect->type) /* ...returning TRUE if that's all */ - return 1; + while (vect->type && !vect->value) /* skip initial value-0 terms */ + vect++; + if (!vect->type) /* trivially return TRUE if nothing */ + return 1; /* is present apart from value-0s */ + if (vect->type < EXPR_SIMPLE) /* FALSE if a register is present */ + return 0; + if (vect->type == EXPR_SIMPLE) { /* skip over a pure number term... */ + do { + vect++; + } while (vect->type && !vect->value); + if (!vect->type) /* ...returning TRUE if that's all */ + return 1; } - if (vect->type == EXPR_WRT) { /* skip over a WRT term... */ - do { - vect++; - } while (vect->type && !vect->value); - if (!vect->type) /* ...returning TRUE if that's all */ - return 1; + if (vect->type == EXPR_WRT) { /* skip over a WRT term... */ + do { + vect++; + } while (vect->type && !vect->value); + if (!vect->type) /* ...returning TRUE if that's all */ + return 1; } if (vect->value != 0 && vect->value != 1) - return 0; /* segment base multiplier non-unity */ - do { /* skip over _one_ seg-base term... */ - vect++; + return 0; /* segment base multiplier non-unity */ + do { /* skip over _one_ seg-base term... */ + vect++; } while (vect->type && !vect->value); - if (!vect->type) /* ...returning TRUE if that's all */ - return 1; - return 0; /* And return FALSE if there's more */ + if (!vect->type) /* ...returning TRUE if that's all */ + return 1; + return 0; /* And return FALSE if there's more */ } /* * Return TRUE if the argument contains an `unknown' part. */ -int is_unknown(expr *vect) +int is_unknown(expr * vect) { while (vect->type && vect->type < EXPR_UNKNOWN) - vect++; + vect++; return (vect->type == EXPR_UNKNOWN); } @@ -955,10 +960,10 @@ int is_unknown(expr *vect) * Return TRUE if the argument contains nothing but an `unknown' * part. */ -int is_just_unknown(expr *vect) +int is_just_unknown(expr * vect) { while (vect->type && !vect->value) - vect++; + vect++; return (vect->type == EXPR_UNKNOWN); } @@ -966,144 +971,158 @@ int is_just_unknown(expr *vect) * Return the scalar part of a relocatable vector. (Including * simple scalar vectors - those qualify as relocatable.) */ -long reloc_value (expr *vect) +long reloc_value(expr * vect) { while (vect->type && !vect->value) - vect++; - if (!vect->type) return 0; + vect++; + if (!vect->type) + return 0; if (vect->type == EXPR_SIMPLE) - return vect->value; + return vect->value; else - return 0; + return 0; } /* * Return the segment number of a relocatable vector, or NO_SEG for * simple scalars. */ -long reloc_seg (expr *vect) +long reloc_seg(expr * vect) { while (vect->type && (vect->type == EXPR_WRT || !vect->value)) - vect++; + vect++; if (vect->type == EXPR_SIMPLE) { - do { - vect++; - } while (vect->type && (vect->type == EXPR_WRT || !vect->value)); + do { + vect++; + } while (vect->type && (vect->type == EXPR_WRT || !vect->value)); } if (!vect->type) - return NO_SEG; + return NO_SEG; else - return vect->type - EXPR_SEGBASE; + return vect->type - EXPR_SEGBASE; } /* * Return the WRT segment number of a relocatable vector, or NO_SEG * if no WRT part is present. */ -long reloc_wrt (expr *vect) +long reloc_wrt(expr * vect) { while (vect->type && vect->type < EXPR_WRT) - vect++; + vect++; if (vect->type == EXPR_WRT) { - return vect->value; + return vect->value; } else - return NO_SEG; + return NO_SEG; } /* * Binary search. */ -int bsi (char *string, const char **array, int size) +int bsi(char *string, const char **array, int size) { - int i = -1, j = size; /* always, i < index < j */ - while (j-i >= 2) { - int k = (i+j)/2; - int l = strcmp(string, array[k]); - if (l<0) /* it's in the first half */ - j = k; - else if (l>0) /* it's in the second half */ - i = k; - else /* we've got it :) */ - return k; + int i = -1, j = size; /* always, i < index < j */ + while (j - i >= 2) { + int k = (i + j) / 2; + int l = strcmp(string, array[k]); + if (l < 0) /* it's in the first half */ + j = k; + else if (l > 0) /* it's in the second half */ + i = k; + else /* we've got it :) */ + return k; } - return -1; /* we haven't got it :( */ + return -1; /* we haven't got it :( */ } static char *file_name = NULL; static long line_number = 0; -char *src_set_fname(char *newname) +char *src_set_fname(char *newname) { char *oldname = file_name; file_name = newname; return oldname; } -long src_set_linnum(long newline) +long src_set_linnum(long newline) { long oldline = line_number; line_number = newline; return oldline; } -long src_get_linnum(void) +long src_get_linnum(void) { return line_number; } -int src_get(long *xline, char **xname) +int src_get(long *xline, char **xname) { - if (!file_name || !*xname || strcmp(*xname, file_name)) - { - nasm_free(*xname); - *xname = file_name ? nasm_strdup(file_name) : NULL; - *xline = line_number; - return -2; + if (!file_name || !*xname || strcmp(*xname, file_name)) { + nasm_free(*xname); + *xname = file_name ? nasm_strdup(file_name) : NULL; + *xline = line_number; + return -2; } - if (*xline != line_number) - { - long tmp = line_number - *xline; - *xline = line_number; - return tmp; + if (*xline != line_number) { + long tmp = line_number - *xline; + *xline = line_number; + return tmp; } return 0; } -void nasm_quote(char **str) +void nasm_quote(char **str) { - int ln=strlen(*str); - char q=(*str)[0]; + int ln = strlen(*str); + char q = (*str)[0]; char *p; - if (ln>1 && (*str)[ln-1]==q && (q=='"' || q=='\'')) - return; + if (ln > 1 && (*str)[ln - 1] == q && (q == '"' || q == '\'')) + return; q = '"'; - if (strchr(*str,q)) - q = '\''; - p = nasm_malloc(ln+3); - strcpy(p+1, *str); + if (strchr(*str, q)) + q = '\''; + p = nasm_malloc(ln + 3); + strcpy(p + 1, *str); nasm_free(*str); - p[ln+1] = p[0] = q; - p[ln+2] = 0; + p[ln + 1] = p[0] = q; + p[ln + 2] = 0; *str = p; } - -char *nasm_strcat(char *one, char *two) + +char *nasm_strcat(char *one, char *two) { char *rslt; - int l1=strlen(one); - rslt = nasm_malloc(l1+strlen(two)+1); + int l1 = strlen(one); + rslt = nasm_malloc(l1 + strlen(two) + 1); strcpy(rslt, one); - strcpy(rslt+l1, two); + strcpy(rslt + l1, two); return rslt; } -void null_debug_init(struct ofmt *of, void *id, FILE *fp, efunc error ) {} -void null_debug_linenum(const char *filename, long linenumber, long segto) {} -void null_debug_deflabel(char *name, long segment, long offset, int is_global, char *special) {} -void null_debug_routine(const char *directive, const char *params) {} -void null_debug_typevalue(long type) {} -void null_debug_output(int type, void *param) {} -void null_debug_cleanup(void){} +void null_debug_init(struct ofmt *of, void *id, FILE * fp, efunc error) +{ +} +void null_debug_linenum(const char *filename, long linenumber, long segto) +{ +} +void null_debug_deflabel(char *name, long segment, long offset, + int is_global, char *special) +{ +} +void null_debug_routine(const char *directive, const char *params) +{ +} +void null_debug_typevalue(long type) +{ +} +void null_debug_output(int type, void *param) +{ +} +void null_debug_cleanup(void) +{ +} struct dfmt null_debug_form = { "Null debug format", |