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