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
 294 #define lib_isnumchar(c)   (nasm_isalnum(c) || (c) == '$' || (c) == '_')
 295 #define numvalue(c)  ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
 296
 297 static int radix_letter(char c)
 298 {
 299     switch (c) {
 300     case 'b': case 'B':
 301     case 'y': case 'Y':
 302         return 2;               /* Binary */
 303     case 'o': case 'O':
 304     case 'q': case 'Q':
 305         return 8;               /* Octal */
 306     case 'h': case 'H':
 307     case 'x': case 'X':
 308         return 16;              /* Hexadecimal */
 309     case 'd': case 'D':
 310     case 't': case 'T':
 311         return 10;              /* Decimal */
 312     default:
 313         return 0;               /* Not a known radix letter */
 314     }
 315 }
 316
 317 int64_t readnum(char *str, bool *error)
 318 {
 319     char *r = str, *q;
 320     int32_t pradix, sradix, radix;
 321     int plen, slen, len;
 322     uint64_t result, checklimit;
 323     int digit, last;
 324     bool warn = false;
 325     int sign = 1;
 326
 327     *error = false;
 328
 329     while (nasm_isspace(*r))
 330         r++;                    /* find start of number */
 331
 332     /*
 333      * If the number came from make_tok_num (as a result of an %assign), it
 334      * might have a '-' built into it (rather than in a preceeding token).
 335      */
 336     if (*r == '-') {
 337         r++;
 338         sign = -1;
 339     }
 340
 341     q = r;
 342
 343     while (lib_isnumchar(*q))
 344         q++;                    /* find end of number */
 345
 346     len = q-r;
 347     if (!len) {
 348         /* Not numeric */
 349         *error = true;
 350         return 0;
 351     }
 352
 353     /*
 354      * Handle radix formats:
 355      *
 356      * 0<radix-letter><string>
 357      * $<string>                (hexadecimal)
 358      * <string><radix-letter>
 359      */
 360     pradix = sradix = 0;
 361     plen = slen = 0;
 362
 363     if (len > 2 && *r == '0' && (pradix = radix_letter(r[1])) != 0)
 364         plen = 2;
 365     else if (len > 1 && *r == '$')
 366         pradix = 16, plen = 1;
 367
 368     if (len > 1 && (sradix = radix_letter(q[-1])) != 0)
 369         slen = 1;
 370
 371     if (pradix > sradix) {
 372         radix = pradix;
 373         r += plen;
 374     } else if (sradix > pradix) {
 375         radix = sradix;
 376         q -= slen;
 377     } else {
 378         /* Either decimal, or invalid -- if invalid, we'll trip up
 379            further down. */
 380         radix = 10;
 381     }
 382
 383     /*
 384      * `checklimit' must be 2**64 / radix. We can't do that in
 385      * 64-bit arithmetic, which we're (probably) using, so we
 386      * cheat: since we know that all radices we use are even, we
 387      * can divide 2**63 by radix/2 instead.
 388      */
 389     checklimit = UINT64_C(0x8000000000000000) / (radix >> 1);
 390
 391     /*
 392      * Calculate the highest allowable value for the last digit of a
 393      * 64-bit constant... in radix 10, it is 6, otherwise it is 0
 394      */
 395     last = (radix == 10 ? 6 : 0);
 396
 397     result = 0;
 398     while (*r && r < q) {
 399         if (*r != '_') {
 400             if (*r < '0' || (*r > '9' && *r < 'A')
 401                 || (digit = numvalue(*r)) >= radix) {
 402                 *error = true;
 403                 return 0;
 404             }
 405             if (result > checklimit ||
 406                 (result == checklimit && digit >= last)) {
 407                 warn = true;
 408             }
 409
 410             result = radix * result + digit;
 411         }
 412         r++;
 413     }
 414
 415     if (warn)
 416         nasm_error(ERR_WARNING | ERR_PASS1 | ERR_WARN_NOV,
 417                    "numeric constant %s does not fit in 64 bits",
 418                    str);
 419
 420     return result * sign;
 421 }
 422
 423 int64_t readstrnum(char *str, int length, bool *warn)
 424 {
 425     int64_t charconst = 0;
 426     int i;
 427
 428     *warn = false;
 429
 430     str += length;
 431     if (globalbits == 64) {
 432         for (i = 0; i < length; i++) {
 433             if (charconst & UINT64_C(0xFF00000000000000))
 434                 *warn = true;
 435             charconst = (charconst << 8) + (uint8_t)*--str;
 436         }
 437     } else {
 438         for (i = 0; i < length; i++) {
 439             if (charconst & 0xFF000000UL)
 440                 *warn = true;
 441             charconst = (charconst << 8) + (uint8_t)*--str;
 442         }
 443     }
 444     return charconst;
 445 }
 446
 447 static int32_t next_seg;
 448
 449 void seg_init(void)
 450 {
 451     next_seg = 0;
 452 }
 453
 454 int32_t seg_alloc(void)
 455 {
 456     return (next_seg += 2) - 2;
 457 }
 458
 459 #ifdef WORDS_LITTLEENDIAN
 460
 461 void fwriteint16_t(uint16_t data, FILE * fp)
 462 {
 463     fwrite(&data, 1, 2, fp);
 464 }
 465
 466 void fwriteint32_t(uint32_t data, FILE * fp)
 467 {
 468     fwrite(&data, 1, 4, fp);
 469 }
 470
 471 void fwriteint64_t(uint64_t data, FILE * fp)
 472 {
 473     fwrite(&data, 1, 8, fp);
 474 }
 475
 476 void fwriteaddr(uint64_t data, int size, FILE * fp)
 477 {
 478     fwrite(&data, 1, size, fp);
 479 }
 480
 481 #else /* not WORDS_LITTLEENDIAN */
 482
 483 void fwriteint16_t(uint16_t data, FILE * fp)
 484 {
 485     char buffer[2], *p = buffer;
 486     WRITESHORT(p, data);
 487     fwrite(buffer, 1, 2, fp);
 488 }
 489
 490 void fwriteint32_t(uint32_t data, FILE * fp)
 491 {
 492     char buffer[4], *p = buffer;
 493     WRITELONG(p, data);
 494     fwrite(buffer, 1, 4, fp);
 495 }
 496
 497 void fwriteint64_t(uint64_t data, FILE * fp)
 498 {
 499     char buffer[8], *p = buffer;
 500     WRITEDLONG(p, data);
 501     fwrite(buffer, 1, 8, fp);
 502 }
 503
 504 void fwriteaddr(uint64_t data, int size, FILE * fp)
 505 {
 506     char buffer[8], *p = buffer;
 507     WRITEADDR(p, data, size);
 508     fwrite(buffer, 1, size, fp);
 509 }
 510
 511 #endif
 512
 513 size_t fwritezero(size_t bytes, FILE *fp)
 514 {
 515     size_t count = 0;
 516     size_t blksize;
 517     size_t rv;
 518
 519     while (bytes) {
 520         blksize = (bytes < ZERO_BUF_SIZE) ? bytes : ZERO_BUF_SIZE;
 521
 522         rv = fwrite(zero_buffer, 1, blksize, fp);
 523         if (!rv)
 524             break;
 525
 526         count += rv;
 527         bytes -= rv;
 528     }
 529
 530     return count;
 531 }
 532
 533 void standard_extension(char *inname, char *outname, char *extension)
 534 {
 535     char *p, *q;
 536
 537     if (*outname)               /* file name already exists, */
 538         return;                 /* so do nothing */
 539     q = inname;
 540     p = outname;
 541     while (*q)
 542         *p++ = *q++;            /* copy, and find end of string */
 543     *p = '\0';                  /* terminate it */
 544     while (p > outname && *--p != '.') ;        /* find final period (or whatever) */
 545     if (*p != '.')
 546         while (*p)
 547             p++;                /* go back to end if none found */
 548     if (!strcmp(p, extension)) {        /* is the extension already there? */
 549         if (*extension)
 550             nasm_error(ERR_WARNING | ERR_NOFILE,
 551                        "file name already ends in `%s': "
 552                        "output will be in `nasm.out'", extension);
 553         else
 554             nasm_error(ERR_WARNING | ERR_NOFILE,
 555                        "file name already has no extension: "
 556                        "output will be in `nasm.out'");
 557         strcpy(outname, "nasm.out");
 558     } else
 559         strcpy(p, extension);
 560 }
 561
 562 /*
 563  * Common list of prefix names
 564  */
 565 static const char *prefix_names[] = {
 566     "a16", "a32", "a64", "asp", "lock", "o16", "o32", "o64", "osp",
 567     "rep", "repe", "repne", "repnz", "repz", "times", "wait"
 568 };
 569
 570 const char *prefix_name(int token)
 571 {
 572     unsigned int prefix = token-PREFIX_ENUM_START;
 573     if (prefix >= ARRAY_SIZE(prefix_names))
 574         return NULL;
 575
 576     return prefix_names[prefix];
 577 }
 578
 579 /*
 580  * Binary search.
 581  */
 582 int bsi(const char *string, const char **array, int size)
 583 {
 584     int i = -1, j = size;       /* always, i < index < j */
 585     while (j - i >= 2) {
 586         int k = (i + j) / 2;
 587         int l = strcmp(string, array[k]);
 588         if (l < 0)              /* it's in the first half */
 589             j = k;
 590         else if (l > 0)         /* it's in the second half */
 591             i = k;
 592         else                    /* we've got it :) */
 593             return k;
 594     }
 595     return -1;                  /* we haven't got it :( */
 596 }
 597
 598 int bsii(const char *string, const char **array, int size)
 599 {
 600     int i = -1, j = size;       /* always, i < index < j */
 601     while (j - i >= 2) {
 602         int k = (i + j) / 2;
 603         int l = nasm_stricmp(string, array[k]);
 604         if (l < 0)              /* it's in the first half */
 605             j = k;
 606         else if (l > 0)         /* it's in the second half */
 607             i = k;
 608         else                    /* we've got it :) */
 609             return k;
 610     }
 611     return -1;                  /* we haven't got it :( */
 612 }
 613
 614 static char *file_name = NULL;
 615 static int32_t line_number = 0;
 616
 617 char *src_set_fname(char *newname)
 618 {
 619     char *oldname = file_name;
 620     file_name = newname;
 621     return oldname;
 622 }
 623
 624 int32_t src_set_linnum(int32_t newline)
 625 {
 626     int32_t oldline = line_number;
 627     line_number = newline;
 628     return oldline;
 629 }
 630
 631 int32_t src_get_linnum(void)
 632 {
 633     return line_number;
 634 }
 635
 636 int src_get(int32_t *xline, char **xname)
 637 {
 638     if (!file_name || !*xname || strcmp(*xname, file_name)) {
 639         nasm_free(*xname);
 640         *xname = file_name ? nasm_strdup(file_name) : NULL;
 641         *xline = line_number;
 642         return -2;
 643     }
 644     if (*xline != line_number) {
 645         int32_t tmp = line_number - *xline;
 646         *xline = line_number;
 647         return tmp;
 648     }
 649     return 0;
 650 }
 651
 652 char *nasm_strcat(const char *one, const char *two)
 653 {
 654     char *rslt;
 655     int l1 = strlen(one);
 656     rslt = nasm_malloc(l1 + strlen(two) + 1);
 657     strcpy(rslt, one);
 658     strcpy(rslt + l1, two);
 659     return rslt;
 660 }
 661
 662 /* skip leading spaces */
 663 char *nasm_skip_spaces(const char *p)
 664 {
 665     if (p)
 666         while (*p && nasm_isspace(*p))
 667             p++;
 668     return (char *)p;
 669 }
 670
 671 /* skip leading non-spaces */
 672 char *nasm_skip_word(const char *p)
 673 {
 674     if (p)
 675         while (*p && !nasm_isspace(*p))
 676             p++;
 677     return (char *)p;
 678 }
 679
 680 /* zap leading spaces with zero */
 681 char *nasm_zap_spaces_fwd(char *p)
 682 {
 683     if (p)
 684         while (*p && nasm_isspace(*p))
 685             *p++ = 0x0;
 686     return p;
 687 }
 688
 689 /* zap spaces with zero in reverse order */
 690 char *nasm_zap_spaces_rev(char *p)
 691 {
 692     if (p)
 693         while (*p && nasm_isspace(*p))
 694             *p-- = 0x0;
 695     return p;
 696 }
 697
 698 /* zap leading and trailing spaces */
 699 char *nasm_trim_spaces(char *p)
 700 {
 701     p = nasm_zap_spaces_fwd(p);
 702     nasm_zap_spaces_fwd(nasm_skip_word(p));
 703
 704     return p;
 705 }
 706
 707 /*
 708  * return the word extracted from a stream
 709  * or NULL if nothing left
 710  */
 711 char *nasm_get_word(char *p, char **tail)
 712 {
 713     char *word = nasm_skip_spaces(p);
 714     char *next = nasm_skip_word(word);
 715
 716     if (word && *word) {
 717         if (*next)
 718             *next++ = '\0';
 719     } else
 720         word = next = NULL;
 721
 722     /* NOTE: the tail may start with spaces */
 723     *tail = next;
 724
 725     return word;
 726 }
 727
 728 /*
 729  * Extract "opt=val" values from the stream and
 730  * returns "opt"
 731  *
 732  * Exceptions:
 733  * 1) If "=val" passed the NULL returned though
 734  *    you may continue handling the tail via "next"
 735  * 2) If "=" passed the NULL is returned and "val"
 736  *    is set to NULL as well
 737  */
 738 char *nasm_opt_val(char *p, char **val, char **next)
 739 {
 740     char *q, *opt, *nxt;
 741
 742     opt = *val = *next = NULL;
 743
 744     p = nasm_get_word(p, &nxt);
 745     if (!p)
 746         return NULL;
 747
 748     q = strchr(p, '=');
 749     if (q) {
 750         if (q == p)
 751             p = NULL;
 752         *q++='\0';
 753         if (*q) {
 754             *val = q;
 755         } else {
 756             q = nasm_get_word(q + 1, &nxt);
 757             if (q)
 758                 *val = q;
 759         }
 760     } else {
 761         q = nasm_skip_spaces(nxt);
 762         if (q && *q == '=') {
 763             q = nasm_get_word(q + 1, &nxt);
 764             if (q)
 765                 *val = q;
 766         }
 767     }
 768
 769     *next = nxt;
 770     return p;
 771 }
 772
 773 /*
 774  * initialized data bytes length from opcode
 775  */
 776 int idata_bytes(int opcode)
 777 {
 778     int ret;
 779     switch (opcode) {
 780     case I_DB:
 781         ret = 1;
 782         break;
 783     case I_DW:
 784         ret = 2;
 785         break;
 786     case I_DD:
 787         ret = 4;
 788         break;
 789     case I_DQ:
 790         ret = 8;
 791         break;
 792     case I_DT:
 793         ret = 10;
 794         break;
 795     case I_DO:
 796         ret = 16;
 797         break;
 798     case I_DY:
 799         ret = 32;
 800         break;
 801     case I_none:
 802         ret = -1;
 803         break;
 804     default:
 805         ret = 0;
 806         break;
 807     }
 808     return ret;
 809 }