nasmlib.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2010 The NASM Authors - All Rights Reserved
   4  *   See the file AUTHORS included with the NASM distribution for
   5  *   the specific copyright holders.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following
   9  *   conditions are met:
  10  *
  11  *   * Redistributions of source code must retain the above copyright
  12  *     notice, this list of conditions and the following disclaimer.
  13  *   * Redistributions in binary form must reproduce the above
  14  *     copyright notice, this list of conditions and the following
  15  *     disclaimer in the documentation and/or other materials provided
  16  *     with the distribution.
  17  *
  18  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  19  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  23  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * ----------------------------------------------------------------------- */
  33
  34 /*
  35  * nasmlib.c    library routines for the Netwide Assembler
  36  */
  37
  38 #include "compiler.h"
  39
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <ctype.h>
  44 #include <inttypes.h>
  45
  46 #include "nasm.h"
  47 #include "nasmlib.h"
  48 #include "insns.h"
  49
  50 int globalbits = 0;    /* defined in nasm.h, works better here for ASM+DISASM */
  51 static vefunc nasm_verror;      /* Global error handling function */
  52
  53 #ifdef LOGALLOC
  54 static FILE *logfp;
  55 #endif
  56
  57 /* Uninitialized -> all zero by C spec */
  58 const uint8_t zero_buffer[ZERO_BUF_SIZE];
  59
  60 /*
  61  * Prepare a table of tolower() results.  This avoids function calls
  62  * on some platforms.
  63  */
  64
  65 unsigned char nasm_tolower_tab[256];
  66
  67 void tolower_init(void)
  68 {
  69     int i;
  70
  71     for (i = 0; i < 256; i++)
  72         nasm_tolower_tab[i] = tolower(i);
  73 }
  74
  75 void nasm_set_verror(vefunc ve)
  76 {
  77     nasm_verror = ve;
  78 }
  79
  80 void nasm_error(int severity, const char *fmt, ...)
  81 {
  82     va_list ap;
  83
  84     va_start(ap, fmt);
  85     nasm_verror(severity, fmt, ap);
  86     va_end(ap);
  87 }
  88
  89 void nasm_init_malloc_error(void)
  90 {
  91 #ifdef LOGALLOC
  92     logfp = fopen("malloc.log", "w");
  93     if (logfp) {
  94         setvbuf(logfp, NULL, _IOLBF, BUFSIZ);
  95     } else {
  96         nasm_error(ERR_NONFATAL | ERR_NOFILE, "Unable to open %s", logfp);
  97         logfp = stderr;
  98     }
  99     fprintf(logfp, "null pointer is %p\n", NULL);
 100 #endif
 101 }
 102
 103 #ifdef LOGALLOC
 104 void *nasm_malloc_log(const char *file, int line, size_t size)
 105 #else
 106 void *nasm_malloc(size_t size)
 107 #endif
 108 {
 109     void *p = malloc(size);
 110     if (!p)
 111         nasm_error(ERR_FATAL | ERR_NOFILE, "out of memory");
 112 #ifdef LOGALLOC
 113     else
 114         fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
 115                 file, line, (long)size, p);
 116 #endif
 117     return p;
 118 }
 119
 120 #ifdef LOGALLOC
 121 void *nasm_zalloc_log(const char *file, int line, size_t size)
 122 #else
 123 void *nasm_zalloc(size_t size)
 124 #endif
 125 {
 126     void *p = calloc(size, 1);
 127     if (!p)
 128         nasm_error(ERR_FATAL | ERR_NOFILE, "out of memory");
 129 #ifdef LOGALLOC
 130     else
 131         fprintf(logfp, "%s %d calloc(%ld, 1) returns %p\n",
 132                 file, line, (long)size, p);
 133 #endif
 134     return p;
 135 }
 136
 137 #ifdef LOGALLOC
 138 void *nasm_realloc_log(const char *file, int line, void *q, size_t size)
 139 #else
 140 void *nasm_realloc(void *q, size_t size)
 141 #endif
 142 {
 143     void *p = q ? realloc(q, size) : malloc(size);
 144     if (!p)
 145         nasm_error(ERR_FATAL | ERR_NOFILE, "out of memory");
 146 #ifdef LOGALLOC
 147     else if (q)
 148         fprintf(logfp, "%s %d realloc(%p,%ld) returns %p\n",
 149                 file, line, q, (long)size, p);
 150     else
 151         fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
 152                 file, line, (long)size, p);
 153 #endif
 154     return p;
 155 }
 156
 157 #ifdef LOGALLOC
 158 void nasm_free_log(const char *file, int line, void *q)
 159 #else
 160 void nasm_free(void *q)
 161 #endif
 162 {
 163     if (q) {
 164 #ifdef LOGALLOC
 165         fprintf(logfp, "%s %d free(%p)\n", file, line, q);
 166 #endif
 167         free(q);
 168     }
 169 }
 170
 171 #ifdef LOGALLOC
 172 char *nasm_strdup_log(const char *file, int line, const char *s)
 173 #else
 174 char *nasm_strdup(const char *s)
 175 #endif
 176 {
 177     char *p;
 178     int size = strlen(s) + 1;
 179
 180     p = malloc(size);
 181     if (!p)
 182         nasm_error(ERR_FATAL | ERR_NOFILE, "out of memory");
 183 #ifdef LOGALLOC
 184     else
 185         fprintf(logfp, "%s %d strdup(%ld) returns %p\n",
 186                 file, line, (long)size, p);
 187 #endif
 188     strcpy(p, s);
 189     return p;
 190 }
 191
 192 #ifdef LOGALLOC
 193 char *nasm_strndup_log(const char *file, int line, const char *s, size_t len)
 194 #else
 195 char *nasm_strndup(const char *s, size_t len)
 196 #endif
 197 {
 198     char *p;
 199     int size = len + 1;
 200
 201     p = malloc(size);
 202     if (!p)
 203         nasm_error(ERR_FATAL | ERR_NOFILE, "out of memory");
 204 #ifdef LOGALLOC
 205     else
 206         fprintf(logfp, "%s %d strndup(%ld) returns %p\n",
 207                 file, line, (long)size, p);
 208 #endif
 209     strncpy(p, s, len);
 210     p[len] = '\0';
 211     return p;
 212 }
 213
 214 no_return nasm_assert_failed(const char *file, int line, const char *msg)
 215 {
 216     nasm_error(ERR_FATAL, "assertion %s failed at %s:%d", msg, file, line);
 217     exit(1);
 218 }
 219
 220 #ifndef nasm_stricmp
 221 int nasm_stricmp(const char *s1, const char *s2)
 222 {
 223     unsigned char c1, c2;
 224     int d;
 225
 226     while (1) {
 227         c1 = nasm_tolower(*s1++);
 228         c2 = nasm_tolower(*s2++);
 229         d = c1-c2;
 230
 231         if (d)
 232             return d;
 233         if (!c1)
 234             break;
 235     }
 236     return 0;
 237 }
 238 #endif
 239
 240 #ifndef nasm_strnicmp
 241 int nasm_strnicmp(const char *s1, const char *s2, size_t n)
 242 {
 243     unsigned char c1, c2;
 244     int d;
 245
 246     while (n--) {
 247         c1 = nasm_tolower(*s1++);
 248         c2 = nasm_tolower(*s2++);
 249         d = c1-c2;
 250
 251         if (d)
 252             return d;
 253         if (!c1)
 254             break;
 255     }
 256     return 0;
 257 }
 258 #endif
 259
 260 int nasm_memicmp(const char *s1, const char *s2, size_t n)
 261 {
 262     unsigned char c1, c2;
 263     int d;
 264
 265     while (n--) {
 266         c1 = nasm_tolower(*s1++);
 267         c2 = nasm_tolower(*s2++);
 268         d = c1-c2;
 269         if (d)
 270             return d;
 271     }
 272     return 0;
 273 }
 274
 275 #ifndef nasm_strsep
 276 char *nasm_strsep(char **stringp, const char *delim)
 277 {
 278         char *s = *stringp;
 279         char *e;
 280
 281         if (!s)
 282                 return NULL;
 283
 284         e = strpbrk(s, delim);
 285         if (e)
 286                 *e++ = '\0';
 287
 288         *stringp = e;
 289         return s;
 290 }
 291 #endif
 292
 293 char *nasm_strrep(const char *str, const char *sub, char *lin, bool casesense)
 294 {
 295     char *outline = lin;
 296     char *temp1 = NULL;
 297     char *temp2 = NULL;
 298     char *l, *ll, *lp, *lt, *ls;
 299     int count = 0;
 300     int str_len, sub_len, lin_len;
 301     int i, c;
 302
 303     str_len = strlen(str);
 304     sub_len = strlen(sub);
 305     lin_len = strlen(lin);
 306
 307     if ((str_len > 0) && (lin_len > 0)) {
 308         if (casesense == false) {
 309             l = nasm_strdup(lin);
 310             for (i = 0; i < lin_len; i++) {
 311                 l[i] = (char)nasm_tolower_tab[(int)l[i]];
 312             }
 313             ls = nasm_strdup(str);
 314             for (i = 0; i < str_len; i++) {
 315                 ls[i] = (char)nasm_tolower_tab[(int)ls[i]];
 316             }
 317             temp1 = l;
 318             temp2 = ls;
 319         } else {
 320             l = lin;
 321             ls = (char *)str;
 322         }
 323
 324         ll = l;
 325
 326         do {
 327             l = strstr(l, ls);
 328             if (l != NULL) {
 329                 count ++;
 330                 l += str_len;
 331             }
 332         } while (l != NULL);
 333
 334         if (count > 0) {
 335             i = (lin_len - (count * str_len));
 336             i += (count * sub_len);
 337             outline = nasm_zalloc(i);
 338
 339             l = ll;
 340             lt = lin;
 341
 342             for (i = 0; i < count; i++) {
 343                 lp = l;
 344                 l = strstr(l, ls);
 345                 c = (l - lp);
 346                 if (c > 0) {
 347                     strncat(outline, lt, c);
 348                     lt += c;
 349                 }
 350                 strncat(outline, sub, sub_len);
 351                 l += str_len;
 352                 lt += str_len;
 353             }
 354
 355             c = (l - ll);
 356             if (c < lin_len) {
 357                 strncat(outline, lt, (lin_len-c));
 358             }
 359
 360             if (temp2 != NULL) {
 361                 nasm_free(temp2);
 362             }
 363
 364             if (temp1 != NULL) {
 365                 nasm_free(temp1);
 366             }
 367
 368             nasm_free(lin);
 369         }
 370     }
 371
 372     return outline;
 373 }
 374
 375
 376 #define lib_isnumchar(c)   (nasm_isalnum(c) || (c) == '$' || (c) == '_')
 377 #define numvalue(c)  ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
 378
 379 static int radix_letter(char c)
 380 {
 381     switch (c) {
 382     case 'b': case 'B':
 383     case 'y': case 'Y':
 384         return 2;               /* Binary */
 385     case 'o': case 'O':
 386     case 'q': case 'Q':
 387         return 8;               /* Octal */
 388     case 'h': case 'H':
 389     case 'x': case 'X':
 390         return 16;              /* Hexadecimal */
 391     case 'd': case 'D':
 392     case 't': case 'T':
 393         return 10;              /* Decimal */
 394     default:
 395         return 0;               /* Not a known radix letter */
 396     }
 397 }
 398
 399 int64_t readnum(char *str, bool *error)
 400 {
 401     char *r = str, *q;
 402     int32_t pradix, sradix, radix;
 403     int plen, slen, len;
 404     uint64_t result, checklimit;
 405     int digit, last;
 406     bool warn = false;
 407     int sign = 1;
 408
 409     *error = false;
 410
 411     while (nasm_isspace(*r))
 412         r++;                    /* find start of number */
 413
 414     /*
 415      * If the number came from make_tok_num (as a result of an %assign), it
 416      * might have a '-' built into it (rather than in a preceeding token).
 417      */
 418     if (*r == '-') {
 419         r++;
 420         sign = -1;
 421     }
 422
 423     q = r;
 424
 425     while (lib_isnumchar(*q))
 426         q++;                    /* find end of number */
 427
 428     len = q-r;
 429     if (!len) {
 430         /* Not numeric */
 431         *error = true;
 432         return 0;
 433     }
 434
 435     /*
 436      * Handle radix formats:
 437      *
 438      * 0<radix-letter><string>
 439      * $<string>                (hexadecimal)
 440      * <string><radix-letter>
 441      */
 442     pradix = sradix = 0;
 443     plen = slen = 0;
 444
 445     if (len > 2 && *r == '0' && (pradix = radix_letter(r[1])) != 0)
 446         plen = 2;
 447     else if (len > 1 && *r == '$')
 448         pradix = 16, plen = 1;
 449
 450     if (len > 1 && (sradix = radix_letter(q[-1])) != 0)
 451         slen = 1;
 452
 453     if (pradix > sradix) {
 454         radix = pradix;
 455         r += plen;
 456     } else if (sradix > pradix) {
 457         radix = sradix;
 458         q -= slen;
 459     } else {
 460         /* Either decimal, or invalid -- if invalid, we'll trip up
 461            further down. */
 462         radix = 10;
 463     }
 464
 465     /*
 466      * `checklimit' must be 2**64 / radix. We can't do that in
 467      * 64-bit arithmetic, which we're (probably) using, so we
 468      * cheat: since we know that all radices we use are even, we
 469      * can divide 2**63 by radix/2 instead.
 470      */
 471     checklimit = UINT64_C(0x8000000000000000) / (radix >> 1);
 472
 473     /*
 474      * Calculate the highest allowable value for the last digit of a
 475      * 64-bit constant... in radix 10, it is 6, otherwise it is 0
 476      */
 477     last = (radix == 10 ? 6 : 0);
 478
 479     result = 0;
 480     while (*r && r < q) {
 481         if (*r != '_') {
 482             if (*r < '0' || (*r > '9' && *r < 'A')
 483                 || (digit = numvalue(*r)) >= radix) {
 484                 *error = true;
 485                 return 0;
 486             }
 487             if (result > checklimit ||
 488                 (result == checklimit && digit >= last)) {
 489                 warn = true;
 490             }
 491
 492             result = radix * result + digit;
 493         }
 494         r++;
 495     }
 496
 497     if (warn)
 498         nasm_error(ERR_WARNING | ERR_PASS1 | ERR_WARN_NOV,
 499                    "numeric constant %s does not fit in 64 bits",
 500                    str);
 501
 502     return result * sign;
 503 }
 504
 505 int64_t readstrnum(char *str, int length, bool *warn)
 506 {
 507     int64_t charconst = 0;
 508     int i;
 509
 510     *warn = false;
 511
 512     str += length;
 513     if (globalbits == 64) {
 514         for (i = 0; i < length; i++) {
 515             if (charconst & UINT64_C(0xFF00000000000000))
 516                 *warn = true;
 517             charconst = (charconst << 8) + (uint8_t)*--str;
 518         }
 519     } else {
 520         for (i = 0; i < length; i++) {
 521             if (charconst & 0xFF000000UL)
 522                 *warn = true;
 523             charconst = (charconst << 8) + (uint8_t)*--str;
 524         }
 525     }
 526     return charconst;
 527 }
 528
 529 static int32_t next_seg;
 530
 531 void seg_init(void)
 532 {
 533     next_seg = 0;
 534 }
 535
 536 int32_t seg_alloc(void)
 537 {
 538     return (next_seg += 2) - 2;
 539 }
 540
 541 #ifdef WORDS_LITTLEENDIAN
 542
 543 void fwriteint16_t(uint16_t data, FILE * fp)
 544 {
 545     fwrite(&data, 1, 2, fp);
 546 }
 547
 548 void fwriteint32_t(uint32_t data, FILE * fp)
 549 {
 550     fwrite(&data, 1, 4, fp);
 551 }
 552
 553 void fwriteint64_t(uint64_t data, FILE * fp)
 554 {
 555     fwrite(&data, 1, 8, fp);
 556 }
 557
 558 void fwriteaddr(uint64_t data, int size, FILE * fp)
 559 {
 560     fwrite(&data, 1, size, fp);
 561 }
 562
 563 #else /* not WORDS_LITTLEENDIAN */
 564
 565 void fwriteint16_t(uint16_t data, FILE * fp)
 566 {
 567     char buffer[2], *p = buffer;
 568     WRITESHORT(p, data);
 569     fwrite(buffer, 1, 2, fp);
 570 }
 571
 572 void fwriteint32_t(uint32_t data, FILE * fp)
 573 {
 574     char buffer[4], *p = buffer;
 575     WRITELONG(p, data);
 576     fwrite(buffer, 1, 4, fp);
 577 }
 578
 579 void fwriteint64_t(uint64_t data, FILE * fp)
 580 {
 581     char buffer[8], *p = buffer;
 582     WRITEDLONG(p, data);
 583     fwrite(buffer, 1, 8, fp);
 584 }
 585
 586 void fwriteaddr(uint64_t data, int size, FILE * fp)
 587 {
 588     char buffer[8], *p = buffer;
 589     WRITEADDR(p, data, size);
 590     fwrite(buffer, 1, size, fp);
 591 }
 592
 593 #endif
 594
 595 size_t fwritezero(size_t bytes, FILE *fp)
 596 {
 597     size_t count = 0;
 598     size_t blksize;
 599     size_t rv;
 600
 601     while (bytes) {
 602         blksize = (bytes < ZERO_BUF_SIZE) ? bytes : ZERO_BUF_SIZE;
 603
 604         rv = fwrite(zero_buffer, 1, blksize, fp);
 605         if (!rv)
 606             break;
 607
 608         count += rv;
 609         bytes -= rv;
 610     }
 611
 612     return count;
 613 }
 614
 615 void standard_extension(char *inname, char *outname, char *extension)
 616 {
 617     char *p, *q;
 618
 619     if (*outname)               /* file name already exists, */
 620         return;                 /* so do nothing */
 621     q = inname;
 622     p = outname;
 623     while (*q)
 624         *p++ = *q++;            /* copy, and find end of string */
 625     *p = '\0';                  /* terminate it */
 626     while (p > outname && *--p != '.') ;        /* find final period (or whatever) */
 627     if (*p != '.')
 628         while (*p)
 629             p++;                /* go back to end if none found */
 630     if (!strcmp(p, extension)) {        /* is the extension already there? */
 631         if (*extension)
 632             nasm_error(ERR_WARNING | ERR_NOFILE,
 633                        "file name already ends in `%s': "
 634                        "output will be in `nasm.out'", extension);
 635         else
 636             nasm_error(ERR_WARNING | ERR_NOFILE,
 637                        "file name already has no extension: "
 638                        "output will be in `nasm.out'");
 639         strcpy(outname, "nasm.out");
 640     } else
 641         strcpy(p, extension);
 642 }
 643
 644 /*
 645  * Common list of prefix names
 646  */
 647 static const char *prefix_names[] = {
 648     "a16", "a32", "a64", "asp", "lock", "o16", "o32", "o64", "osp",
 649     "rep", "repe", "repne", "repnz", "repz", "times", "wait"
 650 };
 651
 652 const char *prefix_name(int token)
 653 {
 654     unsigned int prefix = token-PREFIX_ENUM_START;
 655     if (prefix >= ARRAY_SIZE(prefix_names))
 656         return NULL;
 657
 658     return prefix_names[prefix];
 659 }
 660
 661 /*
 662  * Binary search.
 663  */
 664 int bsi(const char *string, const char **array, int size)
 665 {
 666     int i = -1, j = size;       /* always, i < index < j */
 667     while (j - i >= 2) {
 668         int k = (i + j) / 2;
 669         int l = strcmp(string, array[k]);
 670         if (l < 0)              /* it's in the first half */
 671             j = k;
 672         else if (l > 0)         /* it's in the second half */
 673             i = k;
 674         else                    /* we've got it :) */
 675             return k;
 676     }
 677     return -1;                  /* we haven't got it :( */
 678 }
 679
 680 int bsii(const char *string, const char **array, int size)
 681 {
 682     int i = -1, j = size;       /* always, i < index < j */
 683     while (j - i >= 2) {
 684         int k = (i + j) / 2;
 685         int l = nasm_stricmp(string, array[k]);
 686         if (l < 0)              /* it's in the first half */
 687             j = k;
 688         else if (l > 0)         /* it's in the second half */
 689             i = k;
 690         else                    /* we've got it :) */
 691             return k;
 692     }
 693     return -1;                  /* we haven't got it :( */
 694 }
 695
 696 static char *file_name = NULL;
 697 static int32_t line_number = 0;
 698
 699 char *src_set_fname(char *newname)
 700 {
 701     char *oldname = file_name;
 702     file_name = newname;
 703     return oldname;
 704 }
 705
 706 int32_t src_set_linnum(int32_t newline)
 707 {
 708     int32_t oldline = line_number;
 709     line_number = newline;
 710     return oldline;
 711 }
 712
 713 int32_t src_get_linnum(void)
 714 {
 715     return line_number;
 716 }
 717
 718 int src_get(int32_t *xline, char **xname)
 719 {
 720     if (!file_name || !*xname || strcmp(*xname, file_name)) {
 721         nasm_free(*xname);
 722         *xname = file_name ? nasm_strdup(file_name) : NULL;
 723         *xline = line_number;
 724         return -2;
 725     }
 726     if (*xline != line_number) {
 727         int32_t tmp = line_number - *xline;
 728         *xline = line_number;
 729         return tmp;
 730     }
 731     return 0;
 732 }
 733
 734 char *nasm_strcat(const char *one, const char *two)
 735 {
 736     char *rslt;
 737     int l1 = strlen(one);
 738     rslt = nasm_malloc(l1 + strlen(two) + 1);
 739     strcpy(rslt, one);
 740     strcpy(rslt + l1, two);
 741     return rslt;
 742 }
 743
 744 /* skip leading spaces */
 745 char *nasm_skip_spaces(const char *p)
 746 {
 747     if (p)
 748         while (*p && nasm_isspace(*p))
 749             p++;
 750     return (char *)p;
 751 }
 752
 753 /* skip leading non-spaces */
 754 char *nasm_skip_word(const char *p)
 755 {
 756     if (p)
 757         while (*p && !nasm_isspace(*p))
 758             p++;
 759     return (char *)p;
 760 }
 761
 762 /* zap leading spaces with zero */
 763 char *nasm_zap_spaces_fwd(char *p)
 764 {
 765     if (p)
 766         while (*p && nasm_isspace(*p))
 767             *p++ = 0x0;
 768     return p;
 769 }
 770
 771 /* zap spaces with zero in reverse order */
 772 char *nasm_zap_spaces_rev(char *p)
 773 {
 774     if (p)
 775         while (*p && nasm_isspace(*p))
 776             *p-- = 0x0;
 777     return p;
 778 }
 779
 780 /* zap leading and trailing spaces */
 781 char *nasm_trim_spaces(char *p)
 782 {
 783     p = nasm_zap_spaces_fwd(p);
 784     nasm_zap_spaces_fwd(nasm_skip_word(p));
 785
 786     return p;
 787 }
 788
 789 /*
 790  * return the word extracted from a stream
 791  * or NULL if nothing left
 792  */
 793 char *nasm_get_word(char *p, char **tail)
 794 {
 795     char *word = nasm_skip_spaces(p);
 796     char *next = nasm_skip_word(word);
 797
 798     if (word && *word) {
 799         if (*next)
 800             *next++ = '\0';
 801     } else
 802         word = next = NULL;
 803
 804     /* NOTE: the tail may start with spaces */
 805     *tail = next;
 806
 807     return word;
 808 }
 809
 810 /*
 811  * Extract "opt=val" values from the stream and
 812  * returns "opt"
 813  *
 814  * Exceptions:
 815  * 1) If "=val" passed the NULL returned though
 816  *    you may continue handling the tail via "next"
 817  * 2) If "=" passed the NULL is returned and "val"
 818  *    is set to NULL as well
 819  */
 820 char *nasm_opt_val(char *p, char **val, char **next)
 821 {
 822     char *q, *opt, *nxt;
 823
 824     opt = *val = *next = NULL;
 825
 826     p = nasm_get_word(p, &nxt);
 827     if (!p)
 828         return NULL;
 829
 830     q = strchr(p, '=');
 831     if (q) {
 832         if (q == p)
 833             p = NULL;
 834         *q++='\0';
 835         if (*q) {
 836             *val = q;
 837         } else {
 838             q = nasm_get_word(q + 1, &nxt);
 839             if (q)
 840                 *val = q;
 841         }
 842     } else {
 843         q = nasm_skip_spaces(nxt);
 844         if (q && *q == '=') {
 845             q = nasm_get_word(q + 1, &nxt);
 846             if (q)
 847                 *val = q;
 848         }
 849     }
 850
 851     *next = nxt;
 852     return p;
 853 }
 854
 855 /*
 856  * initialized data bytes length from opcode
 857  */
 858 int idata_bytes(int opcode)
 859 {
 860     int ret;
 861     switch (opcode) {
 862     case I_DB:
 863         ret = 1;
 864         break;
 865     case I_DW:
 866         ret = 2;
 867         break;
 868     case I_DD:
 869         ret = 4;
 870         break;
 871     case I_DQ:
 872         ret = 8;
 873         break;
 874     case I_DT:
 875         ret = 10;
 876         break;
 877     case I_DO:
 878         ret = 16;
 879         break;
 880     case I_DY:
 881         ret = 32;
 882         break;
 883     case I_none:
 884         ret = -1;
 885         break;
 886     default:
 887         ret = 0;
 888         break;
 889     }
 890     return ret;
 891 }