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 "compiler.h"
  10
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <ctype.h>
  15 #include <inttypes.h>
  16
  17 #include "nasm.h"
  18 #include "nasmlib.h"
  19 #include "insns.h"
  20
  21 int globalbits = 0;    /* defined in nasm.h, works better here for ASM+DISASM */
  22 efunc nasm_malloc_error;        /* Exported for the benefit of vsnprintf.c */
  23
  24 #ifdef LOGALLOC
  25 static FILE *logfp;
  26 #endif
  27
  28 void nasm_set_malloc_error(efunc error)
  29 {
  30     nasm_malloc_error = error;
  31 #ifdef LOGALLOC
  32     logfp = fopen("malloc.log", "w");
  33     setvbuf(logfp, NULL, _IOLBF, BUFSIZ);
  34     fprintf(logfp, "null pointer is %p\n", NULL);
  35 #endif
  36 }
  37
  38 #ifdef LOGALLOC
  39 void *nasm_malloc_log(char *file, int line, size_t size)
  40 #else
  41 void *nasm_malloc(size_t size)
  42 #endif
  43 {
  44     void *p = malloc(size);
  45     if (!p)
  46         nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
  47 #ifdef LOGALLOC
  48     else
  49         fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
  50                 file, line, (long)size, p);
  51 #endif
  52     return p;
  53 }
  54
  55 #ifdef LOGALLOC
  56 void *nasm_zalloc_log(char *file, int line, size_t size)
  57 #else
  58 void *nasm_zalloc(size_t size)
  59 #endif
  60 {
  61     void *p = calloc(size, 1);
  62     if (!p)
  63         nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
  64 #ifdef LOGALLOC
  65     else
  66         fprintf(logfp, "%s %d calloc(%ld, 1) returns %p\n",
  67                 file, line, (long)size, p);
  68 #endif
  69     return p;
  70 }
  71
  72 #ifdef LOGALLOC
  73 void *nasm_realloc_log(char *file, int line, void *q, size_t size)
  74 #else
  75 void *nasm_realloc(void *q, size_t size)
  76 #endif
  77 {
  78     void *p = q ? realloc(q, size) : malloc(size);
  79     if (!p)
  80         nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
  81 #ifdef LOGALLOC
  82     else if (q)
  83         fprintf(logfp, "%s %d realloc(%p,%ld) returns %p\n",
  84                 file, line, q, (long)size, p);
  85     else
  86         fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
  87                 file, line, (long)size, p);
  88 #endif
  89     return p;
  90 }
  91
  92 #ifdef LOGALLOC
  93 void nasm_free_log(char *file, int line, void *q)
  94 #else
  95 void nasm_free(void *q)
  96 #endif
  97 {
  98     if (q) {
  99         free(q);
 100 #ifdef LOGALLOC
 101         fprintf(logfp, "%s %d free(%p)\n", file, line, q);
 102 #endif
 103     }
 104 }
 105
 106 #ifdef LOGALLOC
 107 char *nasm_strdup_log(char *file, int line, const char *s)
 108 #else
 109 char *nasm_strdup(const char *s)
 110 #endif
 111 {
 112     char *p;
 113     int size = strlen(s) + 1;
 114
 115     p = malloc(size);
 116     if (!p)
 117         nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
 118 #ifdef LOGALLOC
 119     else
 120         fprintf(logfp, "%s %d strdup(%ld) returns %p\n",
 121                 file, line, (long)size, p);
 122 #endif
 123     strcpy(p, s);
 124     return p;
 125 }
 126
 127 #ifdef LOGALLOC
 128 char *nasm_strndup_log(char *file, int line, char *s, size_t len)
 129 #else
 130 char *nasm_strndup(char *s, size_t len)
 131 #endif
 132 {
 133     char *p;
 134     int size = len + 1;
 135
 136     p = malloc(size);
 137     if (!p)
 138         nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
 139 #ifdef LOGALLOC
 140     else
 141         fprintf(logfp, "%s %d strndup(%ld) returns %p\n",
 142                 file, line, (long)size, p);
 143 #endif
 144     strncpy(p, s, len);
 145     p[len] = '\0';
 146     return p;
 147 }
 148
 149 #ifndef nasm_stricmp
 150 int nasm_stricmp(const char *s1, const char *s2)
 151 {
 152     while (*s1 && tolower(*s1) == tolower(*s2))
 153         s1++, s2++;
 154     if (!*s1 && !*s2)
 155         return 0;
 156     else if (tolower(*s1) < tolower(*s2))
 157         return -1;
 158     else
 159         return 1;
 160 }
 161 #endif
 162
 163 #ifndef nasm_strnicmp
 164 int nasm_strnicmp(const char *s1, const char *s2, int n)
 165 {
 166     while (n > 0 && *s1 && tolower(*s1) == tolower(*s2))
 167         s1++, s2++, n--;
 168     if ((!*s1 && !*s2) || n == 0)
 169         return 0;
 170     else if (tolower(*s1) < tolower(*s2))
 171         return -1;
 172     else
 173         return 1;
 174 }
 175 #endif
 176
 177 #ifndef nasm_strsep
 178 char *nasm_strsep(char **stringp, const char *delim)
 179 {
 180         char *s = *stringp;
 181         char *e;
 182
 183         if (!s)
 184                 return NULL;
 185
 186         e = strpbrk(s, delim);
 187         if (e)
 188                 *e++ = '\0';
 189
 190         *stringp = e;
 191         return s;
 192 }
 193 #endif
 194
 195
 196 #define lib_isnumchar(c)   (isalnum(c) || (c) == '$' || (c) == '_')
 197 #define numvalue(c)  ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
 198
 199 int64_t readnum(char *str, bool *error)
 200 {
 201     char *r = str, *q;
 202     int32_t radix;
 203     uint64_t result, checklimit;
 204     int digit, last;
 205     bool warn = false;
 206     int sign = 1;
 207
 208     *error = false;
 209
 210     while (isspace(*r))
 211         r++;                    /* find start of number */
 212
 213     /*
 214      * If the number came from make_tok_num (as a result of an %assign), it
 215      * might have a '-' built into it (rather than in a preceeding token).
 216      */
 217     if (*r == '-') {
 218         r++;
 219         sign = -1;
 220     }
 221
 222     q = r;
 223
 224     while (lib_isnumchar(*q))
 225         q++;                    /* find end of number */
 226
 227     /*
 228      * If it begins 0x, 0X or $, or ends in H, it's in hex. if it
 229      * ends in Q, it's octal. if it ends in B, it's binary.
 230      * Otherwise, it's ordinary decimal.
 231      */
 232     if (*r == '0' && (r[1] == 'x' || r[1] == 'X'))
 233         radix = 16, r += 2;
 234     else if (*r == '$')
 235         radix = 16, r++;
 236     else if (q[-1] == 'H' || q[-1] == 'h')
 237         radix = 16, q--;
 238     else if (q[-1] == 'Q' || q[-1] == 'q' || q[-1] == 'O' || q[-1] == 'o')
 239         radix = 8, q--;
 240     else if (q[-1] == 'B' || q[-1] == 'b' || q[-1] == 'Y' || q[-1] == 'y')
 241         radix = 2, q--;
 242     else if (q[-1] == 'D' || q[-1] == 'd' || q[-1] == 'T' || q[-1] == 't')
 243         radix = 10, q--;
 244     else
 245         radix = 10;
 246
 247     /*
 248      * If this number has been found for us by something other than
 249      * the ordinary scanners, then it might be malformed by having
 250      * nothing between the prefix and the suffix. Check this case
 251      * now.
 252      */
 253     if (r >= q) {
 254         *error = true;
 255         return 0;
 256     }
 257
 258     /*
 259      * `checklimit' must be 2**(32|64) / radix. We can't do that in
 260      * 32/64-bit arithmetic, which we're (probably) using, so we
 261      * cheat: since we know that all radices we use are even, we
 262      * can divide 2**(31|63) by radix/2 instead.
 263      */
 264     if (globalbits == 64)
 265         checklimit = 0x8000000000000000ULL / (radix >> 1);
 266     else
 267         checklimit = 0x80000000UL / (radix >> 1);
 268
 269     /*
 270      * Calculate the highest allowable value for the last digit of a
 271      * 32-bit constant... in radix 10, it is 6, otherwise it is 0
 272      */
 273     last = (radix == 10 ? 6 : 0);
 274
 275     result = 0;
 276     while (*r && r < q) {
 277         if (*r != '_') {
 278             if (*r < '0' || (*r > '9' && *r < 'A')
 279                 || (digit = numvalue(*r)) >= radix) {
 280                 *error = true;
 281                 return 0;
 282             }
 283             if (result > checklimit ||
 284                 (result == checklimit && digit >= last)) {
 285                 warn = true;
 286             }
 287
 288             result = radix * result + digit;
 289         }
 290         r++;
 291     }
 292
 293     if (warn)
 294         nasm_malloc_error(ERR_WARNING | ERR_PASS1 | ERR_WARN_NOV,
 295                           "numeric constant %s does not fit in 32 bits",
 296                           str);
 297
 298     return result * sign;
 299 }
 300
 301 int64_t readstrnum(char *str, int length, bool *warn)
 302 {
 303     int64_t charconst = 0;
 304     int i;
 305
 306     *warn = false;
 307
 308     str += length;
 309     if (globalbits == 64) {
 310         for (i = 0; i < length; i++) {
 311             if (charconst & 0xFF00000000000000ULL)
 312                 *warn = true;
 313             charconst = (charconst << 8) + (uint8_t)*--str;
 314         }
 315     } else {
 316         for (i = 0; i < length; i++) {
 317             if (charconst & 0xFF000000UL)
 318                 *warn = true;
 319             charconst = (charconst << 8) + (uint8_t)*--str;
 320         }
 321     }
 322     return charconst;
 323 }
 324
 325 static int32_t next_seg;
 326
 327 void seg_init(void)
 328 {
 329     next_seg = 0;
 330 }
 331
 332 int32_t seg_alloc(void)
 333 {
 334     return (next_seg += 2) - 2;
 335 }
 336
 337 void fwriteint16_t(int data, FILE * fp)
 338 {
 339     fputc((int)(data & 255), fp);
 340     fputc((int)((data >> 8) & 255), fp);
 341 }
 342
 343 void fwriteint32_t(int32_t data, FILE * fp)
 344 {
 345     fputc((int)(data & 255), fp);
 346     fputc((int)((data >> 8) & 255), fp);
 347     fputc((int)((data >> 16) & 255), fp);
 348     fputc((int)((data >> 24) & 255), fp);
 349 }
 350
 351 void fwriteint64_t(int64_t data, FILE * fp)
 352 {
 353     fputc((int)(data & 255), fp);
 354     fputc((int)((data >> 8) & 255), fp);
 355     fputc((int)((data >> 16) & 255), fp);
 356     fputc((int)((data >> 24) & 255), fp);
 357     fputc((int)((data >> 32) & 255), fp);
 358     fputc((int)((data >> 40) & 255), fp);
 359     fputc((int)((data >> 48) & 255), fp);
 360     fputc((int)((data >> 56) & 255), fp);
 361 }
 362
 363 void standard_extension(char *inname, char *outname, char *extension,
 364                         efunc error)
 365 {
 366     char *p, *q;
 367
 368     if (*outname)               /* file name already exists, */
 369         return;                 /* so do nothing */
 370     q = inname;
 371     p = outname;
 372     while (*q)
 373         *p++ = *q++;            /* copy, and find end of string */
 374     *p = '\0';                  /* terminate it */
 375     while (p > outname && *--p != '.') ;        /* find final period (or whatever) */
 376     if (*p != '.')
 377         while (*p)
 378             p++;                /* go back to end if none found */
 379     if (!strcmp(p, extension)) {        /* is the extension already there? */
 380         if (*extension)
 381             error(ERR_WARNING | ERR_NOFILE,
 382                   "file name already ends in `%s': "
 383                   "output will be in `nasm.out'", extension);
 384         else
 385             error(ERR_WARNING | ERR_NOFILE,
 386                   "file name already has no extension: "
 387                   "output will be in `nasm.out'");
 388         strcpy(outname, "nasm.out");
 389     } else
 390         strcpy(p, extension);
 391 }
 392
 393 #define LEAFSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_LEAF))
 394 #define BRANCHSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_BRANCH))
 395
 396 #define LAYERSIZ(r) ( (r)->layers==0 ? RAA_BLKSIZE : RAA_LAYERSIZE )
 397
 398 static struct RAA *real_raa_init(int layers)
 399 {
 400     struct RAA *r;
 401     int i;
 402
 403     if (layers == 0) {
 404         r = nasm_zalloc(LEAFSIZ);
 405         r->stepsize = 1L;
 406     } else {
 407         r = nasm_malloc(BRANCHSIZ);
 408         r->layers = layers;
 409         for (i = 0; i < RAA_LAYERSIZE; i++)
 410             r->u.b.data[i] = NULL;
 411         r->stepsize = RAA_BLKSIZE;
 412         while (--layers)
 413             r->stepsize *= RAA_LAYERSIZE;
 414     }
 415     return r;
 416 }
 417
 418 struct RAA *raa_init(void)
 419 {
 420     return real_raa_init(0);
 421 }
 422
 423 void raa_free(struct RAA *r)
 424 {
 425     if (r->layers == 0)
 426         nasm_free(r);
 427     else {
 428         struct RAA **p;
 429         for (p = r->u.b.data; p - r->u.b.data < RAA_LAYERSIZE; p++)
 430             if (*p)
 431                 raa_free(*p);
 432     }
 433 }
 434
 435 int32_t raa_read(struct RAA *r, int32_t posn)
 436 {
 437     if (posn >= r->stepsize * LAYERSIZ(r))
 438         return 0;               /* Return 0 for undefined entries */
 439     while (r->layers > 0) {
 440         ldiv_t l;
 441         l = ldiv(posn, r->stepsize);
 442         r = r->u.b.data[l.quot];
 443         posn = l.rem;
 444         if (!r)
 445             return 0;           /* Return 0 for undefined entries */
 446     }
 447     return r->u.l.data[posn];
 448 }
 449
 450 struct RAA *raa_write(struct RAA *r, int32_t posn, int32_t value)
 451 {
 452     struct RAA *result;
 453
 454     if (posn < 0)
 455         nasm_malloc_error(ERR_PANIC, "negative position in raa_write");
 456
 457     while (r->stepsize * LAYERSIZ(r) <= posn) {
 458         /*
 459          * Must add a layer.
 460          */
 461         struct RAA *s;
 462         int i;
 463
 464         s = nasm_malloc(BRANCHSIZ);
 465         for (i = 0; i < RAA_LAYERSIZE; i++)
 466             s->u.b.data[i] = NULL;
 467         s->layers = r->layers + 1;
 468         s->stepsize = LAYERSIZ(r) * r->stepsize;
 469         s->u.b.data[0] = r;
 470         r = s;
 471     }
 472
 473     result = r;
 474
 475     while (r->layers > 0) {
 476         ldiv_t l;
 477         struct RAA **s;
 478         l = ldiv(posn, r->stepsize);
 479         s = &r->u.b.data[l.quot];
 480         if (!*s)
 481             *s = real_raa_init(r->layers - 1);
 482         r = *s;
 483         posn = l.rem;
 484     }
 485
 486     r->u.l.data[posn] = value;
 487
 488     return result;
 489 }
 490
 491 /* Aggregate SAA components smaller than this */
 492 #define SAA_BLKLEN 65536
 493
 494 struct SAA *saa_init(size_t elem_len)
 495 {
 496     struct SAA *s;
 497     char *data;
 498
 499     s = nasm_zalloc(sizeof(struct SAA));
 500
 501     if (elem_len >= SAA_BLKLEN)
 502         s->blk_len = elem_len;
 503     else
 504         s->blk_len = SAA_BLKLEN - (SAA_BLKLEN % elem_len);
 505
 506     s->elem_len = elem_len;
 507     s->length = s->blk_len;
 508     data = nasm_malloc(s->blk_len);
 509     s->nblkptrs = s->nblks = 1;
 510     s->blk_ptrs = nasm_malloc(sizeof(char *));
 511     s->blk_ptrs[0] = data;
 512     s->wblk = s->rblk = &s->blk_ptrs[0];
 513
 514     return s;
 515 }
 516
 517 void saa_free(struct SAA *s)
 518 {
 519     char **p;
 520     size_t n;
 521
 522     for (p = s->blk_ptrs, n = s->nblks; n; p++, n--)
 523         nasm_free(*p);
 524
 525     nasm_free(s->blk_ptrs);
 526     nasm_free(s);
 527 }
 528
 529 /* Add one allocation block to an SAA */
 530 static void saa_extend(struct SAA *s)
 531 {
 532     size_t blkn = s->nblks++;
 533
 534     if (blkn >= s->nblkptrs) {
 535         size_t rindex = s->rblk - s->blk_ptrs;
 536         size_t windex = s->wblk - s->blk_ptrs;
 537
 538         s->nblkptrs <<= 1;
 539         s->blk_ptrs = nasm_realloc(s->blk_ptrs, s->nblkptrs*sizeof(char *));
 540
 541         s->rblk = s->blk_ptrs + rindex;
 542         s->wblk = s->blk_ptrs + windex;
 543     }
 544
 545     s->blk_ptrs[blkn] = nasm_malloc(s->blk_len);
 546     s->length += s->blk_len;
 547 }
 548
 549 void *saa_wstruct(struct SAA *s)
 550 {
 551     void *p;
 552
 553     if (s->wpos % s->elem_len)
 554             nasm_malloc_error(ERR_PANIC|ERR_NOFILE,
 555                               "misaligned wpos in saa_wstruct");
 556
 557     if (s->wpos + s->elem_len > s->blk_len) {
 558         if (s->wpos != s->blk_len)
 559             nasm_malloc_error(ERR_PANIC|ERR_NOFILE,
 560                               "unfilled block in saa_wstruct");
 561
 562         if (s->wptr + s->elem_len > s->length)
 563             saa_extend(s);
 564         s->wblk++;
 565         s->wpos = 0;
 566     }
 567
 568     p = *s->wblk + s->wpos;
 569     s->wpos += s->elem_len;
 570     s->wptr += s->elem_len;
 571
 572     if (s->wptr > s->datalen)
 573         s->datalen = s->wptr;
 574
 575     return p;
 576 }
 577
 578 void saa_wbytes(struct SAA *s, const void *data, size_t len)
 579 {
 580     const char *d = data;
 581
 582     while (len) {
 583         size_t l = s->blk_len - s->wpos;
 584         if (l > len)
 585             l = len;
 586         if (l) {
 587             if (d) {
 588                 memcpy(*s->wblk + s->wpos, d, l);
 589                 d += l;
 590             } else
 591                 memset(*s->wblk + s->wpos, 0, l);
 592             s->wpos += l;
 593             s->wptr += l;
 594             len -= l;
 595
 596             if (s->datalen < s->wptr)
 597                 s->datalen = s->wptr;
 598         }
 599         if (len) {
 600             if (s->wptr >= s->length)
 601                 saa_extend(s);
 602             s->wblk++;
 603             s->wpos = 0;
 604         }
 605     }
 606 }
 607
 608 void saa_rewind(struct SAA *s)
 609 {
 610     s->rblk = s->blk_ptrs;
 611     s->rpos = s->rptr = 0;
 612 }
 613
 614 void *saa_rstruct(struct SAA *s)
 615 {
 616     void *p;
 617
 618     if (s->rptr + s->elem_len > s->datalen)
 619         return NULL;
 620
 621     if (s->rpos % s->elem_len)
 622             nasm_malloc_error(ERR_PANIC|ERR_NOFILE,
 623                               "misaligned rpos in saa_rstruct");
 624
 625     if (s->rpos + s->elem_len > s->blk_len) {
 626         s->rblk++;
 627         s->rpos = 0;
 628     }
 629
 630     p = *s->rblk + s->rpos;
 631     s->rpos += s->elem_len;
 632     s->rptr += s->elem_len;
 633
 634     return p;
 635 }
 636
 637 const void *saa_rbytes(struct SAA *s, size_t *lenp)
 638 {
 639     const void *p;
 640     size_t len;
 641
 642     if (s->rptr >= s->datalen) {
 643         *lenp = 0;
 644         return NULL;
 645     }
 646
 647     if (s->rpos >= s->blk_len) {
 648         s->rblk++;
 649         s->rpos = 0;
 650     }
 651
 652     len = *lenp;
 653     if (len > s->datalen - s->rptr)
 654         len = s->datalen - s->rptr;
 655     if (len > s->blk_len - s->rpos)
 656         len = s->blk_len - s->rpos;
 657
 658     *lenp = len;
 659     p = *s->rblk + s->rpos;
 660
 661     s->rpos += len;
 662     s->rptr += len;
 663
 664     return p;
 665 }
 666
 667 void saa_rnbytes(struct SAA *s, void *data, size_t len)
 668 {
 669     char *d = data;
 670
 671     if (s->rptr + len > s->datalen) {
 672         nasm_malloc_error(ERR_PANIC|ERR_NOFILE, "overrun in saa_rnbytes");
 673         return;
 674     }
 675
 676     while (len) {
 677         size_t l;
 678         const void *p;
 679
 680         l = len;
 681         p = saa_rbytes(s, &l);
 682
 683         memcpy(d, p, l);
 684         d   += l;
 685         len -= l;
 686     }
 687 }
 688
 689 /* Same as saa_rnbytes, except position the counter first */
 690 void saa_fread(struct SAA *s, size_t posn, void *data, size_t len)
 691 {
 692     size_t ix;
 693
 694     if (posn+len > s->datalen) {
 695         nasm_malloc_error(ERR_PANIC|ERR_NOFILE, "overrun in saa_fread");
 696         return;
 697     }
 698
 699     ix = posn / s->blk_len;
 700     s->rptr = posn;
 701     s->rpos = posn % s->blk_len;
 702     s->rblk = &s->blk_ptrs[ix];
 703
 704     saa_rnbytes(s, data, len);
 705 }
 706
 707 /* Same as saa_wbytes, except position the counter first */
 708 void saa_fwrite(struct SAA *s, size_t posn, const void *data, size_t len)
 709 {
 710     size_t ix;
 711
 712     if (posn > s->datalen) {
 713         /* Seek beyond the end of the existing array not supported */
 714         nasm_malloc_error(ERR_PANIC|ERR_NOFILE, "overrun in saa_fwrite");
 715         return;
 716     }
 717
 718     ix = posn / s->blk_len;
 719     s->wptr = posn;
 720     s->wpos = posn % s->blk_len;
 721     s->wblk = &s->blk_ptrs[ix];
 722
 723     if (!s->wpos) {
 724         s->wpos = s->blk_len;
 725         s->wblk--;
 726     }
 727
 728     saa_wbytes(s, data, len);
 729 }
 730
 731 void saa_fpwrite(struct SAA *s, FILE * fp)
 732 {
 733     const char *data;
 734     size_t len;
 735
 736     saa_rewind(s);
 737     while (len = s->datalen, (data = saa_rbytes(s, &len)) != NULL)
 738         fwrite(data, 1, len, fp);
 739 }
 740
 741 /*
 742  * Common list of prefix names
 743  */
 744 static const char *prefix_names[] = {
 745     "a16", "a32", "lock", "o16", "o32", "rep", "repe", "repne",
 746     "repnz", "repz", "times"
 747 };
 748
 749 const char *prefix_name(int token)
 750 {
 751     unsigned int prefix = token-PREFIX_ENUM_START;
 752     if (prefix > sizeof prefix_names / sizeof(const char *))
 753         return NULL;
 754
 755     return prefix_names[prefix];
 756 }
 757
 758 /*
 759  * Binary search.
 760  */
 761 int bsi(char *string, const char **array, int size)
 762 {
 763     int i = -1, j = size;       /* always, i < index < j */
 764     while (j - i >= 2) {
 765         int k = (i + j) / 2;
 766         int l = strcmp(string, array[k]);
 767         if (l < 0)              /* it's in the first half */
 768             j = k;
 769         else if (l > 0)         /* it's in the second half */
 770             i = k;
 771         else                    /* we've got it :) */
 772             return k;
 773     }
 774     return -1;                  /* we haven't got it :( */
 775 }
 776
 777 int bsii(char *string, const char **array, int size)
 778 {
 779     int i = -1, j = size;       /* always, i < index < j */
 780     while (j - i >= 2) {
 781         int k = (i + j) / 2;
 782         int l = nasm_stricmp(string, array[k]);
 783         if (l < 0)              /* it's in the first half */
 784             j = k;
 785         else if (l > 0)         /* it's in the second half */
 786             i = k;
 787         else                    /* we've got it :) */
 788             return k;
 789     }
 790     return -1;                  /* we haven't got it :( */
 791 }
 792
 793 static char *file_name = NULL;
 794 static int32_t line_number = 0;
 795
 796 char *src_set_fname(char *newname)
 797 {
 798     char *oldname = file_name;
 799     file_name = newname;
 800     return oldname;
 801 }
 802
 803 int32_t src_set_linnum(int32_t newline)
 804 {
 805     int32_t oldline = line_number;
 806     line_number = newline;
 807     return oldline;
 808 }
 809
 810 int32_t src_get_linnum(void)
 811 {
 812     return line_number;
 813 }
 814
 815 int src_get(int32_t *xline, char **xname)
 816 {
 817     if (!file_name || !*xname || strcmp(*xname, file_name)) {
 818         nasm_free(*xname);
 819         *xname = file_name ? nasm_strdup(file_name) : NULL;
 820         *xline = line_number;
 821         return -2;
 822     }
 823     if (*xline != line_number) {
 824         int32_t tmp = line_number - *xline;
 825         *xline = line_number;
 826         return tmp;
 827     }
 828     return 0;
 829 }
 830
 831 void nasm_quote(char **str)
 832 {
 833     int ln = strlen(*str);
 834     char q = (*str)[0];
 835     char *p;
 836     if (ln > 1 && (*str)[ln - 1] == q && (q == '"' || q == '\''))
 837         return;
 838     q = '"';
 839     if (strchr(*str, q))
 840         q = '\'';
 841     p = nasm_malloc(ln + 3);
 842     strcpy(p + 1, *str);
 843     nasm_free(*str);
 844     p[ln + 1] = p[0] = q;
 845     p[ln + 2] = 0;
 846     *str = p;
 847 }
 848
 849 char *nasm_strcat(char *one, char *two)
 850 {
 851     char *rslt;
 852     int l1 = strlen(one);
 853     rslt = nasm_malloc(l1 + strlen(two) + 1);
 854     strcpy(rslt, one);
 855     strcpy(rslt + l1, two);
 856     return rslt;
 857 }
 858
 859 void null_debug_init(struct ofmt *of, void *id, FILE * fp, efunc error)
 860 {
 861         (void)of;
 862         (void)id;
 863         (void)fp;
 864         (void)error;
 865 }
 866 void null_debug_linenum(const char *filename, int32_t linenumber, int32_t segto)
 867 {
 868         (void)filename;
 869         (void)linenumber;
 870         (void)segto;
 871 }
 872 void null_debug_deflabel(char *name, int32_t segment, int32_t offset,
 873                          int is_global, char *special)
 874 {
 875         (void)name;
 876         (void)segment;
 877         (void)offset;
 878         (void)is_global;
 879         (void)special;
 880 }
 881 void null_debug_routine(const char *directive, const char *params)
 882 {
 883         (void)directive;
 884         (void)params;
 885 }
 886 void null_debug_typevalue(int32_t type)
 887 {
 888         (void)type;
 889 }
 890 void null_debug_output(int type, void *param)
 891 {
 892         (void)type;
 893         (void)param;
 894 }
 895 void null_debug_cleanup(void)
 896 {
 897 }
 898
 899 struct dfmt null_debug_form = {
 900     "Null debug format",
 901     "null",
 902     null_debug_init,
 903     null_debug_linenum,
 904     null_debug_deflabel,
 905     null_debug_routine,
 906     null_debug_typevalue,
 907     null_debug_output,
 908     null_debug_cleanup
 909 };
 910
 911 struct dfmt *null_debug_arr[2] = { &null_debug_form, NULL };