From 1598a23ba3377f575ae3b634848d8b50705346aa Mon Sep 17 00:00:00 2001 From: Cyrill Gorcunov Date: Sun, 11 Oct 2009 13:17:52 +0400 Subject: [PATCH] style cleanup Convert tabs to spaces. Eliminate empty comments. No change on binary level. Signed-off-by: Cyrill Gorcunov --- float.c | 542 +++++++++++++++++++++++++++--------------------------- hashtbl.c | 122 ++++++------ nasmlib.h | 206 ++++++++++----------- 3 files changed, 435 insertions(+), 435 deletions(-) diff --git a/float.c b/float.c index 737a2c9..7a4f8cb 100644 --- a/float.c +++ b/float.c @@ -1,5 +1,5 @@ /* ----------------------------------------------------------------------- * - * + * * Copyright 1996-2009 The NASM Authors - All Rights Reserved * See the file AUTHORS included with the NASM distribution for * the specific copyright holders. @@ -14,7 +14,7 @@ * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. - * + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF @@ -65,12 +65,12 @@ static enum float_round rc = FLOAT_RC_NEAR; /* rounding control */ typedef uint32_t fp_limb; typedef uint64_t fp_2limb; -#define LIMB_BITS 32 +#define LIMB_BITS 32 #define LIMB_BYTES (LIMB_BITS/8) -#define LIMB_TOP_BIT ((fp_limb)1 << (LIMB_BITS-1)) -#define LIMB_MASK ((fp_limb)(~0)) -#define LIMB_ALL_BYTES ((fp_limb)0x01010101) -#define LIMB_BYTE(x) ((x)*LIMB_ALL_BYTES) +#define LIMB_TOP_BIT ((fp_limb)1 << (LIMB_BITS-1)) +#define LIMB_MASK ((fp_limb)(~0)) +#define LIMB_ALL_BYTES ((fp_limb)0x01010101) +#define LIMB_BYTE(x) ((x)*LIMB_ALL_BYTES) /* 112 bits + 64 bits for accuracy + 16 bits for rounding */ #define MANT_LIMBS 6 @@ -82,8 +82,8 @@ typedef uint64_t fp_2limb; #define MANT_FMT "%08x_%08x_%08x_%08x_%08x_%08x" #define MANT_ARG SOME_ARG(mant, 0) -#define SOME_ARG(a,i) (a)[(i)+0], (a)[(i)+1], (a)[(i)+2], (a)[(i)+3], \ - (a)[(i)+4], (a)[(i)+5] +#define SOME_ARG(a,i) (a)[(i)+0], (a)[(i)+1], (a)[(i)+2], \ + (a)[(i)+3], (a)[(i)+4], (a)[(i)+5] /* * --------------------------------------------------------------------------- @@ -93,9 +93,9 @@ typedef uint64_t fp_2limb; #ifdef DEBUG_FLOAT #define dprintf(x) printf x -#else /* */ +#else #define dprintf(x) do { } while (0) -#endif /* */ +#endif /* * --------------------------------------------------------------------------- @@ -159,36 +159,36 @@ static int32_t read_exponent(const char *string, int32_t max) bool neg = false; if (*string == '+') { - string++; + string++; } else if (*string == '-') { - neg = true; - string++; + neg = true; + string++; } while (*string) { - if (*string >= '0' && *string <= '9') { - i = (i * 10) + (*string - '0'); - - /* - * To ensure that underflows and overflows are - * handled properly we must avoid wraparounds of - * the signed integer value that is used to hold - * the exponent. Therefore we cap the exponent at - * +/-5000, which is slightly more/less than - * what's required for normal and denormal numbers - * in single, double, and extended precision, but - * sufficient to avoid signed integer wraparound. - */ - if (i > max) - i = max; - } else if (*string == '_') { - /* do nothing */ - } else { - error(ERR_NONFATAL|ERR_PASS1, - "invalid character in floating-point constant %s: '%c'", - "exponent", *string); - return INT32_MAX; - } - string++; + if (*string >= '0' && *string <= '9') { + i = (i * 10) + (*string - '0'); + + /* + * To ensure that underflows and overflows are + * handled properly we must avoid wraparounds of + * the signed integer value that is used to hold + * the exponent. Therefore we cap the exponent at + * +/-5000, which is slightly more/less than + * what's required for normal and denormal numbers + * in single, double, and extended precision, but + * sufficient to avoid signed integer wraparound. + */ + if (i > max) + i = max; + } else if (*string == '_') { + /* do nothing */ + } else { + error(ERR_NONFATAL|ERR_PASS1, + "invalid character in floating-point constant %s: '%c'", + "exponent", *string); + return INT32_MAX; + } + string++; } return neg ? -i : i; @@ -257,13 +257,13 @@ static bool ieee_flconvert(const char *string, fp_limb *mant, } if (*string) { - int32_t e; + int32_t e; string++; /* eat the E */ - e = read_exponent(string, 5000); - if (e == INT32_MAX) - return false; - tenpwr += e; + e = read_exponent(string, 5000); + if (e == INT32_MAX) + return false; + tenpwr += e; } /* @@ -419,8 +419,8 @@ static bool is_zero(const fp_limb *mant) int i; for (i = 0; i < MANT_LIMBS; i++) - if (mant[i]) - return false; + if (mant[i]) + return false; return true; } @@ -431,29 +431,29 @@ static bool is_zero(const fp_limb *mant) * --------------------------------------------------------------------------- */ -#define ROUND_COLLECT_BITS \ - do { \ - m = mant[i] & (2*bit-1); \ - for (j = i+1; j < MANT_LIMBS; j++) \ - m = m | mant[j]; \ +#define ROUND_COLLECT_BITS \ + do { \ + m = mant[i] & (2*bit-1); \ + for (j = i+1; j < MANT_LIMBS; j++) \ + m = m | mant[j]; \ } while (0) -#define ROUND_ABS_DOWN \ - do { \ - mant[i] &= ~(bit-1); \ - for (j = i+1; j < MANT_LIMBS; j++) \ - mant[j] = 0; \ - return false; \ +#define ROUND_ABS_DOWN \ + do { \ + mant[i] &= ~(bit-1); \ + for (j = i+1; j < MANT_LIMBS; j++) \ + mant[j] = 0; \ + return false; \ } while (0) -#define ROUND_ABS_UP \ - do { \ - mant[i] = (mant[i] & ~(bit-1)) + bit; \ - for (j = i+1; j < MANT_LIMBS; j++) \ - mant[j] = 0; \ - while (i > 0 && !mant[i]) \ - ++mant[--i]; \ - return !mant[0]; \ +#define ROUND_ABS_UP \ + do { \ + mant[i] = (mant[i] & ~(bit-1)) + bit; \ + for (j = i+1; j < MANT_LIMBS; j++) \ + mant[j] = 0; \ + while (i > 0 && !mant[i]) \ + ++mant[--i]; \ + return !mant[0]; \ } while (0) static bool ieee_round(bool minus, fp_limb *mant, int bits) @@ -465,34 +465,34 @@ static bool ieee_round(bool minus, fp_limb *mant, int bits) fp_limb bit = LIMB_TOP_BIT >> p; if (rc == FLOAT_RC_NEAR) { - if (mant[i] & bit) { - mant[i] &= ~bit; - ROUND_COLLECT_BITS; - mant[i] |= bit; - if (m) { - ROUND_ABS_UP; - } else { - if (test_bit(mant, bits-1)) { - ROUND_ABS_UP; - } else { - ROUND_ABS_DOWN; - } - } - } else { - ROUND_ABS_DOWN; - } + if (mant[i] & bit) { + mant[i] &= ~bit; + ROUND_COLLECT_BITS; + mant[i] |= bit; + if (m) { + ROUND_ABS_UP; + } else { + if (test_bit(mant, bits-1)) { + ROUND_ABS_UP; + } else { + ROUND_ABS_DOWN; + } + } + } else { + ROUND_ABS_DOWN; + } } else if (rc == FLOAT_RC_ZERO || - rc == (minus ? FLOAT_RC_UP : FLOAT_RC_DOWN)) { - ROUND_ABS_DOWN; + rc == (minus ? FLOAT_RC_UP : FLOAT_RC_DOWN)) { + ROUND_ABS_DOWN; } else { - /* rc == (minus ? FLOAT_RC_DOWN : FLOAT_RC_UP) */ - /* Round toward +/- infinity */ - ROUND_COLLECT_BITS; - if (m) { - ROUND_ABS_UP; - } else { - ROUND_ABS_DOWN; - } + /* rc == (minus ? FLOAT_RC_DOWN : FLOAT_RC_UP) */ + /* Round toward +/- infinity */ + ROUND_COLLECT_BITS; + if (m) { + ROUND_ABS_UP; + } else { + ROUND_ABS_DOWN; + } } return false; } @@ -510,7 +510,7 @@ static unsigned int hexval(char c) /* Handle floating-point numbers with radix 2^bits and binary exponent */ static bool ieee_flconvert_bin(const char *string, int bits, - fp_limb *mant, int32_t *exponent) + fp_limb *mant, int32_t *exponent) { static const int log2tbl[16] = { -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3 }; @@ -567,14 +567,14 @@ static bool ieee_flconvert_bin(const char *string, int bits, twopwr -= bits; } } else if (c == 'p' || c == 'P') { - int32_t e; - e = read_exponent(string, 20000); - if (e == INT32_MAX) - return false; - twopwr += e; + int32_t e; + e = read_exponent(string, 20000); + if (e == INT32_MAX) + return false; + twopwr += e; break; - } else if (c == '_') { - /* ignore */ + } else if (c == '_') { + /* ignore */ } else { error(ERR_NONFATAL|ERR_PASS1, "floating-point constant: `%c' is invalid character", c); @@ -606,20 +606,20 @@ static void ieee_shr(fp_limb *mant, int i) offs = i/LIMB_BITS; if (sr == 0) { - if (offs) - for (j = MANT_LIMBS-1; j >= offs; j--) - mant[j] = mant[j-offs]; + if (offs) + for (j = MANT_LIMBS-1; j >= offs; j--) + mant[j] = mant[j-offs]; } else { - n = mant[MANT_LIMBS-1-offs] >> sr; - for (j = MANT_LIMBS-1; j > offs; j--) { - m = mant[j-offs-1]; - mant[j] = (m << sl) | n; - n = m >> sr; - } - mant[j--] = n; + n = mant[MANT_LIMBS-1-offs] >> sr; + for (j = MANT_LIMBS-1; j > offs; j--) { + m = mant[j-offs-1]; + mant[j] = (m << sl) | n; + n = m >> sr; + } + mant[j--] = n; } while (j >= 0) - mant[j--] = 0; + mant[j--] = 0; } /* Produce standard IEEE formats, with implicit or explicit integer @@ -633,7 +633,7 @@ static void ieee_shr(fp_limb *mant, int i) struct ieee_format { int bytes; int mantissa; /* Fractional bits in the mantissa */ - int explicit; /* Explicit integer */ + int explicit; /* Explicit integer */ int exponent; /* Bits in the exponent */ }; @@ -666,54 +666,54 @@ enum floats { }; static int to_packed_bcd(const char *str, const char *p, - int s, uint8_t *result, - const struct ieee_format *fmt) + int s, uint8_t *result, + const struct ieee_format *fmt) { int n = 0; char c; int tv = -1; if (fmt != &ieee_80) { - error(ERR_NONFATAL|ERR_PASS1, - "packed BCD requires an 80-bit format"); - return 0; + error(ERR_NONFATAL|ERR_PASS1, + "packed BCD requires an 80-bit format"); + return 0; } while (p >= str) { - c = *p--; - if (c >= '0' && c <= '9') { - if (tv < 0) { - if (n == 9) { - error(ERR_WARNING|ERR_PASS1, - "packed BCD truncated to 18 digits"); - } - tv = c-'0'; - } else { - if (n < 9) - *result++ = tv + ((c-'0') << 4); - n++; - tv = -1; - } - } else if (c == '_') { - /* do nothing */ - } else { - error(ERR_NONFATAL|ERR_PASS1, - "invalid character `%c' in packed BCD constant", c); - return 0; - } + c = *p--; + if (c >= '0' && c <= '9') { + if (tv < 0) { + if (n == 9) { + error(ERR_WARNING|ERR_PASS1, + "packed BCD truncated to 18 digits"); + } + tv = c-'0'; + } else { + if (n < 9) + *result++ = tv + ((c-'0') << 4); + n++; + tv = -1; + } + } else if (c == '_') { + /* do nothing */ + } else { + error(ERR_NONFATAL|ERR_PASS1, + "invalid character `%c' in packed BCD constant", c); + return 0; + } } if (tv >= 0) { - if (n < 9) - *result++ = tv; - n++; + if (n < 9) + *result++ = tv; + n++; } while (n < 9) { - *result++ = 0; - n++; + *result++ = 0; + n++; } *result = (s < 0) ? 0x80 : 0; - return 1; /* success */ + return 1; /* success */ } static int to_float(const char *str, int s, uint8_t *result, @@ -723,7 +723,7 @@ static int to_float(const char *str, int s, uint8_t *result, int32_t exponent = 0; const int32_t expmax = 1 << (fmt->exponent - 1); fp_limb one_mask = LIMB_TOP_BIT >> - ((fmt->exponent+fmt->explicit) % LIMB_BITS); + ((fmt->exponent+fmt->explicit) % LIMB_BITS); const int one_pos = (fmt->exponent+fmt->explicit)/LIMB_BITS; int i; int shift; @@ -734,169 +734,169 @@ static int to_float(const char *str, int s, uint8_t *result, const char *strend; if (!str[0]) { - error(ERR_PANIC, - "internal errror: empty string passed to float_const"); - return 0; + error(ERR_PANIC, + "internal errror: empty string passed to float_const"); + return 0; } strend = strchr(str, '\0'); if (strend[-1] == 'P' || strend[-1] == 'p') - return to_packed_bcd(str, strend-2, s, result, fmt); + return to_packed_bcd(str, strend-2, s, result, fmt); if (str[0] == '_') { - /* Special tokens */ + /* Special tokens */ switch (str[2]) { case 'n': /* __nan__ */ case 'N': case 'q': /* __qnan__ */ case 'Q': - type = FL_QNAN; + type = FL_QNAN; break; case 's': /* __snan__ */ case 'S': - type = FL_SNAN; + type = FL_SNAN; break; case 'i': /* __infinity__ */ case 'I': - type = FL_INFINITY; + type = FL_INFINITY; + break; + default: + error(ERR_NONFATAL|ERR_PASS1, + "internal error: unknown FP constant token `%s'\n", str); + type = FL_QNAN; break; - default: - error(ERR_NONFATAL|ERR_PASS1, - "internal error: unknown FP constant token `%s'\n", str); - type = FL_QNAN; - break; } } else { if (str[0] == '0') { - switch (str[1]) { - case 'x': case 'X': - case 'h': case 'H': - ok = ieee_flconvert_bin(str+2, 4, mant, &exponent); - break; - case 'o': case 'O': - case 'q': case 'Q': - ok = ieee_flconvert_bin(str+2, 3, mant, &exponent); - break; - case 'b': case 'B': - case 'y': case 'Y': - ok = ieee_flconvert_bin(str+2, 1, mant, &exponent); - break; - case 'd': case 'D': - case 't': case 'T': - ok = ieee_flconvert(str+2, mant, &exponent); - break; - case 'p': case 'P': - return to_packed_bcd(str+2, strend-1, s, result, fmt); - default: - /* Leading zero was just a zero? */ - ok = ieee_flconvert(str, mant, &exponent); - break; - } - } else if (str[0] == '$') { - ok = ieee_flconvert_bin(str+1, 4, mant, &exponent); - } else { + switch (str[1]) { + case 'x': case 'X': + case 'h': case 'H': + ok = ieee_flconvert_bin(str+2, 4, mant, &exponent); + break; + case 'o': case 'O': + case 'q': case 'Q': + ok = ieee_flconvert_bin(str+2, 3, mant, &exponent); + break; + case 'b': case 'B': + case 'y': case 'Y': + ok = ieee_flconvert_bin(str+2, 1, mant, &exponent); + break; + case 'd': case 'D': + case 't': case 'T': + ok = ieee_flconvert(str+2, mant, &exponent); + break; + case 'p': case 'P': + return to_packed_bcd(str+2, strend-1, s, result, fmt); + default: + /* Leading zero was just a zero? */ + ok = ieee_flconvert(str, mant, &exponent); + break; + } + } else if (str[0] == '$') { + ok = ieee_flconvert_bin(str+1, 4, mant, &exponent); + } else { ok = ieee_flconvert(str, mant, &exponent); - } + } - if (!ok) { - type = FL_QNAN; - } else if (mant[0] & LIMB_TOP_BIT) { + if (!ok) { + type = FL_QNAN; + } else if (mant[0] & LIMB_TOP_BIT) { /* * Non-zero. */ exponent--; if (exponent >= 2 - expmax && exponent <= expmax) { - type = FL_NORMAL; + type = FL_NORMAL; } else if (exponent > 0) { - if (pass0 == 1) - error(ERR_WARNING|ERR_WARN_FL_OVERFLOW|ERR_PASS1, - "overflow in floating-point constant"); - type = FL_INFINITY; - } else { - /* underflow or denormal; the denormal code handles - actual underflow. */ - type = FL_DENORMAL; - } - } else { - /* Zero */ - type = FL_ZERO; - } + if (pass0 == 1) + error(ERR_WARNING|ERR_WARN_FL_OVERFLOW|ERR_PASS1, + "overflow in floating-point constant"); + type = FL_INFINITY; + } else { + /* underflow or denormal; the denormal code handles + actual underflow. */ + type = FL_DENORMAL; + } + } else { + /* Zero */ + type = FL_ZERO; + } } switch (type) { case FL_ZERO: zero: - memset(mant, 0, sizeof mant); - break; + memset(mant, 0, sizeof mant); + break; case FL_DENORMAL: { - shift = -(exponent + expmax - 2 - fmt->exponent) - + fmt->explicit; - ieee_shr(mant, shift); - ieee_round(minus, mant, bits); - if (mant[one_pos] & one_mask) { - /* One's position is set, we rounded up into normal range */ - exponent = 1; - if (!fmt->explicit) - mant[one_pos] &= ~one_mask; /* remove explicit one */ - mant[0] |= exponent << (LIMB_BITS-1 - fmt->exponent); - } else { - if (daz || is_zero(mant)) { - /* Flush denormals to zero */ - error(ERR_WARNING|ERR_WARN_FL_UNDERFLOW|ERR_PASS1, - "underflow in floating-point constant"); - goto zero; - } else { - error(ERR_WARNING|ERR_WARN_FL_DENORM|ERR_PASS1, - "denormal floating-point constant"); - } - } - break; + shift = -(exponent + expmax - 2 - fmt->exponent) + + fmt->explicit; + ieee_shr(mant, shift); + ieee_round(minus, mant, bits); + if (mant[one_pos] & one_mask) { + /* One's position is set, we rounded up into normal range */ + exponent = 1; + if (!fmt->explicit) + mant[one_pos] &= ~one_mask; /* remove explicit one */ + mant[0] |= exponent << (LIMB_BITS-1 - fmt->exponent); + } else { + if (daz || is_zero(mant)) { + /* Flush denormals to zero */ + error(ERR_WARNING|ERR_WARN_FL_UNDERFLOW|ERR_PASS1, + "underflow in floating-point constant"); + goto zero; + } else { + error(ERR_WARNING|ERR_WARN_FL_DENORM|ERR_PASS1, + "denormal floating-point constant"); + } + } + break; } case FL_NORMAL: - exponent += expmax - 1; - ieee_shr(mant, fmt->exponent+fmt->explicit); - ieee_round(minus, mant, bits); - /* did we scale up by one? */ - if (test_bit(mant, fmt->exponent+fmt->explicit-1)) { - ieee_shr(mant, 1); - exponent++; - if (exponent >= (expmax << 1)-1) { - error(ERR_WARNING|ERR_WARN_FL_OVERFLOW|ERR_PASS1, - "overflow in floating-point constant"); - type = FL_INFINITY; - goto overflow; - } - } - - if (!fmt->explicit) - mant[one_pos] &= ~one_mask; /* remove explicit one */ - mant[0] |= exponent << (LIMB_BITS-1 - fmt->exponent); - break; + exponent += expmax - 1; + ieee_shr(mant, fmt->exponent+fmt->explicit); + ieee_round(minus, mant, bits); + /* did we scale up by one? */ + if (test_bit(mant, fmt->exponent+fmt->explicit-1)) { + ieee_shr(mant, 1); + exponent++; + if (exponent >= (expmax << 1)-1) { + error(ERR_WARNING|ERR_WARN_FL_OVERFLOW|ERR_PASS1, + "overflow in floating-point constant"); + type = FL_INFINITY; + goto overflow; + } + } + + if (!fmt->explicit) + mant[one_pos] &= ~one_mask; /* remove explicit one */ + mant[0] |= exponent << (LIMB_BITS-1 - fmt->exponent); + break; case FL_INFINITY: case FL_QNAN: case FL_SNAN: overflow: - memset(mant, 0, sizeof mant); - mant[0] = (((fp_limb)1 << fmt->exponent)-1) - << (LIMB_BITS-1 - fmt->exponent); - if (fmt->explicit) - mant[one_pos] |= one_mask; - if (type == FL_QNAN) - set_bit(mant, fmt->exponent+fmt->explicit+1); - else if (type == FL_SNAN) - set_bit(mant, fmt->exponent+fmt->explicit+fmt->mantissa); - break; + memset(mant, 0, sizeof mant); + mant[0] = (((fp_limb)1 << fmt->exponent)-1) + << (LIMB_BITS-1 - fmt->exponent); + if (fmt->explicit) + mant[one_pos] |= one_mask; + if (type == FL_QNAN) + set_bit(mant, fmt->exponent+fmt->explicit+1); + else if (type == FL_SNAN) + set_bit(mant, fmt->exponent+fmt->explicit+fmt->mantissa); + break; } mant[0] |= minus ? LIMB_TOP_BIT : 0; for (i = fmt->bytes - 1; i >= 0; i--) - *result++ = mant[i/LIMB_BYTES] >> (((LIMB_BYTES-1)-(i%LIMB_BYTES))*8); + *result++ = mant[i/LIMB_BYTES] >> (((LIMB_BYTES-1)-(i%LIMB_BYTES))*8); return 1; /* success */ } @@ -929,28 +929,28 @@ int float_const(const char *number, int sign, uint8_t *result, int float_option(const char *option) { if (!nasm_stricmp(option, "daz")) { - daz = true; - return 0; + daz = true; + return 0; } else if (!nasm_stricmp(option, "nodaz")) { - daz = false; - return 0; + daz = false; + return 0; } else if (!nasm_stricmp(option, "near")) { - rc = FLOAT_RC_NEAR; - return 0; + rc = FLOAT_RC_NEAR; + return 0; } else if (!nasm_stricmp(option, "down")) { - rc = FLOAT_RC_DOWN; - return 0; + rc = FLOAT_RC_DOWN; + return 0; } else if (!nasm_stricmp(option, "up")) { - rc = FLOAT_RC_UP; - return 0; + rc = FLOAT_RC_UP; + return 0; } else if (!nasm_stricmp(option, "zero")) { - rc = FLOAT_RC_ZERO; - return 0; + rc = FLOAT_RC_ZERO; + return 0; } else if (!nasm_stricmp(option, "default")) { - rc = FLOAT_RC_NEAR; - daz = false; - return 0; + rc = FLOAT_RC_NEAR; + daz = false; + return 0; } else { - return -1; /* Unknown option */ + return -1; /* Unknown option */ } } diff --git a/hashtbl.c b/hashtbl.c index fa95478..2b55755 100644 --- a/hashtbl.c +++ b/hashtbl.c @@ -1,5 +1,5 @@ /* ----------------------------------------------------------------------- * - * + * * Copyright 1996-2009 The NASM Authors - All Rights Reserved * See the file AUTHORS included with the NASM distribution for * the specific copyright holders. @@ -14,7 +14,7 @@ * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. - * + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF @@ -44,7 +44,7 @@ #include "nasm.h" #include "hashtbl.h" -#define HASH_MAX_LOAD 2 /* Higher = more memory-efficient, slower */ +#define HASH_MAX_LOAD 2 /* Higher = more memory-efficient, slower */ static struct hash_tbl_node *alloc_table(size_t newsize) { @@ -75,26 +75,26 @@ void hash_init(struct hash_table *head, size_t size) * structure. */ void **hash_find(struct hash_table *head, const char *key, - struct hash_insert *insert) + struct hash_insert *insert) { struct hash_tbl_node *np; uint64_t hash = crc64(CRC64_INIT, key); struct hash_tbl_node *tbl = head->table; size_t mask = head->size-1; size_t pos = hash & mask; - size_t inc = ((hash >> 32) & mask) | 1; /* Always odd */ + size_t inc = ((hash >> 32) & mask) | 1; /* Always odd */ while ((np = &tbl[pos])->key) { - if (hash == np->hash && !strcmp(key, np->key)) - return &np->data; - pos = (pos+inc) & mask; + if (hash == np->hash && !strcmp(key, np->key)) + return &np->data; + pos = (pos+inc) & mask; } /* Not found. Store info for insert if requested. */ if (insert) { - insert->head = head; - insert->hash = hash; - insert->where = np; + insert->head = head; + insert->hash = hash; + insert->where = np; } return NULL; } @@ -103,26 +103,26 @@ void **hash_find(struct hash_table *head, const char *key, * Same as hash_find, but for case-insensitive hashing. */ void **hash_findi(struct hash_table *head, const char *key, - struct hash_insert *insert) + struct hash_insert *insert) { struct hash_tbl_node *np; uint64_t hash = crc64i(CRC64_INIT, key); struct hash_tbl_node *tbl = head->table; size_t mask = head->size-1; size_t pos = hash & mask; - size_t inc = ((hash >> 32) & mask) | 1; /* Always odd */ + size_t inc = ((hash >> 32) & mask) | 1; /* Always odd */ while ((np = &tbl[pos])->key) { - if (hash == np->hash && !nasm_stricmp(key, np->key)) - return &np->data; - pos = (pos+inc) & mask; + if (hash == np->hash && !nasm_stricmp(key, np->key)) + return &np->data; + pos = (pos+inc) & mask; } /* Not found. Store info for insert if requested. */ if (insert) { - insert->head = head; - insert->hash = hash; - insert->where = np; + insert->head = head; + insert->hash = hash; + insert->where = np; } return NULL; } @@ -143,35 +143,35 @@ void **hash_add(struct hash_insert *insert, const char *key, void *data) np->data = data; if (++head->load > head->max_load) { - /* Need to expand the table */ - size_t newsize = head->size << 1; - struct hash_tbl_node *newtbl = alloc_table(newsize); - size_t mask = newsize-1; - - if (head->table) { - struct hash_tbl_node *op, *xp; - size_t i; - - /* Rebalance all the entries */ - for (i = 0, op = head->table; i < head->size; i++, op++) { - if (op->key) { - size_t pos = op->hash & mask; - size_t inc = ((op->hash >> 32) & mask) | 1; - - while ((xp = &newtbl[pos])->key) - pos = (pos+inc) & mask; - - *xp = *op; - if (op == np) - np = xp; - } - } - nasm_free(head->table); - } - - head->table = newtbl; - head->size = newsize; - head->max_load = newsize*(HASH_MAX_LOAD-1)/HASH_MAX_LOAD; + /* Need to expand the table */ + size_t newsize = head->size << 1; + struct hash_tbl_node *newtbl = alloc_table(newsize); + size_t mask = newsize-1; + + if (head->table) { + struct hash_tbl_node *op, *xp; + size_t i; + + /* Rebalance all the entries */ + for (i = 0, op = head->table; i < head->size; i++, op++) { + if (op->key) { + size_t pos = op->hash & mask; + size_t inc = ((op->hash >> 32) & mask) | 1; + + while ((xp = &newtbl[pos])->key) + pos = (pos+inc) & mask; + + *xp = *op; + if (op == np) + np = xp; + } + } + nasm_free(head->table); + } + + head->table = newtbl; + head->size = newsize; + head->max_load = newsize*(HASH_MAX_LOAD-1)/HASH_MAX_LOAD; } return &np->data; @@ -183,31 +183,31 @@ void **hash_add(struct hash_insert *insert, const char *key, void *data) * or NULL on failure. */ void *hash_iterate(const struct hash_table *head, - struct hash_tbl_node **iterator, - const char **key) + struct hash_tbl_node **iterator, + const char **key) { struct hash_tbl_node *np = *iterator; struct hash_tbl_node *ep = head->table + head->size; if (!np) { - np = head->table; - if (!np) - return NULL; /* Uninitialized table */ + np = head->table; + if (!np) + return NULL; /* Uninitialized table */ } while (np < ep) { - if (np->key) { - *iterator = np+1; - if (key) - *key = np->key; - return np->data; - } - np++; + if (np->key) { + *iterator = np+1; + if (key) + *key = np->key; + return np->data; + } + np++; } *iterator = NULL; if (key) - *key = NULL; + *key = NULL; return NULL; } diff --git a/nasmlib.h b/nasmlib.h index c42c3fd..689485b 100644 --- a/nasmlib.h +++ b/nasmlib.h @@ -1,5 +1,5 @@ /* ----------------------------------------------------------------------- * - * + * * Copyright 1996-2009 The NASM Authors - All Rights Reserved * See the file AUTHORS included with the NASM distribution for * the specific copyright holders. @@ -14,7 +14,7 @@ * copyright notice, this list of conditions and the following * disclaimer in the documentation and/or other materials provided * with the distribution. - * + * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF @@ -31,8 +31,8 @@ * * ----------------------------------------------------------------------- */ -/* - * nasmlib.h header file for nasmlib.c +/* + * nasmlib.h header file for nasmlib.c */ #ifndef NASM_NASMLIB_H @@ -96,41 +96,41 @@ void nasm_set_verror(vefunc); * argument to an efunc. */ -#define ERR_DEBUG 0x00000008 /* put out debugging message */ -#define ERR_WARNING 0x00000000 /* warn only: no further action */ -#define ERR_NONFATAL 0x00000001 /* terminate assembly after phase */ -#define ERR_FATAL 0x00000002 /* instantly fatal: exit with error */ -#define ERR_PANIC 0x00000003 /* internal error: panic instantly +#define ERR_DEBUG 0x00000008 /* put out debugging message */ +#define ERR_WARNING 0x00000000 /* warn only: no further action */ +#define ERR_NONFATAL 0x00000001 /* terminate assembly after phase */ +#define ERR_FATAL 0x00000002 /* instantly fatal: exit with error */ +#define ERR_PANIC 0x00000003 /* internal error: panic instantly * and dump core for reference */ -#define ERR_MASK 0x0000000F /* mask off the above codes */ -#define ERR_NOFILE 0x00000010 /* don't give source file name/line */ -#define ERR_USAGE 0x00000020 /* print a usage message */ -#define ERR_PASS1 0x00000040 /* only print this error on pass one */ -#define ERR_PASS2 0x00000080 -#define ERR_NO_SEVERITY 0x00000100 /* suppress printing severity */ +#define ERR_MASK 0x0000000F /* mask off the above codes */ +#define ERR_NOFILE 0x00000010 /* don't give source file name/line */ +#define ERR_USAGE 0x00000020 /* print a usage message */ +#define ERR_PASS1 0x00000040 /* only print this error on pass one */ +#define ERR_PASS2 0x00000080 +#define ERR_NO_SEVERITY 0x00000100 /* suppress printing severity */ /* * These codes define specific types of suppressible warning. */ -#define ERR_WARN_MASK 0xFFFFF000 /* the mask for this feature */ -#define ERR_WARN_SHR 12 /* how far to shift right */ +#define ERR_WARN_MASK 0xFFFFF000 /* the mask for this feature */ +#define ERR_WARN_SHR 12 /* how far to shift right */ #define WARN(x) ((x) << ERR_WARN_SHR) -#define ERR_WARN_MNP WARN( 1) /* macro-num-parameters warning */ -#define ERR_WARN_MSR WARN( 2) /* macro self-reference */ -#define ERR_WARN_MDP WARN( 3) /* macro default parameters check */ -#define ERR_WARN_OL WARN( 4) /* orphan label (no colon, and +#define ERR_WARN_MNP WARN( 1) /* macro-num-parameters warning */ +#define ERR_WARN_MSR WARN( 2) /* macro self-reference */ +#define ERR_WARN_MDP WARN( 3) /* macro default parameters check */ +#define ERR_WARN_OL WARN( 4) /* orphan label (no colon, and * alone on line) */ -#define ERR_WARN_NOV WARN( 5) /* numeric overflow */ -#define ERR_WARN_GNUELF WARN( 6) /* using GNU ELF extensions */ -#define ERR_WARN_FL_OVERFLOW WARN( 7) /* FP overflow */ -#define ERR_WARN_FL_DENORM WARN( 8) /* FP denormal */ -#define ERR_WARN_FL_UNDERFLOW WARN( 9) /* FP underflow */ -#define ERR_WARN_FL_TOOLONG WARN(10) /* FP too many digits */ -#define ERR_WARN_USER WARN(11) /* %warning directives */ -#define ERR_WARN_MAX 11 /* the highest numbered one */ +#define ERR_WARN_NOV WARN( 5) /* numeric overflow */ +#define ERR_WARN_GNUELF WARN( 6) /* using GNU ELF extensions */ +#define ERR_WARN_FL_OVERFLOW WARN( 7) /* FP overflow */ +#define ERR_WARN_FL_DENORM WARN( 8) /* FP denormal */ +#define ERR_WARN_FL_UNDERFLOW WARN( 9) /* FP underflow */ +#define ERR_WARN_FL_TOOLONG WARN(10) /* FP too many digits */ +#define ERR_WARN_USER WARN(11) /* %warning directives */ +#define ERR_WARN_MAX 11 /* the highest numbered one */ /* * Wrappers around malloc, realloc and free. nasm_malloc will @@ -166,10 +166,10 @@ char *nasm_strndup_log(const char *, int, const char *, size_t); * NASM assert failure */ no_return nasm_assert_failed(const char *, int, const char *); -#define nasm_assert(x) \ - do { \ - if (unlikely(!(x))) \ - nasm_assert_failed(__FILE__,__LINE__,#x); \ +#define nasm_assert(x) \ + do { \ + if (unlikely(!(x))) \ + nasm_assert_failed(__FILE__,__LINE__,#x); \ } while (0) /* @@ -243,11 +243,11 @@ void standard_extension(char *inname, char *outname, char *extension); * list_for_each - regular iterator over list * list_for_each_safe - the same but safe against list items removal */ -#define list_for_each(pos, head) \ - for (pos = head; pos; pos = pos->next) -#define list_for_each_safe(pos, n, head) \ - for (pos = head, n = (pos ? pos->next : NULL); pos; \ - pos = n, n = (n ? n->next : NULL)) +#define list_for_each(pos, head) \ + for (pos = head; pos; pos = pos->next) +#define list_for_each_safe(pos, n, head) \ + for (pos = head, n = (pos ? pos->next : NULL); pos; \ + pos = n, n = (n ? n->next : NULL)) /* * some handy macros that will probably be of use in more than one @@ -257,90 +257,90 @@ void standard_extension(char *inname, char *outname, char *extension); #if X86_MEMORY -#define WRITECHAR(p,v) \ - do { \ - *(uint8_t *)(p) = (v); \ - (p) += 1; \ +#define WRITECHAR(p,v) \ + do { \ + *(uint8_t *)(p) = (v); \ + (p) += 1; \ } while (0) -#define WRITESHORT(p,v) \ - do { \ - *(uint16_t *)(p) = (v); \ - (p) += 2; \ +#define WRITESHORT(p,v) \ + do { \ + *(uint16_t *)(p) = (v); \ + (p) += 2; \ } while (0) -#define WRITELONG(p,v) \ - do { \ - *(uint32_t *)(p) = (v); \ - (p) += 4; \ +#define WRITELONG(p,v) \ + do { \ + *(uint32_t *)(p) = (v); \ + (p) += 4; \ } while (0) -#define WRITEDLONG(p,v) \ - do { \ - *(uint64_t *)(p) = (v); \ - (p) += 8; \ +#define WRITEDLONG(p,v) \ + do { \ + *(uint64_t *)(p) = (v); \ + (p) += 8; \ } while (0) -#define WRITEADDR(p,v,s) \ - do { \ - uint64_t _wa_v = (v); \ - memcpy((p), &_wa_v, (s)); \ - (p) += (s); \ +#define WRITEADDR(p,v,s) \ + do { \ + uint64_t _wa_v = (v); \ + memcpy((p), &_wa_v, (s)); \ + (p) += (s); \ } while (0) #else /* !X86_MEMORY */ -#define WRITECHAR(p,v) \ - do { \ - uint8_t *_wc_p = (uint8_t *)(p); \ - uint8_t _wc_v = (v); \ - _wc_p[0] = _wc_v; \ - (p) = (void *)(_wc_p + 1); \ +#define WRITECHAR(p,v) \ + do { \ + uint8_t *_wc_p = (uint8_t *)(p); \ + uint8_t _wc_v = (v); \ + _wc_p[0] = _wc_v; \ + (p) = (void *)(_wc_p + 1); \ } while (0) -#define WRITESHORT(p,v) \ - do { \ - uint8_t *_ws_p = (uint8_t *)(p); \ - uint16_t _ws_v = (v); \ - _ws_p[0] = _ws_v; \ - _ws_p[1] = _ws_v >> 8; \ - (p) = (void *)(_ws_p + 2); \ +#define WRITESHORT(p,v) \ + do { \ + uint8_t *_ws_p = (uint8_t *)(p); \ + uint16_t _ws_v = (v); \ + _ws_p[0] = _ws_v; \ + _ws_p[1] = _ws_v >> 8; \ + (p) = (void *)(_ws_p + 2); \ } while (0) -#define WRITELONG(p,v) \ - do { \ - uint8_t *_wl_p = (uint8_t *)(p); \ - uint32_t _wl_v = (v); \ - _wl_p[0] = _wl_v; \ - _wl_p[1] = _wl_v >> 8; \ - _wl_p[2] = _wl_v >> 16; \ - _wl_p[3] = _wl_v >> 24; \ - (p) = (void *)(_wl_p + 4); \ +#define WRITELONG(p,v) \ + do { \ + uint8_t *_wl_p = (uint8_t *)(p); \ + uint32_t _wl_v = (v); \ + _wl_p[0] = _wl_v; \ + _wl_p[1] = _wl_v >> 8; \ + _wl_p[2] = _wl_v >> 16; \ + _wl_p[3] = _wl_v >> 24; \ + (p) = (void *)(_wl_p + 4); \ } while (0) -#define WRITEDLONG(p,v) \ - do { \ - uint8_t *_wq_p = (uint8_t *)(p); \ - uint64_t _wq_v = (v); \ - _wq_p[0] = _wq_v; \ - _wq_p[1] = _wq_v >> 8; \ - _wq_p[2] = _wq_v >> 16; \ - _wq_p[3] = _wq_v >> 24; \ - _wq_p[4] = _wq_v >> 32; \ - _wq_p[5] = _wq_v >> 40; \ - _wq_p[6] = _wq_v >> 48; \ - _wq_p[7] = _wq_v >> 56; \ - (p) = (void *)(_wq_p + 8); \ +#define WRITEDLONG(p,v) \ + do { \ + uint8_t *_wq_p = (uint8_t *)(p); \ + uint64_t _wq_v = (v); \ + _wq_p[0] = _wq_v; \ + _wq_p[1] = _wq_v >> 8; \ + _wq_p[2] = _wq_v >> 16; \ + _wq_p[3] = _wq_v >> 24; \ + _wq_p[4] = _wq_v >> 32; \ + _wq_p[5] = _wq_v >> 40; \ + _wq_p[6] = _wq_v >> 48; \ + _wq_p[7] = _wq_v >> 56; \ + (p) = (void *)(_wq_p + 8); \ } while (0) -#define WRITEADDR(p,v,s) \ - do { \ - int _wa_s = (s); \ - uint64_t _wa_v = (v); \ - while (_wa_s--) { \ - WRITECHAR(p,_wa_v); \ - _wa_v >>= 8; \ - } \ +#define WRITEADDR(p,v,s) \ + do { \ + int _wa_s = (s); \ + uint64_t _wa_v = (v); \ + while (_wa_s--) { \ + WRITECHAR(p,_wa_v); \ + _wa_v >>= 8; \ + } \ } while(0) #endif @@ -379,7 +379,7 @@ char *nasm_strcat(const char *one, const char *two); const char *prefix_name(int); -#define ZERO_BUF_SIZE 4096 +#define ZERO_BUF_SIZE 4096 extern const uint8_t zero_buffer[ZERO_BUF_SIZE]; size_t fwritezero(size_t bytes, FILE *fp); -- 2.34.1