nasmlib.c

   1 /* nasmlib.c    library routines for the Netwide Assembler
   2  *
   3  * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
   4  * Julian Hall. All rights reserved. The software is
   5  * redistributable under the licence given in the file "Licence"
   6  * distributed in the NASM archive.
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <ctype.h>
  13
  14 #include "nasm.h"
  15 #include "nasmlib.h"
  16
  17 static efunc nasm_malloc_error;
  18
  19 #ifdef LOGALLOC
  20 static FILE *logfp;
  21 #endif
  22
  23 void nasm_set_malloc_error (efunc error) {
  24     nasm_malloc_error = error;
  25 #ifdef LOGALLOC
  26     logfp = fopen ("malloc.log", "w");
  27     setvbuf (logfp, NULL, _IOLBF, BUFSIZ);
  28     fprintf (logfp, "null pointer is %p\n", NULL);
  29 #endif
  30 }
  31
  32 #ifdef LOGALLOC
  33 void *nasm_malloc_log (char *file, int line, size_t size)
  34 #else
  35 void *nasm_malloc (size_t size)
  36 #endif
  37 {
  38     void *p = malloc(size);
  39     if (!p)
  40         nasm_malloc_error (ERR_FATAL | ERR_NOFILE, "out of memory");
  41 #ifdef LOGALLOC
  42     else
  43         fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
  44                 file, line, (long)size, p);
  45 #endif
  46     return p;
  47 }
  48
  49 #ifdef LOGALLOC
  50 void *nasm_realloc_log (char *file, int line, void *q, size_t size)
  51 #else
  52 void *nasm_realloc (void *q, size_t size)
  53 #endif
  54 {
  55     void *p = q ? realloc(q, size) : malloc(size);
  56     if (!p)
  57         nasm_malloc_error (ERR_FATAL | ERR_NOFILE, "out of memory");
  58 #ifdef LOGALLOC
  59     else if (q)
  60         fprintf(logfp, "%s %d realloc(%p,%ld) returns %p\n",
  61                 file, line, q, (long)size, p);
  62     else
  63         fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
  64                 file, line, (long)size, p);
  65 #endif
  66     return p;
  67 }
  68
  69 #ifdef LOGALLOC
  70 void nasm_free_log (char *file, int line, void *q)
  71 #else
  72 void nasm_free (void *q)
  73 #endif
  74 {
  75     if (q) {
  76         free (q);
  77 #ifdef LOGALLOC
  78         fprintf(logfp, "%s %d free(%p)\n",
  79                 file, line, q);
  80 #endif
  81     }
  82 }
  83
  84 #ifdef LOGALLOC
  85 char *nasm_strdup_log (char *file, int line, char *s)
  86 #else
  87 char *nasm_strdup (char *s)
  88 #endif
  89 {
  90     char *p;
  91     int size = strlen(s)+1;
  92
  93     p = malloc(size);
  94     if (!p)
  95         nasm_malloc_error (ERR_FATAL | ERR_NOFILE, "out of memory");
  96 #ifdef LOGALLOC
  97     else
  98         fprintf(logfp, "%s %d strdup(%ld) returns %p\n",
  99                 file, line, (long)size, p);
 100 #endif
 101     strcpy (p, s);
 102     return p;
 103 }
 104
 105 int nasm_stricmp (char *s1, char *s2) {
 106     while (*s1 && toupper(*s1) == toupper(*s2))
 107         s1++, s2++;
 108     if (!*s1 && !*s2)
 109         return 0;
 110     else if (toupper(*s1) < toupper(*s2))
 111         return -1;
 112     else
 113         return 1;
 114 }
 115
 116 int nasm_strnicmp (char *s1, char *s2, int n) {
 117     while (n > 0 && *s1 && toupper(*s1) == toupper(*s2))
 118         s1++, s2++, n--;
 119     if ((!*s1 && !*s2) || n==0)
 120         return 0;
 121     else if (toupper(*s1) < toupper(*s2))
 122         return -1;
 123     else
 124         return 1;
 125 }
 126
 127 #define lib_isnumchar(c)   ( isalnum(c) || (c) == '$')
 128 #define numvalue(c)  ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
 129
 130 long readnum (char *str, int *error) {
 131     char *r = str, *q;
 132     long radix;
 133     long result;
 134
 135     *error = FALSE;
 136
 137     while (isspace(*r)) r++;           /* find start of number */
 138     q = r;
 139
 140     while (lib_isnumchar(*q)) q++;     /* find end of number */
 141
 142     /*
 143      * If it begins 0x, 0X or $, or ends in H, it's in hex. if it
 144      * ends in Q, it's octal. if it ends in B, it's binary.
 145      * Otherwise, it's ordinary decimal.
 146      */
 147     if (*r=='0' && (r[1]=='x' || r[1]=='X'))
 148         radix = 16, r += 2;
 149     else if (*r=='$')
 150         radix = 16, r++;
 151     else if (q[-1]=='H' || q[-1]=='h')
 152         radix = 16 , q--;
 153     else if (q[-1]=='Q' || q[-1]=='q')
 154         radix = 8 , q--;
 155     else if (q[-1]=='B' || q[-1]=='b')
 156         radix = 2 , q--;
 157     else
 158         radix = 10;
 159
 160     result = 0;
 161     while (*r && r < q) {
 162         if (*r<'0' || (*r>'9' && *r<'A') || numvalue(*r)>=radix) {
 163             *error = TRUE;
 164             return 0;
 165         }
 166         result = radix * result + numvalue(*r);
 167         r++;
 168     }
 169     return result;
 170 }
 171
 172 static long next_seg;
 173
 174 void seg_init(void) {
 175     next_seg = 0;
 176 }
 177
 178 long seg_alloc(void) {
 179     return (next_seg += 2) - 2;
 180 }
 181
 182 void fwriteshort (int data, FILE *fp) {
 183     fputc ((int) (data & 255), fp);
 184     fputc ((int) ((data >> 8) & 255), fp);
 185 }
 186
 187 void fwritelong (long data, FILE *fp) {
 188     fputc ((int) (data & 255), fp);
 189     fputc ((int) ((data >> 8) & 255), fp);
 190     fputc ((int) ((data >> 16) & 255), fp);
 191     fputc ((int) ((data >> 24) & 255), fp);
 192 }
 193
 194 void standard_extension (char *inname, char *outname, char *extension,
 195                          efunc error) {
 196     char *p, *q;
 197
 198     q = inname;
 199     p = outname;
 200     while (*q) *p++ = *q++;            /* copy, and find end of string */
 201     *p = '\0';                         /* terminate it */
 202     while (p > outname && *--p != '.');/* find final period (or whatever) */
 203     if (*p != '.') while (*p) p++;     /* go back to end if none found */
 204     if (!strcmp(p, extension)) {       /* is the extension already there? */
 205         if (*extension)
 206             error(ERR_WARNING | ERR_NOFILE,
 207                   "file name already ends in `%s': "
 208                   "output will be in `nasm.out'",
 209                   extension);
 210         else
 211             error(ERR_WARNING | ERR_NOFILE,
 212                   "file name already has no extension: "
 213                   "output will be in `nasm.out'");
 214         strcpy(outname, "nasm.out");
 215     } else
 216         strcpy(p, extension);
 217 }
 218
 219 #define RAA_BLKSIZE 4096               /* this many longs allocated at once */
 220 #define RAA_LAYERSIZE 1024             /* this many _pointers_ allocated */
 221
 222 typedef struct RAA RAA;
 223 typedef union RAA_UNION RAA_UNION;
 224 typedef struct RAA_LEAF RAA_LEAF;
 225 typedef struct RAA_BRANCH RAA_BRANCH;
 226
 227 struct RAA {
 228     int layers;
 229     long stepsize;
 230     union RAA_UNION {
 231         struct RAA_LEAF {
 232             long data[RAA_BLKSIZE];
 233         } l;
 234         struct RAA_BRANCH {
 235             struct RAA *data[RAA_LAYERSIZE];
 236         } b;
 237     } u;
 238 };
 239
 240 #define LEAFSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_LEAF))
 241 #define BRANCHSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_BRANCH))
 242
 243 #define LAYERSIZ(r) ( (r)->layers==0 ? RAA_BLKSIZE : RAA_LAYERSIZE )
 244
 245 static struct RAA *real_raa_init (int layers) {
 246     struct RAA *r;
 247
 248     if (layers == 0) {
 249         r = nasm_malloc (LEAFSIZ);
 250         memset (r->u.l.data, 0, sizeof(r->u.l.data));
 251         r->layers = 0;
 252         r->stepsize = 1L;
 253     } else {
 254         r = nasm_malloc (BRANCHSIZ);
 255         memset (r->u.b.data, 0, sizeof(r->u.b.data));
 256         r->layers = layers;
 257         r->stepsize = 1L;
 258         while (layers--)
 259             r->stepsize *= RAA_LAYERSIZE;
 260     }
 261     return r;
 262 }
 263
 264 struct RAA *raa_init (void) {
 265     return real_raa_init (0);
 266 }
 267
 268 void raa_free (struct RAA *r) {
 269     if (r->layers == 0)
 270         nasm_free (r);
 271     else {
 272         struct RAA **p;
 273         for (p = r->u.b.data; p - r->u.b.data < RAA_LAYERSIZE; p++)
 274             if (*p)
 275                 raa_free (*p);
 276     }
 277 }
 278
 279 long raa_read (struct RAA *r, long posn) {
 280     if (posn > r->stepsize * LAYERSIZ(r))
 281         return 0L;
 282     while (r->layers > 0) {
 283         ldiv_t l;
 284         l = ldiv (posn, r->stepsize);
 285         r = r->u.b.data[l.quot];
 286         posn = l.rem;
 287         if (!r)                        /* better check this */
 288             return 0L;
 289     }
 290     return r->u.l.data[posn];
 291 }
 292
 293 struct RAA *raa_write (struct RAA *r, long posn, long value) {
 294     struct RAA *result;
 295
 296     if (posn < 0)
 297         nasm_malloc_error (ERR_PANIC, "negative position in raa_write");
 298
 299     while (r->stepsize * LAYERSIZ(r) < posn) {
 300         /*
 301          * Must go up a layer.
 302          */
 303         struct RAA *s;
 304
 305         s = nasm_malloc (BRANCHSIZ);
 306         memset (s->u.b.data, 0, sizeof(r->u.b.data));
 307         s->layers = r->layers + 1;
 308         s->stepsize = RAA_LAYERSIZE * r->stepsize;
 309         s->u.b.data[0] = r;
 310         r = s;
 311     }
 312
 313     result = r;
 314
 315     while (r->layers > 0) {
 316         ldiv_t l;
 317         struct RAA **s;
 318         l = ldiv (posn, r->stepsize);
 319         s = &r->u.b.data[l.quot];
 320         if (!*s)
 321             *s = real_raa_init (r->layers - 1);
 322         r = *s;
 323         posn = l.rem;
 324     }
 325
 326     r->u.l.data[posn] = value;
 327
 328     return result;
 329 }
 330
 331 #define SAA_MAXLEN 8192
 332
 333 struct SAA {
 334     /*
 335      * members `end' and `elem_len' are only valid in first link in
 336      * list; `rptr' and `rpos' are used for reading
 337      */
 338     struct SAA *next, *end, *rptr;
 339     long elem_len, length, posn, start, rpos;
 340     char *data;
 341 };
 342
 343 struct SAA *saa_init (long elem_len) {
 344     struct SAA *s;
 345
 346     if (elem_len > SAA_MAXLEN)
 347         nasm_malloc_error (ERR_PANIC | ERR_NOFILE, "SAA with huge elements");
 348
 349     s = nasm_malloc (sizeof(struct SAA));
 350     s->posn = s->start = 0L;
 351     s->elem_len = elem_len;
 352     s->length = SAA_MAXLEN - (SAA_MAXLEN % elem_len);
 353     s->data = nasm_malloc (s->length);
 354     s->next = NULL;
 355     s->end = s;
 356
 357     return s;
 358 }
 359
 360 void saa_free (struct SAA *s) {
 361     struct SAA *t;
 362
 363     while (s) {
 364         t = s->next;
 365         nasm_free (s->data);
 366         nasm_free (s);
 367         s = t;
 368     }
 369 }
 370
 371 void *saa_wstruct (struct SAA *s) {
 372     void *p;
 373
 374     if (s->end->length - s->end->posn < s->elem_len) {
 375         s->end->next = nasm_malloc (sizeof(struct SAA));
 376         s->end->next->start = s->end->start + s->end->posn;
 377         s->end = s->end->next;
 378         s->end->length = s->length;
 379         s->end->next = NULL;
 380         s->end->posn = 0L;
 381         s->end->data = nasm_malloc (s->length);
 382     }
 383
 384     p = s->end->data + s->end->posn;
 385     s->end->posn += s->elem_len;
 386     return p;
 387 }
 388
 389 void saa_wbytes (struct SAA *s, void *data, long len) {
 390     char *d = data;
 391
 392     while (len > 0) {
 393         long l = s->end->length - s->end->posn;
 394         if (l > len)
 395             l = len;
 396         if (l > 0) {
 397             if (d) {
 398                 memcpy (s->end->data + s->end->posn, d, l);
 399                 d += l;
 400             } else
 401                 memset (s->end->data + s->end->posn, 0, l);
 402             s->end->posn += l;
 403             len -= l;
 404         }
 405         if (len > 0) {
 406             s->end->next = nasm_malloc (sizeof(struct SAA));
 407             s->end->next->start = s->end->start + s->end->posn;
 408             s->end = s->end->next;
 409             s->end->length = s->length;
 410             s->end->next = NULL;
 411             s->end->posn = 0L;
 412             s->end->data = nasm_malloc (s->length);
 413         }
 414     }
 415 }
 416
 417 void saa_rewind (struct SAA *s) {
 418     s->rptr = s;
 419     s->rpos = 0L;
 420 }
 421
 422 void *saa_rstruct (struct SAA *s) {
 423     void *p;
 424
 425     if (!s->rptr)
 426         return NULL;
 427
 428     if (s->rptr->posn - s->rpos < s->elem_len) {
 429         s->rptr = s->rptr->next;
 430         if (!s->rptr)
 431             return NULL;               /* end of array */
 432         s->rpos = 0L;
 433     }
 434
 435     p = s->rptr->data + s->rpos;
 436     s->rpos += s->elem_len;
 437     return p;
 438 }
 439
 440 void *saa_rbytes (struct SAA *s, long *len) {
 441     void *p;
 442
 443     if (!s->rptr)
 444         return NULL;
 445
 446     p = s->rptr->data + s->rpos;
 447     *len = s->rptr->posn - s->rpos;
 448     s->rptr = s->rptr->next;
 449     s->rpos = 0L;
 450     return p;
 451 }
 452
 453 void saa_rnbytes (struct SAA *s, void *data, long len) {
 454     char *d = data;
 455
 456     while (len > 0) {
 457         long l;
 458
 459         if (!s->rptr)
 460             return;
 461
 462         l = s->rptr->posn - s->rpos;
 463         if (l > len)
 464             l = len;
 465         if (l > 0) {
 466             memcpy (d, s->rptr->data + s->rpos, l);
 467             d += l;
 468             s->rpos += l;
 469             len -= l;
 470         }
 471         if (len > 0) {
 472             s->rptr = s->rptr->next;
 473             s->rpos = 0L;
 474         }
 475     }
 476 }
 477
 478 void saa_fread (struct SAA *s, long posn, void *data, long len) {
 479     struct SAA *p;
 480     long pos;
 481     char *cdata = data;
 482
 483     if (!s->rptr || posn > s->rptr->start + s->rpos)
 484         saa_rewind (s);
 485     while (posn >= s->rptr->start + s->rptr->posn) {
 486         s->rptr = s->rptr->next;
 487         if (!s->rptr)
 488             return;                    /* what else can we do?! */
 489     }
 490
 491     p = s->rptr;
 492     pos = posn - s->rptr->start;
 493     while (len) {
 494         long l = s->rptr->posn - pos;
 495         if (l > len)
 496             l = len;
 497         memcpy (cdata, s->rptr->data+pos, l);
 498         len -= l;
 499         cdata += l;
 500         p = p->next;
 501         if (!p)
 502             return;
 503         pos = 0L;
 504     }
 505 }
 506
 507 void saa_fwrite (struct SAA *s, long posn, void *data, long len) {
 508     struct SAA *p;
 509     long pos;
 510     char *cdata = data;
 511
 512     if (!s->rptr || posn > s->rptr->start + s->rpos)
 513         saa_rewind (s);
 514     while (posn >= s->rptr->start + s->rptr->posn) {
 515         s->rptr = s->rptr->next;
 516         if (!s->rptr)
 517             return;                    /* what else can we do?! */
 518     }
 519
 520     p = s->rptr;
 521     pos = posn - s->rptr->start;
 522     while (len) {
 523         long l = s->rptr->posn - pos;
 524         if (l > len)
 525             l = len;
 526         memcpy (s->rptr->data+pos, cdata, l);
 527         len -= l;
 528         cdata += l;
 529         p = p->next;
 530         if (!p)
 531             return;
 532         pos = 0L;
 533     }
 534 }
 535
 536 void saa_fpwrite (struct SAA *s, FILE *fp) {
 537     char *data;
 538     long len;
 539
 540     saa_rewind (s);
 541     while ( (data = saa_rbytes (s, &len)) )
 542         fwrite (data, 1, len, fp);
 543 }