summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--generic/tclCompCmds.c4
-rw-r--r--generic/tclDictObj.c2
-rw-r--r--generic/tclEvent.c2
-rw-r--r--generic/tclFCmd.c2
-rw-r--r--generic/tclHistory.c8
-rw-r--r--generic/tclParse.c2
-rw-r--r--generic/tclStrToD.c198
-rw-r--r--generic/tclStringObj.c4
-rw-r--r--generic/tclThreadStorage.c12
-rw-r--r--generic/tclUtil.c50
-rw-r--r--unix/tclUnixNotfy.c2
11 files changed, 143 insertions, 143 deletions
diff --git a/generic/tclCompCmds.c b/generic/tclCompCmds.c
index 106c293..3b234b0 100644
--- a/generic/tclCompCmds.c
+++ b/generic/tclCompCmds.c
@@ -5913,7 +5913,7 @@ TclCompileGlobalCmd(
return TCL_ERROR;
}
- /* TODO: Consider what values can pass through the
+ /* TODO: Consider what values can pass through the
* IndexTailVarIfKnown() screen. Full CompileWord()
* likely does not apply here. Push known value instead. */
CompileWord(envPtr, varTokenPtr, interp, i);
@@ -5988,7 +5988,7 @@ TclCompileVariableCmd(
return TCL_ERROR;
}
- /* TODO: Consider what values can pass through the
+ /* TODO: Consider what values can pass through the
* IndexTailVarIfKnown() screen. Full CompileWord()
* likely does not apply here. Push known value instead. */
CompileWord(envPtr, varTokenPtr, interp, i);
diff --git a/generic/tclDictObj.c b/generic/tclDictObj.c
index 4adc5ce..4fec2c1 100644
--- a/generic/tclDictObj.c
+++ b/generic/tclDictObj.c
@@ -593,7 +593,7 @@ SetDictFromAny(
}
for (i=0 ; i<objc ; i+=2) {
-
+
/* Store key and value in the hash table we're building. */
hPtr = CreateChainEntry(dict, objv[i], &isNew);
if (!isNew) {
diff --git a/generic/tclEvent.c b/generic/tclEvent.c
index dec8289..c664b38 100644
--- a/generic/tclEvent.c
+++ b/generic/tclEvent.c
@@ -418,7 +418,7 @@ TclDefaultBgErrorHandlerObjCmd(
*/
saved = Tcl_SaveInterpState(interp, code);
-
+
/* Invoke the bgerror command. */
Tcl_AllowExceptions(interp);
code = Tcl_EvalObjv(interp, 2, tempObjv, TCL_EVAL_GLOBAL);
diff --git a/generic/tclFCmd.c b/generic/tclFCmd.c
index 93ccfd7..c52cd1e 100644
--- a/generic/tclFCmd.c
+++ b/generic/tclFCmd.c
@@ -743,7 +743,7 @@ CopyRenameOneFile(
errfile = target;
}
- /*
+ /*
* We now need to reset the result, because the above call,
* may have left set it. (Ideally we would prefer not to pass
* an interpreter in above, but the channel IO code used by
diff --git a/generic/tclHistory.c b/generic/tclHistory.c
index a23e102..97cbdcd 100644
--- a/generic/tclHistory.c
+++ b/generic/tclHistory.c
@@ -129,22 +129,22 @@ Tcl_RecordAndEvalObj(
if (call) {
/*
- * Do recording by eval'ing a tcl history command: history add $cmd.
+ * Do recording by eval'ing a tcl history command: history add $cmd.
*/
TclNewLiteralStringObj(list[0], "history");
TclNewLiteralStringObj(list[1], "add");
list[2] = cmdPtr;
-
+
objPtr = Tcl_NewListObj(3, list);
Tcl_IncrRefCount(objPtr);
(void) Tcl_EvalObjEx(interp, objPtr, TCL_EVAL_GLOBAL);
Tcl_DecrRefCount(objPtr);
-
+
/*
* One possible failure mode above: exceeding a resource limit.
*/
-
+
if (Tcl_LimitExceeded(interp)) {
return TCL_ERROR;
}
diff --git a/generic/tclParse.c b/generic/tclParse.c
index c07336f..b40b636 100644
--- a/generic/tclParse.c
+++ b/generic/tclParse.c
@@ -518,7 +518,7 @@ Tcl_ParseCommand(
listStart = nextElem = tokenPtr[1].start;
while (nextElem < listEnd) {
int quoted;
-
+
tokenPtr->type = TCL_TOKEN_SIMPLE_WORD;
tokenPtr->numComponents = 1;
diff --git a/generic/tclStrToD.c b/generic/tclStrToD.c
index ec5e764..cff9bdd 100644
--- a/generic/tclStrToD.c
+++ b/generic/tclStrToD.c
@@ -64,7 +64,7 @@ typedef unsigned int fpu_control_t __attribute__ ((__mode__ (__HI__)));
/*
* MIPS floating-point units need special settings in control registers
* to use gradual underflow as we expect. This fix is for the MIPSpro
- * compiler.
+ * compiler.
*/
#if defined(__sgi) && defined(_COMPILER_VERSION)
#include <sys/fpu.h>
@@ -102,7 +102,7 @@ typedef unsigned int fpu_control_t __attribute__ ((__mode__ (__HI__)));
/* Mask for the exponent field in the
* first word of a double */
#define EXP_SHIFT 20
- /* Shift count to make the exponent an
+ /* Shift count to make the exponent an
* integer */
#define HIDDEN_BIT (((Tcl_WideUInt) 0x00100000) << 32)
/* Hidden 1 bit for the significand */
@@ -263,7 +263,7 @@ static const Tcl_WideUInt wuipow5[27] = {
* Static functions defined in this file.
*/
-static int AccumulateDecimalDigit(unsigned, int,
+static int AccumulateDecimalDigit(unsigned, int,
Tcl_WideUInt *, mp_int *, int);
static double MakeHighPrecisionDouble(int signum,
mp_int *significand, int nSigDigs, int exponent);
@@ -286,7 +286,7 @@ static void ComputeScale(int, int, int*, int*, int*, int*);
static void SetPrecisionLimits(int, int, int*, int*, int*, int*);
static char* BumpUp(char*, char*, int*);
static int AdjustRange(double*, int);
-static char* ShorteningQuickFormat(double, int, int, double,
+static char* ShorteningQuickFormat(double, int, int, double,
char*, int*);
static char* StrictQuickFormat(double, int, int, double,
char*, int*);
@@ -302,15 +302,15 @@ static char* StrictInt64Conversion(Double*, int, Tcl_WideUInt,
static int ShouldBankerRoundUpPowD(mp_int*, int, int);
static int ShouldBankerRoundUpToNextPowD(mp_int*, mp_int*,
int, int, int, mp_int*);
-static char* ShorteningBignumConversionPowD(Double* dPtr,
+static char* ShorteningBignumConversionPowD(Double* dPtr,
int convType, Tcl_WideUInt bw, int b2, int b5,
int m2plus, int m2minus, int m5,
- int sd, int k, int len,
+ int sd, int k, int len,
int ilim, int ilim1, int* decpt,
char** endPtr);
static char* StrictBignumConversionPowD(Double* dPtr, int convType,
Tcl_WideUInt bw, int b2, int b5,
- int sd, int k, int len,
+ int sd, int k, int len,
int ilim, int ilim1, int* decpt,
char** endPtr);
static int ShouldBankerRoundUp(mp_int*, mp_int*, int);
@@ -319,12 +319,12 @@ static int ShouldBankerRoundUpToNext(mp_int*, mp_int*, mp_int*,
static char* ShorteningBignumConversion(Double* dPtr, int convType,
Tcl_WideUInt bw, int b2,
int m2plus, int m2minus,
- int s2, int s5, int k, int len,
+ int s2, int s5, int k, int len,
int ilim, int ilim1, int* decpt,
char** endPtr);
static char* StrictBignumConversion(Double* dPtr, int convType,
Tcl_WideUInt bw, int b2,
- int s2, int s5, int k, int len,
+ int s2, int s5, int k, int len,
int ilim, int ilim1, int* decpt,
char** endPtr);
static double BignumToBiasedFrExp(mp_int *big, int *machexp);
@@ -1905,7 +1905,7 @@ RefineApproximation(
if ((rteSigWide & 1) == 0) {
return approxResult;
}
- }
+ }
/*
* Convert the numerator and denominator of the corrector term accurately
@@ -1994,7 +1994,7 @@ NormalizeRightward(Tcl_WideUInt* wPtr)
Tcl_WideUInt w = *wPtr;
if (!(w & (Tcl_WideUInt) 0xffffffff)) {
w >>= 32; rv += 32;
- }
+ }
if (!(w & (Tcl_WideUInt) 0xffff)) {
w >>= 16; rv += 16;
}
@@ -2145,7 +2145,7 @@ TakeAbsoluteValue(Double* d, /* Number to replace with absolute value */
*
* Side effects:
* Stores 9999 in *decpt, and sets '*endPtr' to designate the
- * terminating NUL byte of the string if 'endPtr' is not NULL.
+ * terminating NUL byte of the string if 'endPtr' is not NULL.
*
* The string returned must be freed by the caller using 'ckfree'.
*
@@ -2233,8 +2233,8 @@ ApproximateLog10(Tcl_WideUInt bw,
/*
* Compute i and d2 such that d = d2*2**i, and 1 < d2 < 2.
- * Compute an approximation to log10(d),
- * log10(d) ~ log10(2) * i + log10(1.5)
+ * Compute an approximation to log10(d),
+ * log10(d) ~ log10(2) * i + log10(1.5)
* + (significand-1.5)/(1.5 * log(10))
*/
@@ -2274,7 +2274,7 @@ BetterLog10(double d, /* Original number to format */
int k, /* Characteristic(Log base 10) of the number */
int* k_check) /* Flag == 1 if k is inexact */
{
- /*
+ /*
* Performance hack. If k is in the range 0..TEN_PMAX, then we can
* use a powers-of-ten table to check it.
*/
@@ -2318,7 +2318,7 @@ ComputeScale(int be, /* Exponent part of number: d = bw * 2**be */
int* s5) /* OUTPUT: Power of 5 in the denominator */
{
- /*
+ /*
* Scale numerator and denominator powers of 2 so that the
* input binary number is the ratio of integers
*/
@@ -2330,7 +2330,7 @@ ComputeScale(int be, /* Exponent part of number: d = bw * 2**be */
*s2 = 0;
}
- /*
+ /*
* Scale numerator and denominator so that the output decimal number
* is the ratio of integers
*/
@@ -2438,7 +2438,7 @@ SetPrecisionLimits(int convType,
inline static char*
BumpUp(char* s, /* Cursor pointing one past the end of the
- * string */
+ * string */
char* retval, /* Start of the string of digits */
int* kPtr) /* Position of the decimal point */
{
@@ -2527,7 +2527,7 @@ AdjustRange(double* dPtr, /* INOUT: Number to adjust */
*
* Returns a 'quick' format of a double precision number to a string
* of digits, preferring a shorter string of digits if the shorter
- * string is still within 1/2 ulp of the number.
+ * string is still within 1/2 ulp of the number.
*
* Results:
* Returns the string of digits. Returns NULL if the 'quick' method
@@ -2638,7 +2638,7 @@ StrictQuickFormat(double d, /* Number to convert */
}
*s++ = '0' + digit;
- /*
+ /*
* When the given digit count is reached, handle trailing strings
* of 0 and 9.
*/
@@ -2852,13 +2852,13 @@ ShorteningInt64Conversion(Double* dPtr,
/* OUTPUT: Position of the terminal '\0'
* at the end of the returned string */
{
-
+
char* retval = ckalloc(len + 1);
/* Output buffer */
Tcl_WideUInt b = (bw * wuipow5[b5]) << b2;
/* Numerator of the fraction being converted */
Tcl_WideUInt S = wuipow5[s5] << s2;
- /* Denominator of the fraction being
+ /* Denominator of the fraction being
* converted */
Tcl_WideUInt mplus, mminus; /* Ranges for testing whether the result
* is within roundoff of being exact */
@@ -2890,7 +2890,7 @@ ShorteningInt64Conversion(Double* dPtr,
}
b = b % S;
- /*
+ /*
* Does the current digit put us on the low side of the exact value
* but within within roundoff of being exact?
*/
@@ -2948,16 +2948,16 @@ ShorteningInt64Conversion(Double* dPtr,
}
break;
}
-
+
/* Advance to the next digit */
-
+
b = 10 * b;
mplus = 10 * mplus;
mminus = 10 * mminus;
++i;
}
- /*
+ /*
* Endgame - store the location of the decimal point and the end of the
* string.
*/
@@ -3020,13 +3020,13 @@ StrictInt64Conversion(Double* dPtr,
/* OUTPUT: Position of the terminal '\0'
* at the end of the returned string */
{
-
+
char* retval = ckalloc(len + 1);
/* Output buffer */
Tcl_WideUInt b = (bw * wuipow5[b5]) << b2;
/* Numerator of the fraction being converted */
Tcl_WideUInt S = wuipow5[s5] << s2;
- /* Denominator of the fraction being
+ /* Denominator of the fraction being
* converted */
int digit; /* Current output digit */
char* s = retval; /* Cursor in the output buffer */
@@ -3066,14 +3066,14 @@ StrictInt64Conversion(Double* dPtr,
}
break;
}
-
+
/* Advance to the next digit */
-
+
b = 10 * b;
++i;
}
- /*
+ /*
* Endgame - store the location of the decimal point and the end of the
* string.
*/
@@ -3144,10 +3144,10 @@ ShouldBankerRoundUpToNextPowD(mp_int* b,
/* Numerator of the fraction */
mp_int* m,
/* Numerator of the rounding tolerance */
- int sd,
+ int sd,
/* Common denominator is 2**(sd*DIGIT_BIT) */
int convType,
- /* Conversion type: STEELE defeats
+ /* Conversion type: STEELE defeats
* round-to-even (Not sure why one wants to
* do this; I copied it from Gay) FIXME */
int isodd,
@@ -3157,7 +3157,7 @@ ShouldBankerRoundUpToNextPowD(mp_int* b,
{
int i;
- /*
+ /*
* Compare B and S-m -- which is the same as comparing B+m and S --
* which we do by computing b+m and doing a bitwhack compare against
* 2**(DIGIT_BIT*sd)
@@ -3238,7 +3238,7 @@ ShorteningBignumConversionPowD(Double* dPtr,
/* OUTPUT: Position of the terminal '\0'
* at the end of the returned string */
{
-
+
char* retval = ckalloc(len + 1);
/* Output buffer */
mp_int b; /* Numerator of the fraction being converted */
@@ -3249,7 +3249,7 @@ ShorteningBignumConversionPowD(Double* dPtr,
mp_int temp;
int r1;
- /*
+ /*
* b = bw * 2**b2 * 5**b5
* mminus = 5**m5
*/
@@ -3296,11 +3296,11 @@ ShorteningBignumConversionPowD(Double* dPtr,
--b.used; mp_clamp(&b);
}
- /*
+ /*
* Does the current digit put us on the low side of the exact value
* but within within roundoff of being exact?
*/
-
+
r1 = mp_cmp_mag(&b, (m2plus > m2minus)? &mplus : &mminus);
if (r1 == MP_LT
|| (r1 == MP_EQ
@@ -3329,8 +3329,8 @@ ShorteningBignumConversionPowD(Double* dPtr,
* Does one plus the current digit put us within roundoff of the
* number?
*/
-
- if (ShouldBankerRoundUpToNextPowD(&b, &mminus, sd,
+
+ if (ShouldBankerRoundUpToNextPowD(&b, &mminus, sd,
convType, dPtr->w.word1 & 1,
&temp)) {
if (digit == 9) {
@@ -3353,9 +3353,9 @@ ShorteningBignumConversionPowD(Double* dPtr,
}
break;
}
-
+
/* Advance to the next digit */
-
+
mp_mul_d(&b, 10, &b);
mp_mul_d(&mminus, 10, &mminus);
if (m2plus > m2minus) {
@@ -3364,7 +3364,7 @@ ShorteningBignumConversionPowD(Double* dPtr,
++i;
}
- /*
+ /*
* Endgame - store the location of the decimal point and the end of the
* string.
*/
@@ -3388,7 +3388,7 @@ ShorteningBignumConversionPowD(Double* dPtr,
* Converts a double-precision number to a fixed-lengt string of
* 'ilim' digits (or 'ilim1' if log10(d) has been overestimated.)
* The denominator in David Gay's conversion algorithm is known to
- * be a power of 2**DIGIT_BIT, and hence the division in the main
+ * be a power of 2**DIGIT_BIT, and hence the division in the main
* loop may be replaced by a digit shift and mask.
*
* Results:
@@ -3430,7 +3430,7 @@ StrictBignumConversionPowD(Double* dPtr,
/* OUTPUT: Position of the terminal '\0'
* at the end of the returned string */
{
-
+
char* retval = ckalloc(len + 1);
/* Output buffer */
mp_int b; /* Numerator of the fraction being converted */
@@ -3439,7 +3439,7 @@ StrictBignumConversionPowD(Double* dPtr,
int i; /* Index in the output buffer */
mp_int temp;
- /*
+ /*
* b = bw * 2**b2 * 5**b5
*/
@@ -3456,9 +3456,9 @@ StrictBignumConversionPowD(Double* dPtr,
}
mp_init(&temp);
- /*
+ /*
* Loop through the digits. Do division and mod by s == 2**(sd*DIGIT_BIT)
- * by mp_digit extraction
+ * by mp_digit extraction
*/
i = 1;
@@ -3488,14 +3488,14 @@ StrictBignumConversionPowD(Double* dPtr,
}
break;
}
-
+
/* Advance to the next digit */
-
+
mp_mul_d(&b, 10, &b);
++i;
}
- /*
+ /*
* Endgame - store the location of the decimal point and the end of the
* string.
*/
@@ -3592,7 +3592,7 @@ ShouldBankerRoundUpToNext(mp_int* b,
Tcl_Panic("in ShouldBankerRoundUpToNext, trichotomy fails!");
return 0;
}
-
+
/*
*-----------------------------------------------------------------------------
*
@@ -3662,10 +3662,10 @@ ShorteningBignumConversion(Double* dPtr,
MulPow5(&S, s5, &S); mp_mul_2d(&S, s2, &S);
/*
- * Handle the case where we guess the position of the decimal point
- * wrong.
+ * Handle the case where we guess the position of the decimal point
+ * wrong.
*/
-
+
if (mp_cmp_mag(&b, &S) == MP_LT) {
mp_mul_d(&b, 10, &b);
minit = 10;
@@ -3694,7 +3694,7 @@ ShorteningBignumConversion(Double* dPtr,
}
digit = dig.dp[0];
- /*
+ /*
* Does the current digit leave us with a remainder small enough to
* round to it?
*/
@@ -3740,7 +3740,7 @@ ShorteningBignumConversion(Double* dPtr,
if (i == ilim) {
mp_mul_2d(&b, 1, &b);
if (ShouldBankerRoundUp(&b, &S, digit&1)) {
- s = BumpUp(s, retval, &k);
+ s = BumpUp(s, retval, &k);
}
break;
}
@@ -3757,7 +3757,7 @@ ShorteningBignumConversion(Double* dPtr,
}
mp_div_d(&S, 5, &S, NULL);
--s5;
- /*
+ /*
* IDEA: It might possibly be a win to fall back to
* int64 arithmetic here if S < 2**64/10. But it's
* a win only for a fairly narrow range of magnitudes
@@ -3767,7 +3767,7 @@ ShorteningBignumConversion(Double* dPtr,
* Possible savings:
* 10**26 1 trip through loop before fallback possible
* 10**27 1 trip
- * 10**28 2 trips
+ * 10**28 2 trips
* 10**29 3 trips
* 10**30 4 trips
* 10**31 5 trips
@@ -3796,7 +3796,7 @@ ShorteningBignumConversion(Double* dPtr,
}
- /*
+ /*
* Endgame - store the location of the decimal point and the end of the
* string.
*/
@@ -3812,7 +3812,7 @@ ShorteningBignumConversion(Double* dPtr,
return retval;
}
-
+
/*
*-----------------------------------------------------------------------------
*
@@ -3862,7 +3862,7 @@ StrictBignumConversion(Double* dPtr,
mp_int temp; /* Work area */
int g; /* Size of the current digit groun */
int i, j;
-
+
/*
* b = bw * 2**b2 * 5**b5
* S = 2**s2 * 5*s5
@@ -3875,10 +3875,10 @@ StrictBignumConversion(Double* dPtr,
MulPow5(&S, s5, &S); mp_mul_2d(&S, s2, &S);
/*
- * Handle the case where we guess the position of the decimal point
- * wrong.
+ * Handle the case where we guess the position of the decimal point
+ * wrong.
*/
-
+
if (mp_cmp_mag(&b, &S) == MP_LT) {
mp_mul_d(&b, 10, &b);
ilim =ilim1;
@@ -3900,7 +3900,7 @@ StrictBignumConversion(Double* dPtr,
if (++i >= ilim) {
mp_mul_2d(&b, 1, &b);
if (ShouldBankerRoundUp(&b, &S, digit&1)) {
- s = BumpUp(s, retval, &k);
+ s = BumpUp(s, retval, &k);
}
} else {
@@ -3923,7 +3923,7 @@ StrictBignumConversion(Double* dPtr,
mp_mul_d(&b, dpow5[g], &b);
}
mp_mul_2d(&b, g, &b);
-
+
/*
* As with the shortening bignum conversion, it's possible at
* this point that we will have reduced the denominator to
@@ -3936,7 +3936,7 @@ StrictBignumConversion(Double* dPtr,
*/
/* Extract the next group of digits */
-
+
mp_div(&b, &S, &dig, &b);
if (dig.used > 1) {
Tcl_Panic("wrong digit!");
@@ -3948,24 +3948,24 @@ StrictBignumConversion(Double* dPtr,
digit %= t;
}
i += g;
-
+
/* Have we converted all the requested digits? */
-
+
if (i == ilim) {
mp_mul_2d(&b, 1, &b);
if (ShouldBankerRoundUp(&b, &S, digit&1)) {
- s = BumpUp(s, retval, &k);
+ s = BumpUp(s, retval, &k);
} else {
while (*--s == '0') {
/* do nothing */
}
++s;
- }
+ }
break;
}
}
}
- /*
+ /*
* Endgame - store the location of the decimal point and the end of the
* string.
*/
@@ -4009,7 +4009,7 @@ StrictBignumConversion(Double* dPtr,
* TCL_DD_STEELE - This value is not recommended and may be removed
* in the future. It follows the conversion algorithm outlined
* in "How to Print Floating-Point Numbers Accurately" by
- * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90,
+ * Guy L. Steele, Jr. and Jon L. White [Proc. ACM SIGPLAN '90,
* pp. 112-126]. This rule has the effect of rendering 1e23
* as 9.9999999999999999e22 - which is a 'better' approximation
* in the sense that it will reconvert correctly even if
@@ -4021,14 +4021,14 @@ StrictBignumConversion(Double* dPtr,
* 'ndigits' digits, choosing the one that is closest to the
* given number (and resolving ties with 'round to even').
* It is allowed to return fewer than 'ndigits' if the number
- * converts exactly; if the TCL_DD_E_FORMAT|TCL_DD_SHORTEN_FLAG
- * is supplied instead, it also returns fewer digits if the
+ * converts exactly; if the TCL_DD_E_FORMAT|TCL_DD_SHORTEN_FLAG
+ * is supplied instead, it also returns fewer digits if the
* shorter string will still reconvert to the given input number.
* In any case, strings of trailing zeroes are suppressed.
* TCL_DD_F_FORMAT - This value is used to prepare numbers for %f
* format conversion. It requests that conversion proceed until
* 'ndigits' digits after the decimal point have been converted.
- * It is possible for this format to result in a zero-length
+ * It is possible for this format to result in a zero-length
* string if the number is sufficiently small. Again, it
* is permissible for TCL_DD_F_FORMAT to return fewer digits
* for a number that converts exactly, and changing the
@@ -4045,12 +4045,12 @@ StrictBignumConversion(Double* dPtr,
* midpoint between two decimal strings that more precision is needed
* to resolve which string is correct.
*
- * The value stored in the 'decpt' argument on return may be negative
- * (indicating that the decimal point falls to the left of the string)
+ * The value stored in the 'decpt' argument on return may be negative
+ * (indicating that the decimal point falls to the left of the string)
* or greater than the length of the string. In addition, the value -9999
* is used as a sentinel to indicate that the string is one of the special
* values "Infinity" and "NaN", and that no decimal point should be inserted.
- *
+ *
*-----------------------------------------------------------------------------
*/
char*
@@ -4076,12 +4076,12 @@ TclDoubleDigits(double dv, /* Number to convert */
int denorm; /* Flag == 1 iff the input number was
* denormalized */
int k; /* Estimate of floor(log10(d)) */
- int k_check; /* Flag == 1 if d is near enough to a
+ int k_check; /* Flag == 1 if d is near enough to a
* power of ten that k must be checked */
int b2, b5, s2, s5; /* Powers of 2 and 5 in the numerator and
* denominator of intermediate results */
int ilim = -1, ilim1 = -1; /* Number of digits to convert, and number
- * to convert if log10(d) has been
+ * to convert if log10(d) has been
* overestimated */
char* retval; /* Return value from this function */
int i = -1;
@@ -4090,7 +4090,7 @@ TclDoubleDigits(double dv, /* Number to convert */
d.d = dv;
- /*
+ /*
* Handle the cases of negative numbers (by taking the absolute value:
* this includes -Inf and -NaN!), infinity, Not a Number, and zero.
*/
@@ -4103,7 +4103,7 @@ TclDoubleDigits(double dv, /* Number to convert */
return FormatZero(decpt, endPtr);
}
- /*
+ /*
* Unpack the floating point into a wide integer and an exponent.
* Determine the number of bits that the big integer requires, and
* compute a quick approximation (which may be one too high) of
@@ -4116,12 +4116,12 @@ TclDoubleDigits(double dv, /* Number to convert */
/* At this point, we have:
* d is the number to convert.
- * bw are significand and exponent: d == bw*2**be,
+ * bw are significand and exponent: d == bw*2**be,
* bbits is the length of bw: 2**bbits-1 <= bw < 2**bbits
* k is either ceil(log10(d)) or ceil(log10(d))+1. k_check is 0
* if we know that k is exactly ceil(log10(d)) and 1 if we need to
* check.
- * We want a rational number
+ * We want a rational number
* r = b * 10**(1-k) = bw * 2**b2 * 5**b5 / (2**s2 / 5**s5),
* with b2, b5, s2, s5 >= 0. Note that the most significant decimal
* digit is floor(r) and that successive digits can be obtained
@@ -4149,7 +4149,7 @@ TclDoubleDigits(double dv, /* Number to convert */
SetPrecisionLimits(convType, k, &ndigits, &i, &ilim, &ilim1);
- /*
+ /*
* Try to do low-precision conversion in floating point rather
* than resorting to expensive multiprecision arithmetic
*/
@@ -4161,7 +4161,7 @@ TclDoubleDigits(double dv, /* Number to convert */
}
}
- /*
+ /*
* For shortening conversions, determine the upper and lower bounds
* for the remainder at which we can stop.
* m+ = (2**m2plus * 5**m5) / (2**s2 * 5**s5) is the limit on the
@@ -4178,9 +4178,9 @@ TclDoubleDigits(double dv, /* Number to convert */
int m5 = b5;
int len = i;
- /*
+ /*
* Find the quantity i so that (2**i*5**b5)/(2**s2*5**s5)
- * is 1/2 unit in the least significant place of the floating
+ * is 1/2 unit in the least significant place of the floating
* point number.
*/
if (denorm) {
@@ -4191,7 +4191,7 @@ TclDoubleDigits(double dv, /* Number to convert */
b2 += i;
s2 += i;
- /*
+ /*
* Reduce the fractions to lowest terms, since the above calculation
* may have left excess powers of 2 in numerator and denominator
*/
@@ -4220,7 +4220,7 @@ TclDoubleDigits(double dv, /* Number to convert */
return ShorteningInt64Conversion(&d, convType, bw, b2, b5,
m2plus, m2minus, m5,
- s2, s5, k, len, ilim, ilim1,
+ s2, s5, k, len, ilim, ilim1,
decpt, endPtr);
} else if (s5 == 0) {
/*
@@ -4239,11 +4239,11 @@ TclDoubleDigits(double dv, /* Number to convert */
}
return ShorteningBignumConversionPowD(&d, convType, bw, b2, b5,
m2plus, m2minus, m5,
- s2/DIGIT_BIT, k, len,
+ s2/DIGIT_BIT, k, len,
ilim, ilim1, decpt, endPtr);
} else {
- /*
+ /*
* Alas, there's no helpful special case; use full-up
* bignum arithmetic for the conversion
*/
@@ -4279,7 +4279,7 @@ TclDoubleDigits(double dv, /* Number to convert */
*/
return StrictInt64Conversion(&d, convType, bw, b2, b5,
- s2, s5, k, len, ilim, ilim1,
+ s2, s5, k, len, ilim, ilim1,
decpt, endPtr);
} else if (s5 == 0) {
@@ -4296,7 +4296,7 @@ TclDoubleDigits(double dv, /* Number to convert */
s2 += delta;
}
return StrictBignumConversionPowD(&d, convType, bw, b2, b5,
- s2/DIGIT_BIT, k, len,
+ s2/DIGIT_BIT, k, len,
ilim, ilim1, decpt, endPtr);
} else {
/*
@@ -4308,7 +4308,7 @@ TclDoubleDigits(double dv, /* Number to convert */
return StrictBignumConversion(&d, convType, bw, b2, s2, s5,
k, len, ilim, ilim1, decpt, endPtr);
}
- }
+ }
}
@@ -4558,7 +4558,7 @@ TclBignumToDouble(
/*
- * We need a 'mantBits'-bit significand. Determine what shift will
+ * We need a 'mantBits'-bit significand. Determine what shift will
* give us that.
*/
@@ -4573,7 +4573,7 @@ TclBignumToDouble(
}
shift = mantBits - bits;
- /*
+ /*
* If shift > 0, shift the significand left by the requisite number of
* bits. If shift == 0, the significand is already exactly 'mantBits'
* in length. If shift < 0, we will need to shift the significand right
diff --git a/generic/tclStringObj.c b/generic/tclStringObj.c
index 8c6a376..86f0c62 100644
--- a/generic/tclStringObj.c
+++ b/generic/tclStringObj.c
@@ -1392,7 +1392,7 @@ AppendUnicodeToUnicodeRep(
+ stringPtr->uallocated / sizeof(Tcl_UniChar)) {
offset = unicode - stringPtr->unicode;
}
-
+
GrowUnicodeBuffer(objPtr, numChars);
stringPtr = GET_STRING(objPtr);
@@ -1575,7 +1575,7 @@ AppendUtfToUtfRep(
unsigned int limit = INT_MAX - newLength;
unsigned int extra = numBytes + TCL_GROWTH_MIN_ALLOC;
int growth = (int) ((extra > limit) ? limit : extra);
-
+
Tcl_SetObjLength(objPtr, newLength + growth);
}
diff --git a/generic/tclThreadStorage.c b/generic/tclThreadStorage.c
index f1df888..1578b40 100644
--- a/generic/tclThreadStorage.c
+++ b/generic/tclThreadStorage.c
@@ -135,7 +135,7 @@ AllocThreadStorageEntry(
hPtr = (Tcl_HashEntry *) TclpSysAlloc(sizeof(Tcl_HashEntry), 0);
hPtr->key.oneWordValue = keyPtr;
hPtr->clientData = NULL;
-
+
return hPtr;
}
@@ -170,7 +170,7 @@ FreeThreadStorageEntry(
* ThreadStorageGetHashTable --
*
* This procedure returns a hash table pointer to be used for thread
- * storage for the specified thread.
+ * storage for the specified thread.
*
* Results:
* A hash table pointer for the specified thread, or NULL if the hash
@@ -182,8 +182,8 @@ FreeThreadStorageEntry(
*
* Thread safety:
* This function assumes that integer operations are safe (atomic)
- * on all (currently) supported Tcl platforms. Hence there are
- * places where shared integer arithmetic is done w/o protective locks.
+ * on all (currently) supported Tcl platforms. Hence there are
+ * places where shared integer arithmetic is done w/o protective locks.
*
*----------------------------------------------------------------------
*/
@@ -205,12 +205,12 @@ ThreadStorageGetHashTable(
* Thread safety: threadStorageCache is accessed w/o locks in order to
* avoid serialization of all threads at this hot-spot. It is safe to
* do this here because (threadStorageCache[index].id != id) test below
- * should be atomic on all (currently) supported platforms and there
+ * should be atomic on all (currently) supported platforms and there
* are no devastatig side effects of the test.
*
* Note Valgrind users: this place will show up as a race-condition in
* helgrind-tool output. To silence this warnings, define VALGRIND
- * symbol at compilation time.
+ * symbol at compilation time.
*/
#if !defined(VALGRIND)
diff --git a/generic/tclUtil.c b/generic/tclUtil.c
index 8c6adfe..69d0b17 100644
--- a/generic/tclUtil.c
+++ b/generic/tclUtil.c
@@ -63,7 +63,7 @@ static ProcessGlobalValue executableName = {
* CONVERT_MASK A mask value used to extract the conversion mode from
* the flags argument.
* Also indicates a strange conversion mode where all
- * special characters are escaped with backslashes
+ * special characters are escaped with backslashes
* *except for braces*. This is a strange and unnecessary
* case, but it's part of the historical way in which
* lists have been formatted in Tcl. To experiment with
@@ -81,7 +81,7 @@ static ProcessGlobalValue executableName = {
* in other cases this means an overestimate of the
* required size.
*
- * For more details, see the comments on the Tcl*Scan*Element and
+ * For more details, see the comments on the Tcl*Scan*Element and
* Tcl*Convert*Element routines.
*/
@@ -171,12 +171,12 @@ Tcl_ObjType tclEndOffsetType = {
* rules similar to the parsing of the words of a command in a Tcl script.
* Backslash substitution plays a key role, and is defined exactly as it is
* in command parsing. The same routine, TclParseBackslash() is used in both
- * command parsing and list parsing.
+ * command parsing and list parsing.
*
* NOTE: This means that if and when backslash substitution rules ever
* change for command parsing, the interpretation of strings as lists also
* changes.
- *
+ *
* Backslash substitution replaces an "escape sequence" of one or more
* characters starting with
* \u005c \ BACKSLASH
@@ -189,7 +189,7 @@ Tcl_ObjType tclEndOffsetType = {
*
* * If the first character of a formatted substring is
* \u007b { OPEN BRACE
- * then the end of the substring is the matching
+ * then the end of the substring is the matching
* \u007d } CLOSE BRACE
* character, where matching is determined by counting nesting levels,
* and not including any brace characters that are contained within a
@@ -211,7 +211,7 @@ Tcl_ObjType tclEndOffsetType = {
* that includes an unbalanced brace not in a backslash escape sequence,
* and any value that ends with a backslash not itself in a backslash
* escape sequence.
- *
+ *
* * If the first character of a formatted substring is
* \u0022 " QUOTE
* then the end of the substring is the next QUOTE character, not counting
@@ -246,7 +246,7 @@ Tcl_ObjType tclEndOffsetType = {
* minimum be able to produce escape sequences for the 10 characters
* identified above that have significance to a list parser.
*
- * * * CANONICAL LISTS * * * * *
+ * * * CANONICAL LISTS * * * * *
*
* In addition to the basic rules for parsing strings into Tcl lists, there
* are additional properties to be met by the set of list values that are
@@ -297,7 +297,7 @@ Tcl_ObjType tclEndOffsetType = {
* This sort of coding was once fairly common, though it's become more
* idiomatic to see the following instead:
* set script [list puts [list $one $two $three]]; eval $script
- * In order to support this guarantee, every canonical list must have
+ * In order to support this guarantee, every canonical list must have
* balance when counting those braces that are not in escape sequences.
*
* Within these constraints, the canonical list generation routines
@@ -339,7 +339,7 @@ Tcl_ObjType tclEndOffsetType = {
* #if COMPAT directives. This makes it easy to experiment with eliminating
* this formatting mode simply with "#define COMPAT 0" above. I believe
* this is worth considering.
- *
+ *
* Another consideration is the treatment of QUOTE characters in list elements.
* TclConvertElement() must have the ability to produce the escape sequence
* \" so that when a list element begins with a QUOTE we do not confuse
@@ -396,7 +396,7 @@ TclMaxListLength(
}
/* No list element before leading white space */
- count += 1 - TclIsSpaceProc(*bytes);
+ count += 1 - TclIsSpaceProc(*bytes);
/* Count white space runs as potential element separators */
while (numBytes) {
@@ -420,7 +420,7 @@ TclMaxListLength(
}
/* No list element following trailing white space */
- count -= TclIsSpaceProc(bytes[-1]);
+ count -= TclIsSpaceProc(bytes[-1]);
done:
if (endPtr) {
@@ -488,7 +488,7 @@ TclFindElement(
* indicate that the substring of *sizePtr
* bytes starting at **elementPtr is/is not
* the literal list element and therefore
- * does not/does require a call to
+ * does not/does require a call to
* TclCopyAndCollapse() by the caller. */
{
CONST char *p = list;
@@ -945,7 +945,7 @@ TclScanElement(
int preferBrace = 0; /* CONVERT_MASK mode. */
int braceCount = 0; /* Count of all braces '{' '}' seen. */
#endif
-
+
if ((p == NULL) || (length == 0) || ((*p == '\0') && (length == -1))) {
/* Empty string element must be brace quoted. */
*flagPtr = CONVERT_BRACE;
@@ -1012,7 +1012,7 @@ TclScanElement(
extra++; /* Escape '\' => '\\' */
if ((length == 1) || ((length == -1) && (p[1] == '\0'))) {
/* Final backslash. Cannot format with brace quoting. */
- requireEscape = 1;
+ requireEscape = 1;
break;
}
if (p[1] == '\n') {
@@ -1087,7 +1087,7 @@ TclScanElement(
if (preferEscape && !preferBrace) {
/*
* If we are quoting solely due to ] or internal " characters
- * use the CONVERT_MASK mode where we escape all special
+ * use the CONVERT_MASK mode where we escape all special
* characters except for braces. "extra" counted space needed
* to escape braces too, so substract "braceCount" to get our
* actual needs.
@@ -1351,7 +1351,7 @@ int TclConvertElement(
if (length == -1) {
return p - dst;
}
- /*
+ /*
* If we reach this point, there's an embedded NULL in the
* string range being processed, which should not happen when
* the encoding rules for Tcl strings are properly followed.
@@ -1417,7 +1417,7 @@ Tcl_Merge(
/*
* We cannot allocate a large enough flag array to format this
* list in one pass. We could imagine converting this routine
- * to a multi-pass implementation, but for sizeof(int) == 4,
+ * to a multi-pass implementation, but for sizeof(int) == 4,
* the limit is a max of 2^30 list elements and since each element
* is at least one byte formatted, and requires one byte space
* between it and the next one, that a minimum space requirement
@@ -1678,7 +1678,7 @@ Tcl_Concat(
}
if (bytesNeeded + argc - 1 < 0) {
/*
- * Panic test could be tighter, but not going to bother for
+ * Panic test could be tighter, but not going to bother for
* this legacy routine.
*/
Tcl_Panic("Tcl_Concat: max size of Tcl value exceeded");
@@ -1689,7 +1689,7 @@ Tcl_Concat(
for (p = result, i = 0; i < argc; i++) {
int trim, elemLength;
const char *element;
-
+
element = argv[i];
elemLength = strlen(argv[i]);
@@ -1827,7 +1827,7 @@ Tcl_ConcatObj(
for (i = 0; i < objc; i++) {
int trim;
-
+
element = TclGetStringFromObj(objv[i], &elemLength);
/* Trim away the leading whitespace */
@@ -2828,7 +2828,7 @@ Tcl_PrintDouble(
/*
* Remember to copy the terminating NUL too.
*/
-
+
if (value < 0) {
memcpy(dst, "-Inf", 5);
} else {
@@ -2885,7 +2885,7 @@ Tcl_PrintDouble(
*/
digits = TclDoubleDigits(value, *precisionPtr,
- TCL_DD_E_FORMAT /* | TCL_DD_SHORTEN_FLAG */,
+ TCL_DD_E_FORMAT /* | TCL_DD_SHORTEN_FLAG */,
&exponent, &signum, &end);
}
if (signum) {
@@ -2896,7 +2896,7 @@ Tcl_PrintDouble(
/*
* E format for numbers < 1e-3 or >= 1e17.
*/
-
+
*dst++ = *p++;
c = *p;
if (c != '\0') {
@@ -2906,7 +2906,7 @@ Tcl_PrintDouble(
c = *++p;
}
}
- /*
+ /*
* Tcl 8.4 appears to format with at least a two-digit exponent; \
* preserve that behaviour when tcl_precision != 0
*/
@@ -2919,7 +2919,7 @@ Tcl_PrintDouble(
/*
* F format for others.
*/
-
+
if (exponent < 0) {
*dst++ = '0';
}
diff --git a/unix/tclUnixNotfy.c b/unix/tclUnixNotfy.c
index 2df704b..a57a89a 100644
--- a/unix/tclUnixNotfy.c
+++ b/unix/tclUnixNotfy.c
@@ -111,7 +111,7 @@ typedef struct ThreadSpecificData {
* event is ready to be processed by signaling
* this condition variable. */
#endif /* __CYGWIN__ */
- int waitCVinitialized; /* Variable to flag initialization of the structure */
+ int waitCVinitialized; /* Variable to flag initialization of the structure */
int eventReady; /* True if an event is ready to be processed.
* Used as condition flag together with waitCV
* above. */