*
* The Netwide Assembler is copyright (C) 1996 Simon Tatham and
* Julian Hall. All rights reserved. The software is
- * redistributable under the licence given in the file "Licence"
+ * redistributable under the license given in the file "LICENSE"
* distributed in the NASM archive.
*/
+#include "compiler.h"
+
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#endif
{
if (q) {
- free(q);
#ifdef LOGALLOC
fprintf(logfp, "%s %d free(%p)\n", file, line, q);
#endif
+ free(q);
}
}
return p;
}
-#if !defined(stricmp) && !defined(strcasecmp)
+#ifndef nasm_stricmp
int nasm_stricmp(const char *s1, const char *s2)
{
while (*s1 && tolower(*s1) == tolower(*s2))
}
#endif
-#if !defined(strnicmp) && !defined(strncasecmp)
+#ifndef nasm_strnicmp
int nasm_strnicmp(const char *s1, const char *s2, int n)
{
while (n > 0 && *s1 && tolower(*s1) == tolower(*s2))
}
#endif
-#if !defined(strsep)
+#ifndef nasm_strsep
char *nasm_strsep(char **stringp, const char *delim)
{
char *s = *stringp;
#endif
-#define lib_isnumchar(c) ( isalnum(c) || (c) == '$')
+#define lib_isnumchar(c) (isalnum(c) || (c) == '$' || (c) == '_')
#define numvalue(c) ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
-int64_t readnum(char *str, int *error)
+static int radix_letter(char c)
+{
+ switch (c) {
+ case 'b': case 'B':
+ case 'y': case 'Y':
+ return 2; /* Binary */
+ case 'o': case 'O':
+ case 'q': case 'Q':
+ return 8; /* Octal */
+ case 'h': case 'H':
+ case 'x': case 'X':
+ return 16; /* Hexadecimal */
+ case 'd': case 'D':
+ case 't': case 'T':
+ return 10; /* Decimal */
+ default:
+ return 0; /* Not a known radix letter */
+ }
+}
+
+int64_t readnum(char *str, bool *error)
{
char *r = str, *q;
- int32_t radix;
+ int32_t pradix, sradix, radix;
+ int plen, slen, len;
uint64_t result, checklimit;
int digit, last;
- int warn = FALSE;
+ bool warn = false;
int sign = 1;
- *error = FALSE;
+ *error = false;
while (isspace(*r))
r++; /* find start 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--;
- else
- radix = 10;
+ len = q-r;
+ if (!len) {
+ /* Not numeric */
+ *error = true;
+ return 0;
+ }
/*
- * If this number has been found for us by something other than
- * the ordinary scanners, then it might be malformed by having
- * nothing between the prefix and the suffix. Check this case
- * now.
+ * Handle radix formats:
+ *
+ * 0<radix-letter><string>
+ * $<string> (hexadecimal)
+ * <string><radix-letter>
*/
- if (r >= q) {
- *error = TRUE;
- return 0;
+ pradix = sradix = 0;
+ plen = slen = 0;
+
+ if (len > 2 && *r == '0' && (pradix = radix_letter(r[1])) != 0)
+ plen = 2;
+ else if (len > 1 && *r == '$')
+ pradix = 16, plen = 1;
+
+ if (len > 1 && (sradix = radix_letter(q[-1])) != 0)
+ slen = 1;
+
+ if (pradix > sradix) {
+ radix = pradix;
+ r += plen;
+ } else if (sradix > pradix) {
+ radix = sradix;
+ q -= slen;
+ } else {
+ /* Either decimal, or invalid -- if invalid, we'll trip up
+ further down. */
+ radix = 10;
}
-
+
/*
- * `checklimit' must be 2**(32|64) / radix. We can't do that in
- * 32/64-bit arithmetic, which we're (probably) using, so we
+ * `checklimit' must be 2**64 / radix. We can't do that in
+ * 64-bit arithmetic, which we're (probably) using, so we
* cheat: since we know that all radices we use are even, we
- * can divide 2**(31|63) by radix/2 instead.
+ * can divide 2**63 by radix/2 instead.
*/
- if (globalbits == 64)
- checklimit = 0x8000000000000000ULL / (radix >> 1);
- else
- checklimit = 0x80000000UL / (radix >> 1);
+ checklimit = 0x8000000000000000ULL / (radix >> 1);
/*
* Calculate the highest allowable value for the last digit of a
- * 32-bit constant... in radix 10, it is 6, otherwise it is 0
+ * 64-bit constant... in radix 10, it is 6, otherwise it is 0
*/
last = (radix == 10 ? 6 : 0);
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;
+ if (*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",
+ "numeric constant %s does not fit in 64 bits",
str);
return result * sign;
}
-int64_t readstrnum(char *str, int length, int *warn)
+int64_t readstrnum(char *str, int length, bool *warn)
{
int64_t charconst = 0;
int i;
- *warn = FALSE;
+ *warn = false;
str += length;
if (globalbits == 64) {
for (i = 0; i < length; i++) {
if (charconst & 0xFF00000000000000ULL)
- *warn = TRUE;
+ *warn = true;
charconst = (charconst << 8) + (uint8_t)*--str;
}
} else {
for (i = 0; i < length; i++) {
if (charconst & 0xFF000000UL)
- *warn = TRUE;
+ *warn = true;
charconst = (charconst << 8) + (uint8_t)*--str;
}
}
return (next_seg += 2) - 2;
}
-void fwriteint16_t(int data, FILE * fp)
+#if X86_MEMORY
+
+void fwriteint16_t(uint16_t data, FILE * fp)
+{
+ fwrite(&data, 1, 2, fp);
+}
+
+void fwriteint32_t(uint32_t data, FILE * fp)
+{
+ fwrite(&data, 1, 4, fp);
+}
+
+void fwriteint64_t(uint64_t data, FILE * fp)
+{
+ fwrite(&data, 1, 8, fp);
+}
+
+void fwriteaddr(uint64_t data, int size, FILE * fp)
+{
+ fwrite(&data, 1, size, fp);
+}
+
+#else /* !X86_MEMORY */
+
+void fwriteint16_t(uint16_t data, FILE * fp)
+{
+ char buffer[2], *p = buffer;
+ WRITESHORT(p, data);
+ fwrite(buffer, 1, 2, fp);
+}
+
+void fwriteint32_t(uint32_t data, FILE * fp)
{
- fputc((int)(data & 255), fp);
- fputc((int)((data >> 8) & 255), fp);
+ char buffer[4], *p = buffer;
+ WRITELONG(p, data);
+ fwrite(buffer, 1, 4, fp);
}
-void fwriteint32_t(int32_t data, FILE * fp)
+void fwriteint64_t(uint64_t 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);
+ char buffer[8], *p = buffer;
+ WRITEDLONG(p, data);
+ fwrite(buffer, 1, 8, fp);
}
-void fwriteint64_t(int64_t data, FILE * fp)
+void fwriteaddr(uint64_t data, int size, 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 >> 32) & 255), fp);
- fputc((int)((data >> 40) & 255), fp);
- fputc((int)((data >> 48) & 255), fp);
- fputc((int)((data >> 56) & 255), fp);
+ char buffer[8], *p = buffer;
+ WRITEADDR(p, data, size);
+ fwrite(buffer, 1, size, fp);
}
+#endif
+
void standard_extension(char *inname, char *outname, char *extension,
efunc error)
{
#define LEAFSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_LEAF))
#define BRANCHSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_BRANCH))
-#define LAYERSIZ(r) ( (r)->layers==0 ? RAA_BLKSIZE : RAA_LAYERSIZE )
+#define LAYERSHIFT(r) ( (r)->layers==0 ? RAA_BLKSHIFT : RAA_LAYERSHIFT )
static struct RAA *real_raa_init(int layers)
{
if (layers == 0) {
r = nasm_zalloc(LEAFSIZ);
- r->stepsize = 1L;
+ r->shift = 0;
} 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->shift = (RAA_BLKSHIFT-RAA_LAYERSHIFT) + layers*RAA_LAYERSHIFT;
}
return r;
}
void raa_free(struct RAA *r)
{
- if (r->layers == 0)
- nasm_free(r);
- else {
+ if (r->layers) {
struct RAA **p;
for (p = r->u.b.data; p - r->u.b.data < RAA_LAYERSIZE; p++)
if (*p)
raa_free(*p);
}
+ nasm_free(r);
}
-int32_t raa_read(struct RAA *r, int32_t posn)
+int64_t raa_read(struct RAA *r, int32_t posn)
{
- if (posn >= r->stepsize * LAYERSIZ(r))
+ if ((uint32_t)posn >= (UINT32_C(1) << (r->shift + LAYERSHIFT(r))))
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;
+ int32_t l = posn >> r->shift;
+ posn &= (UINT32_C(1) << r->shift)-1;
+ r = r->u.b.data[l];
if (!r)
return 0; /* Return 0 for undefined entries */
}
return r->u.l.data[posn];
}
-struct RAA *raa_write(struct RAA *r, int32_t posn, int32_t value)
+struct RAA *raa_write(struct RAA *r, int32_t posn, int64_t value)
{
struct RAA *result;
if (posn < 0)
nasm_malloc_error(ERR_PANIC, "negative position in raa_write");
- while (r->stepsize * LAYERSIZ(r) <= posn) {
+ while ((UINT32_C(1) << (r->shift+LAYERSHIFT(r))) <= (uint32_t)posn) {
/*
* Must add a layer.
*/
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->shift = LAYERSHIFT(r) + r->shift;
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];
+ int32_t l = posn >> r->shift;
+ posn &= (UINT32_C(1) << r->shift)-1;
+ s = &r->u.b.data[l];
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
+/* Aggregate SAA components smaller than this */
+#define SAA_BLKLEN 65536
-struct SAA *saa_init(int32_t elem_len)
+struct SAA *saa_init(size_t elem_len)
{
struct SAA *s;
+ char *data;
+
+ s = nasm_zalloc(sizeof(struct SAA));
- if (elem_len > SAA_MAXLEN)
- nasm_malloc_error(ERR_PANIC | ERR_NOFILE,
- "SAA with huge elements");
+ if (elem_len >= SAA_BLKLEN)
+ s->blk_len = elem_len;
+ else
+ s->blk_len = SAA_BLKLEN - (SAA_BLKLEN % elem_len);
- 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;
+ s->length = s->blk_len;
+ data = nasm_malloc(s->blk_len);
+ s->nblkptrs = s->nblks = 1;
+ s->blk_ptrs = nasm_malloc(sizeof(char *));
+ s->blk_ptrs[0] = data;
+ s->wblk = s->rblk = &s->blk_ptrs[0];
return s;
}
void saa_free(struct SAA *s)
{
- struct SAA *t;
+ char **p;
+ size_t n;
+
+ for (p = s->blk_ptrs, n = s->nblks; n; p++, n--)
+ nasm_free(*p);
+
+ nasm_free(s->blk_ptrs);
+ nasm_free(s);
+}
+
+/* Add one allocation block to an SAA */
+static void saa_extend(struct SAA *s)
+{
+ size_t blkn = s->nblks++;
- while (s) {
- t = s->next;
- nasm_free(s->data);
- nasm_free(s);
- s = t;
+ if (blkn >= s->nblkptrs) {
+ size_t rindex = s->rblk - s->blk_ptrs;
+ size_t windex = s->wblk - s->blk_ptrs;
+
+ s->nblkptrs <<= 1;
+ s->blk_ptrs = nasm_realloc(s->blk_ptrs, s->nblkptrs*sizeof(char *));
+
+ s->rblk = s->blk_ptrs + rindex;
+ s->wblk = s->blk_ptrs + windex;
}
+
+ s->blk_ptrs[blkn] = nasm_malloc(s->blk_len);
+ s->length += s->blk_len;
}
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);
+ if (s->wpos % s->elem_len)
+ nasm_malloc_error(ERR_PANIC|ERR_NOFILE,
+ "misaligned wpos in saa_wstruct");
+
+ if (s->wpos + s->elem_len > s->blk_len) {
+ if (s->wpos != s->blk_len)
+ nasm_malloc_error(ERR_PANIC|ERR_NOFILE,
+ "unfilled block in saa_wstruct");
+
+ if (s->wptr + s->elem_len > s->length)
+ saa_extend(s);
+ s->wblk++;
+ s->wpos = 0;
}
- p = s->end->data + s->end->posn;
- s->end->posn += s->elem_len;
+ p = *s->wblk + s->wpos;
+ s->wpos += s->elem_len;
+ s->wptr += s->elem_len;
+
+ if (s->wptr > s->datalen)
+ s->datalen = s->wptr;
+
return p;
}
-void saa_wbytes(struct SAA *s, const void *data, int32_t len)
+void saa_wbytes(struct SAA *s, const void *data, size_t len)
{
const char *d = data;
- while (len > 0) {
- int32_t l = s->end->length - s->end->posn;
+ while (len) {
+ size_t l = s->blk_len - s->wpos;
if (l > len)
l = len;
- if (l > 0) {
+ if (l) {
if (d) {
- memcpy(s->end->data + s->end->posn, d, l);
+ memcpy(*s->wblk + s->wpos, d, l);
d += l;
} else
- memset(s->end->data + s->end->posn, 0, l);
- s->end->posn += l;
+ memset(*s->wblk + s->wpos, 0, l);
+ s->wpos += l;
+ s->wptr += l;
len -= l;
+
+ if (s->datalen < s->wptr)
+ s->datalen = s->wptr;
}
- 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);
- }
+ if (len) {
+ if (s->wptr >= s->length)
+ saa_extend(s);
+ s->wblk++;
+ s->wpos = 0;
+ }
}
}
+/* write unsigned LEB128 value to SAA */
+void saa_wleb128u(struct SAA *psaa, int value)
+{
+ char temp[64], *ptemp;
+ uint8_t byte;
+ int len;
+
+ ptemp = temp;
+ len = 0;
+ do
+ {
+ byte = value & 127;
+ value >>= 7;
+ if (value != 0) /* more bytes to come */
+ byte |= 0x80;
+ *ptemp = byte;
+ ptemp++;
+ len++;
+ } while (value != 0);
+ saa_wbytes(psaa, temp, len);
+}
+
+/* write signed LEB128 value to SAA */
+void saa_wleb128s(struct SAA *psaa, int value)
+{
+ char temp[64], *ptemp;
+ uint8_t byte;
+ bool more, negative;
+ int size, len;
+
+ ptemp = temp;
+ more = 1;
+ negative = (value < 0);
+ size = sizeof(int) * 8;
+ len = 0;
+ while(more)
+ {
+ byte = value & 0x7f;
+ value >>= 7;
+ if (negative)
+ /* sign extend */
+ value |= - (1 <<(size - 7));
+ /* sign bit of byte is second high order bit (0x40) */
+ if ((value == 0 && ! (byte & 0x40)) ||
+ ((value == -1) && (byte & 0x40)))
+ more = 0;
+ else
+ byte |= 0x80;
+ *ptemp = byte;
+ ptemp++;
+ len++;
+ }
+ saa_wbytes(psaa, temp, len);
+}
+
void saa_rewind(struct SAA *s)
{
- s->rptr = s;
- s->rpos = 0L;
+ s->rblk = s->blk_ptrs;
+ s->rpos = s->rptr = 0;
}
void *saa_rstruct(struct SAA *s)
{
void *p;
- if (!s->rptr)
- return NULL;
+ if (s->rptr + s->elem_len > s->datalen)
+ return NULL;
+
+ if (s->rpos % s->elem_len)
+ nasm_malloc_error(ERR_PANIC|ERR_NOFILE,
+ "misaligned rpos in saa_rstruct");
- 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;
+ if (s->rpos + s->elem_len > s->blk_len) {
+ s->rblk++;
+ s->rpos = 0;
}
- p = s->rptr->data + s->rpos;
+ p = *s->rblk + s->rpos;
s->rpos += s->elem_len;
+ s->rptr += s->elem_len;
+
return p;
}
-void *saa_rbytes(struct SAA *s, int32_t *len)
+const void *saa_rbytes(struct SAA *s, size_t *lenp)
{
- void *p;
+ const void *p;
+ size_t len;
+
+ if (s->rptr >= s->datalen) {
+ *lenp = 0;
+ return NULL;
+ }
+
+ if (s->rpos >= s->blk_len) {
+ s->rblk++;
+ s->rpos = 0;
+ }
- if (!s->rptr)
- return NULL;
+ len = *lenp;
+ if (len > s->datalen - s->rptr)
+ len = s->datalen - s->rptr;
+ if (len > s->blk_len - s->rpos)
+ len = s->blk_len - s->rpos;
+
+ *lenp = len;
+ p = *s->rblk + s->rpos;
+
+ s->rpos += len;
+ s->rptr += len;
- 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, int32_t len)
+void saa_rnbytes(struct SAA *s, void *data, size_t len)
{
char *d = data;
- while (len > 0) {
- int32_t l;
+ if (s->rptr + len > s->datalen) {
+ nasm_malloc_error(ERR_PANIC|ERR_NOFILE, "overrun in saa_rnbytes");
+ return;
+ }
- if (!s->rptr)
- return;
+ while (len) {
+ size_t l;
+ const void *p;
- 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;
- }
+ l = len;
+ p = saa_rbytes(s, &l);
+
+ memcpy(d, p, l);
+ d += l;
+ len -= l;
}
}
-void saa_fread(struct SAA *s, int32_t posn, void *data, int32_t len)
+/* Same as saa_rnbytes, except position the counter first */
+void saa_fread(struct SAA *s, size_t posn, void *data, size_t len)
{
- struct SAA *p;
- int64_t pos;
- char *cdata = data;
+ size_t ix;
- 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?! */
+ if (posn+len > s->datalen) {
+ nasm_malloc_error(ERR_PANIC|ERR_NOFILE, "overrun in saa_fread");
+ return;
}
- pos = posn - p->start;
- while (len) {
- int64_t 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 = 0LL;
- }
- s->rptr = p;
+ ix = posn / s->blk_len;
+ s->rptr = posn;
+ s->rpos = posn % s->blk_len;
+ s->rblk = &s->blk_ptrs[ix];
+
+ saa_rnbytes(s, data, len);
}
-void saa_fwrite(struct SAA *s, int32_t posn, void *data, int32_t len)
+/* Same as saa_wbytes, except position the counter first */
+void saa_fwrite(struct SAA *s, size_t posn, const void *data, size_t len)
{
- struct SAA *p;
- int64_t pos;
- char *cdata = data;
+ size_t ix;
- 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?! */
+ if (posn > s->datalen) {
+ /* Seek beyond the end of the existing array not supported */
+ nasm_malloc_error(ERR_PANIC|ERR_NOFILE, "overrun in saa_fwrite");
+ return;
}
- pos = posn - p->start;
- while (len) {
- int64_t 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 = 0LL;
+ ix = posn / s->blk_len;
+ s->wptr = posn;
+ s->wpos = posn % s->blk_len;
+ s->wblk = &s->blk_ptrs[ix];
+
+ if (!s->wpos) {
+ s->wpos = s->blk_len;
+ s->wblk--;
}
- s->rptr = p;
+
+ saa_wbytes(s, data, len);
}
void saa_fpwrite(struct SAA *s, FILE * fp)
{
- char *data;
- int32_t len;
+ const char *data;
+ size_t len;
saa_rewind(s);
-// while ((data = saa_rbytes(s, &len)))
- for (; (data = saa_rbytes(s, &len));)
+ while (len = s->datalen, (data = saa_rbytes(s, &len)) != NULL)
fwrite(data, 1, len, fp);
}
const char *prefix_name(int token)
{
unsigned int prefix = token-PREFIX_ENUM_START;
- if (prefix > sizeof prefix_names / sizeof(const char *))
+ if (prefix > elements(prefix_names))
return NULL;
return prefix_names[prefix];
/*
* Binary search.
*/
-int bsi(char *string, const char **array, int size)
+int bsi(const char *string, const char **array, int size)
{
int i = -1, j = size; /* always, i < index < j */
while (j - i >= 2) {
return -1; /* we haven't got it :( */
}
-int bsii(char *string, const char **array, int size)
+int bsii(const char *string, const char **array, int size)
{
int i = -1, j = size; /* always, i < index < j */
while (j - i >= 2) {
{
(void)filename;
(void)linenumber;
- (void)segto;
+ (void)segto;
}
-void null_debug_deflabel(char *name, int32_t segment, int32_t offset,
+void null_debug_deflabel(char *name, int32_t segment, int64_t offset,
int is_global, char *special)
{
(void)name;
projects / platform / upstream / nasm.git / blobdiff