Formatting cleanup to more accurately match the coding standards of

the rest of the core.

1 files changed, 713 insertions, 734 deletions

diff --git a/generic/tclStrToD.c b/generic/tclStrToD.c
index e4d7e18..7c2d6a8 100755
--- a/generic/tclStrToD.c
+++ b/generic/tclStrToD.c
@@ -1,20 +1,20 @@
 /*
  *----------------------------------------------------------------------
  *
- * tclDouble.c --
+ * tclStrToD.c --
  *
- *	This file contains a collection of procedures for managing
- *	conversions to/from floating-point in Tcl.  They include
- *	TclParseNumber, which parses numbers from strings; TclDoubleDigits,
- *	which formats numbers into strings of digits, and procedures for
- *	interconversion among 'double' and 'mp_int' types.
+ *	This file contains a collection of procedures for managing conversions
+ *	to/from floating-point in Tcl. They include TclParseNumber, which
+ *	parses numbers from strings; TclDoubleDigits, which formats numbers
+ *	into strings of digits, and procedures for interconversion among
+ *	'double' and 'mp_int' types.
  *
  * Copyright (c) 2005 by Kevin B. Kenny.  All rights reserved.
  *
- * See the file "license.terms" for information on usage and redistribution
- * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
+ * See the file "license.terms" for information on usage and redistribution of
+ * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tclStrToD.c,v 1.11 2005/10/13 15:15:28 dgp Exp $
+ * RCS: @(#) $Id: tclStrToD.c,v 1.12 2005/10/13 15:23:22 dkf Exp $
  *
  *----------------------------------------------------------------------
  */
@@ -30,8 +30,8 @@
 
 /*
  * Define TIP_114_FORMATS to accept 0b and 0o for binary and octal strings.
- * Define KILL_OCTAL as well as TIP_114_FORMATS to suppress interpretation
- * of numbers with leading zero as octal. (Ceterum censeo: numeros octonarios
+ * Define KILL_OCTAL as well as TIP_114_FORMATS to suppress interpretation of
+ * numbers with leading zero as octal. (Ceterum censeo: numeros octonarios
  * delendos esse.)
  */
 
@@ -43,10 +43,9 @@
 #endif
 
 /*
- * This code supports (at least hypothetically), IBM, Cray, VAX and
- * IEEE-754 floating point; of these, only IEEE-754 can represent NaN.
- * IEEE-754 can be uniquely determined by radix and by the widths of
- * significand and exponent.
+ * This code supports (at least hypothetically), IBM, Cray, VAX and IEEE-754
+ * floating point; of these, only IEEE-754 can represent NaN. IEEE-754 can be
+ * uniquely determined by radix and by the widths of significand and exponent.
  */
 
 #if (FLT_RADIX == 2) && (DBL_MANT_DIG == 53) && (DBL_MAX_EXP == 1024)
@@ -56,9 +55,9 @@
 /*
  * gcc on x86 needs access to rounding controls, because of a questionable
  * feature where it retains intermediate results as IEEE 'long double' values
- * somewhat unpredictably.  It is tempting to include fpu_control.h, but
- * that file exists only on Linux; it is missing on Cygwin and MinGW. Most 
- * gcc-isms and ix86-isms are factored out here.
+ * somewhat unpredictably. It is tempting to include fpu_control.h, but that
+ * file exists only on Linux; it is missing on Cygwin and MinGW. Most gcc-isms
+ * and ix86-isms are factored out here.
  */
 
 #if defined(__GNUC__) && defined(__i386)
@@ -71,7 +70,7 @@ typedef unsigned int fpu_control_t __attribute__ ((__mode__ (__HI__)));
 
 /*
  * HP's PA_RISC architecture uses 7ff4000000000000 to represent a quiet NaN.
- * Everyone else uses 7ff8000000000000.  (Why, HP, why?)
+ * Everyone else uses 7ff8000000000000. (Why, HP, why?)
  */
 
 #ifdef __hppa
@@ -82,26 +81,33 @@ typedef unsigned int fpu_control_t __attribute__ ((__mode__ (__HI__)));
 #   define NAN_MASK (((Tcl_WideUInt) 1) << 51)
 #endif
 
-/* The powers of ten that can be represented exactly as wide integers */
+/*
+ * Constants used by this file (most of which are only ever calculated at
+ * runtime).
+ */
 
-static int maxpow10_wide;
+static int maxpow10_wide;	/* The powers of ten that can be represented
+				 * exactly as wide integers. */
 static Tcl_WideUInt *pow10_wide;
-
-/* The number of decimal digits that fit in an mp_digit */
-
-static int log10_DIGIT_MAX;
-
-/* The powers of ten that can be represented exactly as IEEE754 doubles. */
-
-#define MAXPOW 22
-static double pow10 [MAXPOW+1];
-
+#define MAXPOW	22
+static double pow10[MAXPOW+1];	/* The powers of ten that can be represented
+				 * exactly as IEEE754 doubles. */
 static int mmaxpow;		/* Largest power of ten that can be
 				 * represented exactly in a 'double'. */
-
-/* Inexact higher powers of ten */
-
-static CONST double pow_10_2_n [] = {
+static int log10_DIGIT_MAX;	/* The number of decimal digits that fit in an
+				 * mp_digit. */
+static int log2FLT_RADIX;	/* Logarithm of the floating point radix. */
+static int mantBits;		/* Number of bits in a double's significand */
+static mp_int pow5[9];		/* Table of powers of 5**(2**n), up to
+				 * 5**256 */
+static double tiny;		/* The smallest representable double */
+static int maxDigits;		/* The maximum number of digits to the left of
+				 * the decimal point of a double. */
+static int minDigits;		/* The maximum number of digits to the right
+				 * of the decimal point in a double. */
+static int mantDIGIT;		/* Number of mp_digit's needed to hold the
+				 * significand of a double. */
+static CONST double pow_10_2_n[] = {	/* Inexact higher powers of ten. */
     1.0,
     100.0,
     10000.0,
@@ -113,60 +119,26 @@ static CONST double pow_10_2_n [] = {
     1.0e+256
 };
 
- /* Logarithm of the floating point radix. */
-
-static int log2FLT_RADIX;
-
-/* Number of bits in a double's significand */
-
-static int mantBits;
-
-/* Table of powers of 5**(2**n), up to 5**256 */
-
-static mp_int pow5[9];
-
-/* The smallest representable double */
-
-static double tiny;
-
-/* The maximum number of digits to the left of the decimal point of a
- * double. */
-
-static int maxDigits;
-
-/* The maximum number of digits to the right of the decimal point in a
- * double. */
-
-static int minDigits;
-
-/* Number of mp_digit's needed to hold the significand of a double */
-
-static int mantDIGIT;
-
-/* Static functions defined in this file */
-
-static int AccumulateDecimalDigit _ANSI_ARGS_((unsigned, int, 
-					       Tcl_WideUInt*, mp_int*, int));
-static double MakeLowPrecisionDouble _ANSI_ARGS_((int signum,
-						  Tcl_WideUInt significand,
-						  int nSigDigs,
-						  int exponent));
-static double MakeHighPrecisionDouble _ANSI_ARGS_((int signum,
-						   mp_int* significand,
-						   int nSigDigs,
-						   int exponent));
-static double MakeNaN _ANSI_ARGS_(( int signum, Tcl_WideUInt tag ));
-static double RefineApproximation _ANSI_ARGS_((double approx,
-					       mp_int* exactSignificand,
-					       int exponent));
-static double AbsoluteValue(double v, int* signum);
-static int GetIntegerTimesPower(double v, mp_int* r, int* e);
-static double BignumToBiasedFrExp _ANSI_ARGS_(( mp_int* big, int* machexp ));
-static double Pow10TimesFrExp _ANSI_ARGS_(( int exponent,
-					    double fraction,
-					    int* machexp ));
-static double SafeLdExp _ANSI_ARGS_(( double fraction, int exponent ));
+/*
+ * Static functions defined in this file.
+ */
 
+static double		AbsoluteValue(double v, int *signum);
+static int		AccumulateDecimalDigit(unsigned, int, 
+			    Tcl_WideUInt *, mp_int *, int);
+static double		BignumToBiasedFrExp(mp_int *big, int* machexp);
+static int		GetIntegerTimesPower(double v, mp_int *r, int *e);
+static double		MakeHighPrecisionDouble(int signum,
+			    mp_int *significand, int nSigDigs, int exponent);
+static double		MakeLowPrecisionDouble(int signum,
+			    Tcl_WideUInt significand, int nSigDigs,
+			    int exponent);
+static double		MakeNaN(int signum, Tcl_WideUInt tag);
+static double		Pow10TimesFrExp(int exponent, double fraction,
+			    int *machexp);
+static double		RefineApproximation(double approx,
+			    mp_int *exactSignificand, int exponent);
+static double		SafeLdExp(double fraction, int exponent);
 
 /*
  *----------------------------------------------------------------------
@@ -179,71 +151,64 @@ static double SafeLdExp _ANSI_ARGS_(( double fraction, int exponent ));
  *	Returns a standard Tcl result.
  *
  * Side effects:
- *	Stores an internal representation appropriate to the string.
- *	The internal representation may be an integer, a wide integer,
- *	a bignum, or a double.
- *
- * TclMakeObjNumeric is called as a common scanner in routines
- * that expect numbers in Tcl_Obj's.  It scans the string representation
- * of a given Tcl_Obj and stores an internal rep that represents
- * a "canonical" version of its numeric value.  The value of the
- * canonicalization is that a routine can determine simply by
- * examining the type pointer whether an object LooksLikeInt,
- * what size of integer is needed to hold it, and similar questions,
- * and never needs to refer back to the string representation, even
- * for "impure" objects.
- *
- * The 'strPtr' and 'endPtrPtr' arguments allow for recognizing a number
- * that is in a substring of a Tcl_Obj, for example a screen metric or
- * "end-" index.  If 'strPtr' is not NULL, it designates where the
- * number begins within the string.  (The default is the start of
- * objPtr's string rep, which will be constructed if necessary.)
- *
- * If 'strPtr' is supplied, 'objPtr' may be NULL.  In this case,
- * no internal representation will be generated; instead, the routine
- * will simply check for a syntactically correct number, returning
- * TCL_OK or TCL_ERROR as appropriate, and setting *endPtrPtr if
- * necessary.
- *
- * If 'endPtrPtr' is not NULL, it designates the first character
- * after the scanned number.  In this case, successfully recognizing
- * any digits will yield a return code of TCL_OK.  Only in the case
- * where no leading string of 'strPtr' (or of objPtr's internal rep)
- * represents a number will TCL_ERROR be returned.
- *
- * When only a partial string is being recognized, it is the caller's
- * responsibility to destroy the internal representation, or at
- * least change its type.  Failure to do so will lead to subsequent
- * problems where a string that does not represent a number will
- * be recognized as one because it has a numeric internal representation.
- *
- * When the 'flags' word includes TCL_PARSE_DECIMAL_ONLY, only decimal
- * numbers are recognized; leading 0 has no special interpretation as
- * octal and leading '0x' is forbidden.
+ *	Stores an internal representation appropriate to the string. The
+ *	internal representation may be an integer, a wide integer, a bignum,
+ *	or a double.
+ *
+ *	TclMakeObjNumeric is called as a common scanner in routines that
+ *	expect numbers in Tcl_Obj's. It scans the string representation of a
+ *	given Tcl_Obj and stores an internal rep that represents a "canonical"
+ *	version of its numeric value. The value of the canonicalization is
+ *	that a routine can determine simply by examining the type pointer
+ *	whether an object LooksLikeInt, what size of integer is needed to hold
+ *	it, and similar questions, and never needs to refer back to the string
+ *	representation, even for "impure" objects.
+ *
+ *	The 'strPtr' and 'endPtrPtr' arguments allow for recognizing a number
+ *	that is in a substring of a Tcl_Obj, for example a screen metric or
+ *	"end-" index. If 'strPtr' is not NULL, it designates where the number
+ *	begins within the string. (The default is the start of objPtr's string
+ *	rep, which will be constructed if necessary.)
+ *
+ *	If 'strPtr' is supplied, 'objPtr' may be NULL. In this case, no
+ *	internal representation will be generated; instead, the routine will
+ *	simply check for a syntactically correct number, returning TCL_OK or
+ *	TCL_ERROR as appropriate, and setting *endPtrPtr if necessary.
+ *
+ *	If 'endPtrPtr' is not NULL, it designates the first character after
+ *	the scanned number. In this case, successfully recognizing any digits
+ *	will yield a return code of TCL_OK. Only in the case where no leading
+ *	string of 'strPtr' (or of objPtr's internal rep) represents a number
+ *	will TCL_ERROR be returned.
+ *
+ *	When only a partial string is being recognized, it is the caller's
+ *	responsibility to destroy the internal representation, or at least
+ *	change its type. Failure to do so will lead to subsequent problems
+ *	where a string that does not represent a number will be recognized as
+ *	one because it has a numeric internal representation.
+ *
+ *	When the 'flags' word includes TCL_PARSE_DECIMAL_ONLY, only decimal
+ *	numbers are recognized; leading 0 has no special interpretation as
+ *	octal and leading '0x' is forbidden.
  *
  *----------------------------------------------------------------------
  */
 
 int
-TclParseNumber( Tcl_Interp* interp,
-				/* Tcl interpreter for error reporting.
-				 * May be NULL */
-		Tcl_Obj* objPtr,
-				/* Object to receive the internal rep */
-		CONST char* type,
-				/* Type of number being parsed ("integer",
+TclParseNumber(
+    Tcl_Interp *interp,		/* Tcl interpreter for error reporting. May be
+				 * NULL */
+    Tcl_Obj *objPtr,		/* Object to receive the internal rep */
+    CONST char *type,		/* Type of number being parsed ("integer",
 				 * "wide integer", etc. */
-		CONST char* string,
-				/* Pointer to the start of the string to
-				 * scan, see above */
-		size_t length,	/* Maximum length of the string to scan,
-				 * see above. */
-		CONST char** endPtrPtr,
-				/* (Output) pointer to the end of the
-				 * scanned number, see above */
-		int flags)	/* Flags governing the parse */
+    CONST char *string,		/* Pointer to the start of the string to scan,
+				 * see above */
+    size_t length,		/* Maximum length of the string to scan, see
+				 * above. */
+    CONST char **endPtrPtr,	/* (Output) pointer to the end of the scanned
+				 * number, see above */
+    int flags)			/* Flags governing the parse */
 {
-
     enum State {
 	INITIAL, SIGNUM, ZERO, ZERO_X, 
 #ifdef TIP_114_FORMATS
@@ -261,66 +226,69 @@ TclParseNumber( Tcl_Interp* interp,
 
     int signum = 0;		/* Sign of the number being parsed */
     Tcl_WideUInt significandWide = 0;
-				/* Significand of the number being
-				 * parsed (if no overflow) */
-    mp_int significandBig;	/* Significand of the number being
-				 * parsed (if it overflows significandWide) */
-    int significandOverflow = 0;
-				/* Flag==1 iff significandBig is used */
+				/* Significand of the number being parsed (if
+				 * no overflow) */
+    mp_int significandBig;	/* Significand of the number being parsed (if
+				 * it overflows significandWide) */
+    int significandOverflow = 0;/* Flag==1 iff significandBig is used */
     Tcl_WideUInt octalSignificandWide = 0;
 				/* Significand of an octal number; needed
-				 * because we don't know whether a number
-				 * with a leading zero is octal or decimal
-				 * until we've scanned forward to a '.' or
-				 * 'e' */
+				 * because we don't know whether a number with
+				 * a leading zero is octal or decimal until
+				 * we've scanned forward to a '.' or 'e' */
     mp_int octalSignificandBig;	/* Significand of octal number once
 				 * octalSignificandWide overflows */
     int octalSignificandOverflow = 0;
 				/* Flag==1 if octalSignificandBig is used */
-    int numSigDigs = 0;		/* Number of significant digits in the
-				 * decimal significand */
-    int numTrailZeros = 0;	/* Number of trailing zeroes at the
-				 * current point in the parse. */
-    int numDigitsAfterDp = 0;	/* Number of digits scanned after the
-				 * decimal point */
-    int exponentSignum = 0;	/* Signum of the exponent of a floating
-				 * point number */
+    int numSigDigs = 0;		/* Number of significant digits in the decimal
+				 * significand */
+    int numTrailZeros = 0;	/* Number of trailing zeroes at the current
+				 * point in the parse. */
+    int numDigitsAfterDp = 0;	/* Number of digits scanned after the decimal
+				 * point */
+    int exponentSignum = 0;	/* Signum of the exponent of a floating point
+				 * number */
     long exponent = 0;		/* Exponent of a floating point number */
-    CONST char* p;		/* Pointer to next character to scan */
+    CONST char *p;		/* Pointer to next character to scan */
     size_t len;			/* Number of characters remaining after p */
-    CONST char* acceptPoint;	/* Pointer to position after last character
-				 * in an acceptable number */
-    size_t acceptLen;		/* Number of characters following that point */
+    CONST char *acceptPoint;	/* Pointer to position after last character in
+				 * an acceptable number */
+    size_t acceptLen;		/* Number of characters following that
+				 * point. */
     int status = TCL_OK;	/* Status to return to caller */
-    char d = 0;			/* Last hexadecimal digit scanned; initialized 
+    char d = 0;			/* Last hexadecimal digit scanned; initialized
 				 * to avoid a compiler warning. */
     int shift = 0;		/* Amount to shift when accumulating binary */
 #ifdef TIP_114_FORMATS
     int explicitOctal = 0;
 #endif
 
+#define ALL_BITS	(~(Tcl_WideUInt)0)
+#define MOST_BITS	(ALL_BITS >> 1)
+
     /* 
-     * Initialize string to start of the object's string rep if
-     * the caller didn't pass anything else.
+     * Initialize string to start of the object's string rep if the caller
+     * didn't pass anything else.
      */
 
-    if ( string == NULL ) {
-	string = Tcl_GetStringFromObj( objPtr, NULL );
+    if (string == NULL) {
+	string = TclGetString(objPtr);
     }
 
     p = string;
     len = length;
     acceptPoint = p;
     acceptLen = len;
-    while ( 1 ) {
+    while (1) {
 	char c = len ? *p : '\0';
 	switch (state) {
 
 	case INITIAL:
 	    /*
-	     * Initial state. Acceptable characters are +, -, digits,
-	     * period, I, N, and whitespace.
+	     * Initial state. Acceptable characters are +, -, digits, period,
+	     * I, N, and whitespace.
 	     */
+
 	    if (isspace(UCHAR(c))) {
 		break;
 	    } else if (c == '+') {
@@ -335,9 +303,10 @@ TclParseNumber( Tcl_Interp* interp,
 	    
 	case SIGNUM:
 	    /*
-	     * Scanned a leading + or -. Acceptable characters are
-	     * digits, period, I, and N.
+	     * Scanned a leading + or -. Acceptable characters are digits,
+	     * period, I, and N.
 	     */
+
 	    if (c == '0') {
 		if (flags & TCL_PARSE_DECIMAL_ONLY) {
 		    state = DECIMAL;
@@ -372,12 +341,12 @@ TclParseNumber( Tcl_Interp* interp,
 
 	case ZERO:
 	    /*
-	     * Scanned a leading zero (perhaps with a + or -).
-	     * Acceptable inputs are digits, period, X, and E.
-	     * If 8 or 9 is encountered, the number can't be
-	     * octal.  This state and the OCTAL state differ only
-	     * in whether they recognize 'X'.
+	     * Scanned a leading zero (perhaps with a + or -). Acceptable
+	     * inputs are digits, period, X, and E. If 8 or 9 is encountered,
+	     * the number can't be octal. This state and the OCTAL state
+	     * differ only in whether they recognize 'X'.
 	     */
+
 	    acceptState = state;
 	    acceptPoint = p;
 	    acceptLen = len;
@@ -409,11 +378,11 @@ TclParseNumber( Tcl_Interp* interp,
 
 	case OCTAL:
 	    /*
-	     * Scanned an optional + or -, followed by a string of
-	     * octal digits.  Acceptable inputs are more digits,
-	     * period, or E.  If 8 or 9 is encountered, commit to
-	     * floating point.
+	     * Scanned an optional + or -, followed by a string of octal
+	     * digits. Acceptable inputs are more digits, period, or E. If 8
+	     * or 9 is encountered, commit to floating point.
 	     */
+
 	    acceptState = state;
 	    acceptPoint = p;
 	    acceptLen = len;
@@ -429,40 +398,39 @@ TclParseNumber( Tcl_Interp* interp,
 	    } else if (c >= '1' && c <= '7') {
 		if (objPtr != NULL) {
 		    shift = 3 * (numTrailZeros + 1);
-		    significandOverflow = 
-			AccumulateDecimalDigit((unsigned)(c-'0'),
-					       numTrailZeros, 
-					       &significandWide,
-					       &significandBig, 
-					       significandOverflow);
-		    
+		    significandOverflow = AccumulateDecimalDigit(
+			    (unsigned)(c-'0'), numTrailZeros,
+			    &significandWide, &significandBig,
+			    significandOverflow);
+
 		    if (!octalSignificandOverflow) {
 			/*
 			 * Shifting by more bits than are in the value being
-			 * shifted is at least de facto nonportable.  Check
-			 * for too large shifts first.
+			 * shifted is at least de facto nonportable. Check for
+			 * too large shifts first.
 			 */
+
 			if ((octalSignificandWide != 0) 
 				&& ((shift >= CHAR_BIT*sizeof(Tcl_WideUInt)) 
 				|| (octalSignificandWide 
 				> (~(Tcl_WideUInt)0 >> shift)))) {
 			    octalSignificandOverflow = 1;
 			    TclBNInitBignumFromWideUInt(&octalSignificandBig,
-							octalSignificandWide);
+				    octalSignificandWide);
 			}
 		    }
 		    if (!octalSignificandOverflow) {
-			octalSignificandWide
-			    = (octalSignificandWide << shift) + (c - '0');
+			octalSignificandWide =
+				(octalSignificandWide << shift) + (c - '0');
 		    } else {
 			mp_mul_2d(&octalSignificandBig, shift,
-				  &octalSignificandBig);
+				&octalSignificandBig);
 			mp_add_d(&octalSignificandBig, (mp_digit)(c - '0'),
-				 &octalSignificandBig);
+				&octalSignificandBig);
 		    }
 		}
-		if ( numSigDigs != 0 ) {
-		    numSigDigs += ( numTrailZeros + 1 );
+		if (numSigDigs != 0) {
+		    numSigDigs += numTrailZeros+1;
 		} else {
 		    numSigDigs = 1;
 		}
@@ -475,35 +443,42 @@ TclParseNumber( Tcl_Interp* interp,
 	case BAD_OCTAL:
 #ifdef TIP_114_FORMATS
 	    if (explicitOctal) {
-		/* No forgiveness for bad digits in explicitly octal numbers */
+		/*
+		 * No forgiveness for bad digits in explicitly octal
+		 * numbers.
+		 */
+
 		goto endgame;
 	    }
 #endif
 	    if (flags & TCL_PARSE_INTEGER_ONLY) {
-		/* No seeking floating point when parsing only integer */
+		/*
+		 * No seeking floating point when parsing only integer.
+		 */
+
 		goto endgame;
 	    }
 #ifndef KILL_OCTAL
+
 	    /*
-	     * Scanned a number with a leading zero that contains an
-	     * 8, 9, radix point or E.  This is an invalid octal number,
-	     * but might still be floating point.  
+	     * Scanned a number with a leading zero that contains an 8, 9,
+	     * radix point or E. This is an invalid octal number, but might
+	     * still be floating point.
 	     */
+
 	    if (c == '0') {
 		++numTrailZeros;
 		state = BAD_OCTAL;
 		break;
 	    } else if (isdigit(UCHAR(c))) {
 		if (objPtr != NULL) {
-		    significandOverflow = 
-			AccumulateDecimalDigit((unsigned)(c-'0'),
-					       numTrailZeros, 
-					       &significandWide,
-					       &significandBig, 
-					       significandOverflow);
+		    significandOverflow = AccumulateDecimalDigit(
+			    (unsigned)(c-'0'), numTrailZeros,
+			    &significandWide, &significandBig,
+			    significandOverflow);
 		}
-		if ( numSigDigs != 0 ) {
-		    numSigDigs += ( numTrailZeros + 1 );
+		if (numSigDigs != 0) {
+		    numSigDigs += (numTrailZeros + 1);
 		} else {
 		    numSigDigs = 1;
 		}
@@ -521,15 +496,17 @@ TclParseNumber( Tcl_Interp* interp,
 	    goto endgame;
 
 	    /*
-	     * Scanned 0x.  If state is HEXADECIMAL, scanned at least
-	     * one character following the 0x.  The only acceptable
-	     * inputs are hexadecimal digits.
+	     * Scanned 0x. If state is HEXADECIMAL, scanned at least one
+	     * character following the 0x. The only acceptable inputs are
+	     * hexadecimal digits.
 	     */
+
 	case HEXADECIMAL:
 	    acceptState = state;
 	    acceptPoint = p;
 	    acceptLen = len;
 	    /* FALLTHROUGH */
+
 	case ZERO_X:
 	zerox:
 	    if (c == '0') {
@@ -550,25 +527,23 @@ TclParseNumber( Tcl_Interp* interp,
 		if (!significandOverflow) {
 		    /*
 		     * Shifting by more bits than are in the value being
-		     * shifted is at least de facto nonportable.  Check
-		     * for too large shifts first.
+		     * shifted is at least de facto nonportable. Check for too
+		     * large shifts first.
 		     */
-		    if (significandWide != 0 
-			    && (shift >= CHAR_BIT*sizeof(Tcl_WideUInt)
-			    || significandWide > (~(Tcl_WideUInt)0 >> shift))) {
+
+		    if (significandWide != 0 &&
+			    (shift >= CHAR_BIT*sizeof(Tcl_WideUInt) ||
+			    significandWide > (~(Tcl_WideUInt)0 >> shift))) {
 			significandOverflow = 1;
 			TclBNInitBignumFromWideUInt(&significandBig,
-						    significandWide);
+				significandWide);
 		    }
 		}
 		if (!significandOverflow) {
-		    significandWide
-			= (significandWide << shift) + d;
+		    significandWide = (significandWide << shift) + d;
 		} else {
-		    mp_mul_2d(&significandBig, shift,
-			      &significandBig);
-		    mp_add_d(&significandBig, (mp_digit) d,
-			     &significandBig);
+		    mp_mul_2d(&significandBig, shift, &significandBig);
+		    mp_add_d(&significandBig, (mp_digit) d, &significandBig);
 		}
 	    }
 	    numTrailZeros = 0;
@@ -593,25 +568,23 @@ TclParseNumber( Tcl_Interp* interp,
 		if (!significandOverflow) {
 		    /*
 		     * Shifting by more bits than are in the value being
-		     * shifted is at least de facto nonportable.  Check
-		     * for too large shifts first.
+		     * shifted is at least de facto nonportable. Check for too
+		     * large shifts first.
 		     */
-		    if (significandWide != 0 
-			    && (shift >= CHAR_BIT*sizeof(Tcl_WideUInt)
-			    || significandWide > (~(Tcl_WideUInt)0 >> shift))) {
+
+		    if (significandWide != 0 &&
+			    (shift >= CHAR_BIT*sizeof(Tcl_WideUInt) ||
+			    significandWide > (~(Tcl_WideUInt)0 >> shift))) {
 			significandOverflow = 1;
 			TclBNInitBignumFromWideUInt(&significandBig,
-						    significandWide);
+				significandWide);
 		    }
 		}
 		if (!significandOverflow) {
-		    significandWide
-			= (significandWide << shift) + 1;
+		    significandWide = (significandWide << shift) + 1;
 		} else {
-		    mp_mul_2d(&significandBig, shift,
-			      &significandBig);
-		    mp_add_d(&significandBig, (mp_digit) 1,
-			     &significandBig);
+		    mp_mul_2d(&significandBig, shift, &significandBig);
+		    mp_add_d(&significandBig, (mp_digit) 1, &significandBig);
 		}
 	    }
 	    numTrailZeros = 0;
@@ -621,9 +594,10 @@ TclParseNumber( Tcl_Interp* interp,
 
 	case DECIMAL:
 	    /*
-	     * Scanned an optional + or - followed by a string of
-	     * decimal digits.
+	     * Scanned an optional + or - followed by a string of decimal
+	     * digits.
 	     */
+
 #ifdef KILL_OCTAL
 	decimal:
 #endif
@@ -636,14 +610,12 @@ TclParseNumber( Tcl_Interp* interp,
 		break;
 	    } else if (isdigit(UCHAR(c))) {
 		if (objPtr != NULL) {
-		    significandOverflow = 
-			AccumulateDecimalDigit((unsigned)(c - '0'), 
-					       numTrailZeros, 
-					       &significandWide,
-					       &significandBig, 
-					       significandOverflow);
+		    significandOverflow = AccumulateDecimalDigit(
+			    (unsigned)(c - '0'), numTrailZeros, 
+			    &significandWide, &significandBig, 
+			    significandOverflow);
 		}
-		numSigDigs += ( numTrailZeros + 1 );
+		numSigDigs += numTrailZeros+1;
 		numTrailZeros = 0;
 		state = DECIMAL;
 		break;
@@ -659,11 +631,11 @@ TclParseNumber( Tcl_Interp* interp,
 	    goto endgame;
 
 	    /* 
-	     * Found a decimal point.  If no digits have yet been scanned,
-	     * E is not allowed; otherwise, it introduces the exponent.
-	     * If at least one digit has been found, we have a possible
-	     * complete number.
+	     * Found a decimal point. If no digits have yet been scanned, E is
+	     * not allowed; otherwise, it introduces the exponent. If at least
+	     * one digit has been found, we have a possible complete number.
 	     */
+
 	case FRACTION:
 	    acceptState = state;
 	    acceptPoint = p;
@@ -673,6 +645,7 @@ TclParseNumber( Tcl_Interp* interp,
 		break;
 	    }
 	    /* FALLTHROUGH */
+
 	case LEADING_RADIX_POINT:
 	    if (c == '0') {
 		++numDigitsAfterDp;
@@ -682,15 +655,13 @@ TclParseNumber( Tcl_Interp* interp,
 	    } else if (isdigit(UCHAR(c))) {
 		++numDigitsAfterDp;
 		if (objPtr != NULL) {
-		    significandOverflow = 
-			AccumulateDecimalDigit((unsigned)(c-'0'),
-					       numTrailZeros, 
-					       &significandWide,
-					       &significandBig, 
-					       significandOverflow);
+		    significandOverflow = AccumulateDecimalDigit(
+			    (unsigned)(c-'0'), numTrailZeros, 
+			    &significandWide, &significandBig, 
+			    significandOverflow);
 		}
-		if ( numSigDigs != 0 ) {
-		    numSigDigs += ( numTrailZeros + 1 );
+		if (numSigDigs != 0) {
+		    numSigDigs += numTrailZeros+1;
 		} else {
 		    numSigDigs = 1;
 		}
@@ -702,10 +673,11 @@ TclParseNumber( Tcl_Interp* interp,
 
 	case EXPONENT_START:
 	    /* 
-	     * Scanned the E at the start of an exponent. Make sure
-	     * a legal character follows before using the C library
-	     * strtol routine, which allows whitespace.
+	     * Scanned the E at the start of an exponent. Make sure a legal
+	     * character follows before using the C library strtol routine,
+	     * which allows whitespace.
 	     */
+
 	    if (c == '+') {
 		state = EXPONENT_SIGNUM;
 		break;
@@ -718,9 +690,10 @@ TclParseNumber( Tcl_Interp* interp,
 
 	case EXPONENT_SIGNUM:
 	    /*
-	     * Found the E at the start of the exponent, followed by
-	     * a sign character.
+	     * Found the E at the start of the exponent, followed by a sign
+	     * character.
 	     */
+
 	    if (isdigit(UCHAR(c))) {
 		exponent = c - '0';
 		state = EXPONENT;
@@ -730,10 +703,10 @@ TclParseNumber( Tcl_Interp* interp,
 
 	case EXPONENT:
 	    /* 
-	     * Found an exponent with at least one digit. 
-	     * Accumulate it, making sure to hard-pin it to LONG_MAX
-	     * on overflow.
+	     * Found an exponent with at least one digit. Accumulate it,
+	     * making sure to hard-pin it to LONG_MAX on overflow.
 	     */
+
 	    acceptState = state;
 	    acceptPoint = p;
 	    acceptLen = len;
@@ -749,18 +722,18 @@ TclParseNumber( Tcl_Interp* interp,
 	    goto endgame;
 
 	    /*
-	     * Parse out INFINITY by simply spelling it out.
-	     * INF is accepted as an abbreviation; other prefices are
-	     * not.
+	     * Parse out INFINITY by simply spelling it out. INF is accepted
+	     * as an abbreviation; other prefices are not.
 	     */
+
 	case sI:
-	    if ( c == 'n' || c == 'N' ) {
+	    if (c == 'n' || c == 'N') {
 		state = sIN;
 		break;
 	    } 
 	    goto endgame;
 	case sIN:
-	    if ( c == 'f' || c == 'F' ) {
+	    if (c == 'f' || c == 'F') {
 		state = sINF;
 		break;
 	    } 
@@ -769,31 +742,31 @@ TclParseNumber( Tcl_Interp* interp,
 	    acceptState = state;
 	    acceptPoint = p;
 	    acceptLen = len;
-	    if ( c == 'i' || c == 'I' ) {
+	    if (c == 'i' || c == 'I') {
 		state = sINFI;
 		break;
 	    }
 	    goto endgame;
 	case sINFI:
-	    if ( c == 'n' || c == 'N' ) {
+	    if (c == 'n' || c == 'N') {
 		state = sINFIN;
 		break;
 	    }
 	    goto endgame;
 	case sINFIN:
-	    if ( c == 'i' || c == 'I' ) {
+	    if (c == 'i' || c == 'I') {
 		state = sINFINI;
 		break;
 	    }
 	    goto endgame;
 	case sINFINI:
-	    if ( c == 't' || c == 'T' ) {
+	    if (c == 't' || c == 'T') {
 		state = sINFINIT;
 		break;
 	    }
 	    goto endgame;
 	case sINFINIT:
-	    if ( c == 'y' || c == 'Y' ) {
+	    if (c == 'y' || c == 'Y') {
 		state = sINFINITY;
 		break;
 	    }
@@ -804,13 +777,13 @@ TclParseNumber( Tcl_Interp* interp,
 	     */
 #ifdef IEEE_FLOATING_POINT
 	case sN:
-	    if ( c == 'a' || c == 'A' ) {
+	    if (c == 'a' || c == 'A') {
 		state = sNA;
 		break;
 	    }
 	    goto endgame;
 	case sNA:
-	    if ( c == 'n' || c == 'N' ) {
+	    if (c == 'n' || c == 'N') {
 		state = sNAN;
 		break;
 	    }
@@ -819,7 +792,7 @@ TclParseNumber( Tcl_Interp* interp,
 	    acceptState = state;
 	    acceptPoint = p;
 	    acceptLen = len;
-	    if ( c == '(' ) {
+	    if (c == '(') {
 		state = sNANPAREN;
 		break;
 	    }
@@ -829,21 +802,21 @@ TclParseNumber( Tcl_Interp* interp,
 	     * Parse NaN(hexdigits)
 	     */
 	case sNANHEX:
-	    if ( c == ')' ) {
+	    if (c == ')') {
 		state = sNANFINISH;
 		break;
 	    }
 	    /* FALLTHROUGH */
 	case sNANPAREN:
-	    if ( isspace(UCHAR(c)) ) {
+	    if (isspace(UCHAR(c))) {
 		break;
 	    }
-	    if ( numSigDigs < 13 ) {
-		if ( c >= '0' && c <= '9' ) {
+	    if (numSigDigs < 13) {
+		if (c >= '0' && c <= '9') {
 		    d = c - '0';
-		} else if ( c >= 'a' && c <= 'f' ) {
+		} else if (c >= 'a' && c <= 'f') {
 		    d = 10 + c - 'a';
-		} else if ( c >= 'A' && c <= 'F' ) {
+		} else if (c >= 'A' && c <= 'F') {
 		    d = 10 + c - 'A';
 		}
 		significandWide = (significandWide << 4) + d;
@@ -853,6 +826,7 @@ TclParseNumber( Tcl_Interp* interp,
 	    goto endgame;
 	case sNANFINISH:
 #endif
+
 	case sINFINITY:
 	    acceptState = state;
 	    acceptPoint = p;
@@ -865,7 +839,9 @@ TclParseNumber( Tcl_Interp* interp,
 
   endgame:
 
-    /* Back up to the last accepting state in the lexer */
+    /*
+     * Back up to the last accepting state in the lexer.
+     */
 
     if (acceptState == INITIAL) {
 	status = TCL_ERROR;
@@ -873,7 +849,9 @@ TclParseNumber( Tcl_Interp* interp,
     p = acceptPoint;
     len = acceptLen;
 
-    /* Skip past trailing whitespace */
+    /*
+     * Skip past trailing whitespace.
+     */
 
     if (endPtrPtr != NULL) {
 	*endPtrPtr = p;
@@ -884,17 +862,21 @@ TclParseNumber( Tcl_Interp* interp,
 	--len;
     }
 
-    /* Determine whether a partial string is acceptable. */
+    /*
+     * Determine whether a partial string is acceptable.
+     */
 
     if (endPtrPtr == NULL && len != 0 && *p != '\0') {
 	status = TCL_ERROR;
     }
 
-    /* Generate and store the appropriate internal rep */
+    /*
+     * Generate and store the appropriate internal rep.
+     */
 
     if (status == TCL_OK && objPtr != NULL) {
-	if ( acceptState != INITIAL ) {
-	    TclFreeIntRep( objPtr );
+	if (acceptState != INITIAL) {
+	    TclFreeIntRep(objPtr);
 	}
 	switch (acceptState) {
 
@@ -927,74 +909,69 @@ TclParseNumber( Tcl_Interp* interp,
 #ifdef TIP_114_FORMATS
 	case BINARY:
 	    shift = numTrailZeros;
-	    if (!significandOverflow) {
-		if (significandWide !=0 
-			&& (shift >= CHAR_BIT*sizeof(Tcl_WideUInt) 
-			|| significandWide 
-			> (((~(Tcl_WideUInt)0) >> 1) + signum) >> shift )) {
-		    significandOverflow = 1;
-		    TclBNInitBignumFromWideUInt(&significandBig,
-						significandWide);
-		}
+	    if (!significandOverflow && significandWide != 0 &&
+		    (shift >= CHAR_BIT*sizeof(Tcl_WideUInt) ||
+		    significandWide > (MOST_BITS + signum) >> shift)) {
+		significandOverflow = 1;
+		TclBNInitBignumFromWideUInt(&significandBig, significandWide);
 	    }
 	    if (shift) {
-		if ( !significandOverflow ) {
+		if (!significandOverflow) {
 		    significandWide <<= shift;
 		} else {
-		    mp_mul_2d( &significandBig, shift, &significandBig );
+		    mp_mul_2d(&significandBig, shift, &significandBig);
 		}
 	    }
 	    goto returnInteger;
 #endif
+
 	case HEXADECIMAL:
-	    /* Returning a hex integer.  Final scaling step */
+	    /*
+	     * Returning a hex integer. Final scaling step.
+	     */
+
 	    shift = 4 * numTrailZeros;
-	    if (!significandOverflow) {
-		if (significandWide !=0 
-			&& (shift >= CHAR_BIT*sizeof(Tcl_WideUInt) 
-			|| significandWide 
-			> (((~(Tcl_WideUInt)0) >> 1) + signum) >> shift )) {
-		    significandOverflow = 1;
-		    TclBNInitBignumFromWideUInt(&significandBig,
-						significandWide);
-		}
+	    if (!significandOverflow && significandWide !=0 &&
+		    (shift >= CHAR_BIT*sizeof(Tcl_WideUInt) ||
+		    significandWide > (MOST_BITS + signum) >> shift)) {
+		significandOverflow = 1;
+		TclBNInitBignumFromWideUInt(&significandBig, significandWide);
 	    }
 	    if (shift) {
-		if ( !significandOverflow ) {
+		if (!significandOverflow) {
 		    significandWide <<= shift;
 		} else {
-		    mp_mul_2d( &significandBig, shift, &significandBig );
+		    mp_mul_2d(&significandBig, shift, &significandBig);
 		}
 	    }
 	    goto returnInteger;
 
 	case OCTAL:
-	    /* Returning an octal integer.  Final scaling step */
+	    /*
+	     * Returning an octal integer. Final scaling step
+	     */
+
 	    shift = 3 * numTrailZeros;
-	    if (!octalSignificandOverflow) {
-		if (octalSignificandWide != 0
-			&& (shift >= CHAR_BIT*sizeof(Tcl_WideUInt) 
-			|| octalSignificandWide 
-			> (((~(Tcl_WideUInt)0) >> 1) + signum) >> shift )) {
-		    octalSignificandOverflow = 1;
-		    TclBNInitBignumFromWideUInt(&octalSignificandBig,
-						octalSignificandWide);
-		}
+	    if (!octalSignificandOverflow && octalSignificandWide != 0 &&
+		    (shift >= CHAR_BIT*sizeof(Tcl_WideUInt) ||
+		    octalSignificandWide > (MOST_BITS + signum) >> shift)) {
+		octalSignificandOverflow = 1;
+		TclBNInitBignumFromWideUInt(&octalSignificandBig,
+			octalSignificandWide);
 	    }
-	    if ( shift ) {
-		if ( !octalSignificandOverflow ) {
+	    if (shift) {
+		if (!octalSignificandOverflow) {
 		    octalSignificandWide <<= shift;
 		} else {
-		    mp_mul_2d( &octalSignificandBig, shift,
-			       &octalSignificandBig );
+		    mp_mul_2d(&octalSignificandBig, shift,
+			    &octalSignificandBig);
 		}
 	    }
 	    if (!octalSignificandOverflow) {
 		if (octalSignificandWide > 
 			(Tcl_WideUInt)(((~(unsigned long)0) >> 1) + signum)) {
 #ifndef NO_WIDE_TYPE
-		    if (octalSignificandWide 
-			    <= (((~(Tcl_WideUInt)0) >> 1) + signum)) {
+		    if (octalSignificandWide <= (MOST_BITS + signum)) {
 			objPtr->typePtr = &tclWideIntType;
 			if (signum) {
 			    objPtr->internalRep.wideValue =
@@ -1007,7 +984,7 @@ TclParseNumber( Tcl_Interp* interp,
 		    }
 #endif
 		    TclBNInitBignumFromWideUInt(&octalSignificandBig,
-						octalSignificandWide);
+			    octalSignificandWide);
 		    octalSignificandOverflow = 1;
 		} else {
 		    objPtr->typePtr = &tclIntType;
@@ -1030,24 +1007,18 @@ TclParseNumber( Tcl_Interp* interp,
 
 	case ZERO:
 	case DECIMAL:
-	    significandOverflow =
-		AccumulateDecimalDigit( 0, numTrailZeros-1,
-					&significandWide, &significandBig,
-					significandOverflow );
-	    if (!significandOverflow
-		&& (significandWide
-		    > (((~(Tcl_WideUInt)0) >> 1) + signum))) {
+	    significandOverflow = AccumulateDecimalDigit(0, numTrailZeros-1,
+		    &significandWide, &significandBig, significandOverflow);
+	    if (!significandOverflow && (significandWide > MOST_BITS+signum)) {
 		significandOverflow = 1;
-		TclBNInitBignumFromWideUInt(&significandBig,
-					    significandWide);
+		TclBNInitBignumFromWideUInt(&significandBig, significandWide);
 	    }
-	  returnInteger:
+	returnInteger:
 	    if (!significandOverflow) {
 		if (significandWide > 
 			(Tcl_WideUInt)(((~(unsigned long)0) >> 1) + signum)) {
 #ifndef NO_WIDE_TYPE
-		    if (significandWide 
-			    <= (((~(Tcl_WideUInt)0) >> 1) + signum)) {
+		    if (significandWide <= MOST_BITS+signum) {
 			objPtr->typePtr = &tclWideIntType;
 			if (signum) {
 			    objPtr->internalRep.wideValue =
@@ -1060,7 +1031,7 @@ TclParseNumber( Tcl_Interp* interp,
 		    }
 #endif
 		    TclBNInitBignumFromWideUInt(&significandBig,
-						significandWide);
+			    significandWide);
 		    significandOverflow = 1;
 		} else {
 		    objPtr->typePtr = &tclIntType;
@@ -1085,40 +1056,31 @@ TclParseNumber( Tcl_Interp* interp,
 	case EXPONENT:
 
 	    /*
-	     * Here, we're parsing a floating-point number.
-	     * 'significandWide' or 'significandBig' contains the
-	     * exact significand, according to whether
-	     * 'significandOverflow' is set.  The desired floating
+	     * Here, we're parsing a floating-point number. 'significandWide'
+	     * or 'significandBig' contains the exact significand, according
+	     * to whether 'significandOverflow' is set. The desired floating
 	     * point value is significand * 10**k, where
 	     * k = numTrailZeros+exponent-numDigitsAfterDp.
 	     */
 
 	    objPtr->typePtr = &tclDoubleType;
-	    if ( exponentSignum ) {
+	    if (exponentSignum) {
 		exponent = - exponent;
 	    }
-	    if ( !significandOverflow ) {
-		objPtr->internalRep.doubleValue = 
-		    MakeLowPrecisionDouble( signum, 
-					    significandWide,
-					    numSigDigs,
-					    ( numTrailZeros
-					      + exponent
-					      - numDigitsAfterDp ) );
+	    if (!significandOverflow) {
+		objPtr->internalRep.doubleValue = MakeLowPrecisionDouble(
+			signum, significandWide, numSigDigs,
+			(numTrailZeros + exponent - numDigitsAfterDp));
 	    } else {
-		objPtr->internalRep.doubleValue =
-		    MakeHighPrecisionDouble( signum,
-					     &significandBig,
-					     numSigDigs,
-					     ( numTrailZeros
-					       + exponent
-					       - numDigitsAfterDp ) );
+		objPtr->internalRep.doubleValue = MakeHighPrecisionDouble(
+			signum, &significandBig, numSigDigs,
+			(numTrailZeros + exponent - numDigitsAfterDp));
 	    }
 	    break;
 
 	case sINF:
 	case sINFINITY:
-	    if ( signum ) {
+	    if (signum) {
 		objPtr->internalRep.doubleValue = -HUGE_VAL;
 	    } else {
 		objPtr->internalRep.doubleValue = HUGE_VAL;
@@ -1128,32 +1090,34 @@ TclParseNumber( Tcl_Interp* interp,
 
 	case sNAN:
 	case sNANFINISH:
-	    objPtr->internalRep.doubleValue
-		= MakeNaN( signum, significandWide );
+	    objPtr->internalRep.doubleValue = MakeNaN(signum, significandWide);
 	    objPtr->typePtr = &tclDoubleType;
 	    break;
-	    
 	}
     }
 
-    /* Format an error message when an invalid number is encountered. */
+    /*
+     * Format an error message when an invalid number is encountered.
+     */
 
-    if ( status != TCL_OK ) {
-	if ( interp != NULL ) {
-	    Tcl_Obj *msg = Tcl_NewStringObj( "expected ", -1 );
-	    Tcl_AppendToObj( msg, type, -1 );
-	    Tcl_AppendToObj( msg, " but got \"", -1 );
-	    TclAppendLimitedToObj( msg, string, length, 50, "" );
-	    Tcl_AppendToObj( msg, "\"", -1 );
-	    if ( state == BAD_OCTAL ) {
-		Tcl_AppendToObj( msg, " (looks like invalid octal number)",
-				 -1 );
+    if (status != TCL_OK) {
+	if (interp != NULL) {
+	    Tcl_Obj *msg = Tcl_NewStringObj("expected ", -1);
+
+	    Tcl_AppendToObj(msg, type, -1);
+	    Tcl_AppendToObj(msg, " but got \"", -1);
+	    TclAppendLimitedToObj(msg, string, length, 50, "");
+	    Tcl_AppendToObj(msg, "\"", -1);
+	    if (state == BAD_OCTAL) {
+		Tcl_AppendToObj(msg, " (looks like invalid octal number)", -1);
 	    }
-	    Tcl_SetObjResult( interp, msg );
+	    Tcl_SetObjResult(interp, msg);
 	}
     }
 
-    /* Free memory */
+    /*
+     * Free memory.
+     */
 
     if (octalSignificandOverflow) {
 	mp_clear(&octalSignificandBig);
@@ -1172,8 +1136,8 @@ TclParseNumber( Tcl_Interp* interp,
  *	Consume a decimal digit in a number being scanned.
  *
  * Results:
- *	Returns 1 if the number has overflowed to a bignum, 0 if it
- *	still fits in a wide integer.
+ *	Returns 1 if the number has overflowed to a bignum, 0 if it still fits
+ *	in a wide integer.
  *
  * Side effects:
  *	Updates either the wide or bignum representation.
@@ -1182,75 +1146,73 @@ TclParseNumber( Tcl_Interp* interp,
  */
 
 static int
-AccumulateDecimalDigit( unsigned digit,
-				/* Digit being scanned */
-			int numZeros,
-				/* Count of zero digits preceding the
-				 * digit being scanned */
-			Tcl_WideUInt* wideRepPtr,
-				/* Representation of the partial number
-				 * as a wide integer */
-			mp_int* bignumRepPtr,
-				/* Representation of the partial number
-				 * as a bignum */
-			int bignumFlag )
-				/* Flag == 1 if the number overflowed
-				 * previous to this digit. */
+AccumulateDecimalDigit(
+    unsigned digit,		/* Digit being scanned. */
+    int numZeros,		/* Count of zero digits preceding the digit
+				 * being scanned. */
+    Tcl_WideUInt *wideRepPtr,	/* Representation of the partial number as a
+				 * wide integer. */
+    mp_int *bignumRepPtr,	/* Representation of the partial number as a
+				 * bignum. */
+    int bignumFlag)		/* Flag == 1 if the number overflowed previous
+				 * to this digit. */
 {
     int i, n;
 
-    /* Check if the number still fits in a wide */
+    /*
+     * Check if the number still fits in a wide.
+     */
 
-    if (!bignumFlag) {
-	if (*wideRepPtr != 0) {
-	    if ((numZeros >= maxpow10_wide)
-		|| (*wideRepPtr > (((~(Tcl_WideUInt)0) - digit)
-				   / pow10_wide[numZeros+1]))) {
-		/* Oops, it's overflowed, have to allocate a bignum */
-		TclBNInitBignumFromWideUInt (bignumRepPtr, *wideRepPtr);
-		bignumFlag = 1;
-	    }
-	}
+    if (!bignumFlag && *wideRepPtr!=0 && ((numZeros >= maxpow10_wide) ||
+	    *wideRepPtr > ((~(Tcl_WideUInt)0)-digit)/pow10_wide[numZeros+1])) {
+	/*
+	 * Oops, it's overflowed, have to allocate a bignum.
+	 */
+
+	TclBNInitBignumFromWideUInt (bignumRepPtr, *wideRepPtr);
+	bignumFlag = 1;
     }
 
-    /* Multiply the number by 10**numZeros+1 and add in the new digit. */
+    /*
+     * Multiply the number by 10**numZeros+1 and add in the new digit.
+     */
 
     if (!bignumFlag) {
-
-	/* Wide multiplication */
+	/*
+	 * Wide multiplication.
+	 */
 
 	*wideRepPtr = *wideRepPtr * pow10_wide[numZeros+1] + digit;
-    } else if (numZeros < log10_DIGIT_MAX ) {
-
-	/* Up to about 8 zeros - single digit multiplication */
-
-	mp_mul_d (bignumRepPtr, (mp_digit) pow10_wide[numZeros+1],
-		  bignumRepPtr);
-	mp_add_d (bignumRepPtr, (mp_digit) digit, bignumRepPtr);
+    } else if (numZeros < log10_DIGIT_MAX) {
+	/*
+	 * Up to about 8 zeros - single digit multiplication.
+	 */
 
+	mp_mul_d(bignumRepPtr, (mp_digit) pow10_wide[numZeros+1],
+		bignumRepPtr);
+	mp_add_d(bignumRepPtr, (mp_digit) digit, bignumRepPtr);
     } else {
-
 	/* 
 	 * More than single digit multiplication. Multiply by the appropriate
-	 * small powers of 5, and then shift.  Large strings of zeroes are
-	 * eaten 256 at a time; this is less efficient than it could be,
-	 * but seems implausible.  We presume that DIGIT_BIT is at least 27.
-	 * The first multiplication, by up to 10**7, is done with a
-	 * one-DIGIT multiply (this presumes that DIGIT_BIT >= 24).
+	 * small powers of 5, and then shift. Large strings of zeroes are
+	 * eaten 256 at a time; this is less efficient than it could be, but
+	 * seems implausible. We presume that DIGIT_BIT is at least 27. The
+	 * first multiplication, by up to 10**7, is done with a one-DIGIT
+	 * multiply (this presumes that DIGIT_BIT >= 24).
 	 */
 
 	n = numZeros + 1;
-	mp_mul_d (bignumRepPtr, (mp_digit) pow10_wide[n&0x7], bignumRepPtr);
-	for (i = 3; i <= 7; ++i) {
+	mp_mul_d(bignumRepPtr, (mp_digit) pow10_wide[n&0x7], bignumRepPtr);
+	for (i=3; i<=7; ++i) {
 	    if (n & (1 << i)) {
-		mp_mul (bignumRepPtr, pow5+i, bignumRepPtr);
+		mp_mul(bignumRepPtr, pow5+i, bignumRepPtr);
 	    }
 	}
 	while (n >= 256) {
-	    mp_mul (bignumRepPtr, pow5+8, bignumRepPtr);
+	    mp_mul(bignumRepPtr, pow5+8, bignumRepPtr);
 	    n -= 256;
 	}
-	mp_mul_2d (bignumRepPtr, (int)(numZeros+1)&~0x7, bignumRepPtr);
+	mp_mul_2d(bignumRepPtr, (int)(numZeros+1)&~0x7, bignumRepPtr);
     }
 
     return bignumFlag;
@@ -1266,24 +1228,21 @@ AccumulateDecimalDigit( unsigned digit,
  * Results:
  *	Returns the constructed number.
  *
- * Common cases, where there are few enough digits that the number can
- * be represented with at most roundoff, are handled specially here.
- * If the number requires more than one rounded operation to compute,
- * the code promotes the significand to a bignum and calls
- * MakeHighPrecisionDouble to do it instead.
+ *	Common cases, where there are few enough digits that the number can be
+ *	represented with at most roundoff, are handled specially here. If the
+ *	number requires more than one rounded operation to compute, the code
+ *	promotes the significand to a bignum and calls MakeHighPrecisionDouble
+ *	to do it instead.
  *
  *----------------------------------------------------------------------
  */
 
 static double
-MakeLowPrecisionDouble( int signum,
-				/* 1 if the number is negative, 0 otherwise */
-			Tcl_WideUInt significand,
-				/* Significand of the number */
-			int numSigDigs,
-				/* Number of digits in the significand */
-			int exponent )
-				/* Power of ten */
+MakeLowPrecisionDouble(
+    int signum,			/* 1 if the number is negative, 0 otherwise */
+    Tcl_WideUInt significand,	/* Significand of the number */
+    int numSigDigs,		/* Number of digits in the significand */
+    int exponent)		/* Power of ten */
 {
     double retval;		/* Value of the number */
     mp_int significandBig;	/* Significand expressed as a bignum */
@@ -1292,55 +1251,54 @@ MakeLowPrecisionDouble( int signum,
      * With gcc on x86, the floating point rounding mode is double-extended.
      * This causes the result of double-precision calculations to be rounded
      * twice: once to the precision of double-extended and then again to the
-     * precision of double.  Double-rounding introduces gratuitous errors of
-     * 1 ulp, so we need to change rounding mode to 53-bits.
+     * precision of double. Double-rounding introduces gratuitous errors of 1
+     * ulp, so we need to change rounding mode to 53-bits.
      */
 
 #if defined(__GNUC__) && defined(__i386)
     fpu_control_t roundTo53Bits = 0x027f;
     fpu_control_t oldRoundingMode;
-    _FPU_GETCW( oldRoundingMode );
-    _FPU_SETCW( roundTo53Bits );
+    _FPU_GETCW(oldRoundingMode);
+    _FPU_SETCW(roundTo53Bits);
 #endif
 
-    /* Test for the easy cases */
-
-    if ( numSigDigs <= DBL_DIG ) {
-	if ( exponent >= 0 ) {
-	    if ( exponent <= mmaxpow ) {
+    /*
+     * Test for the easy cases.
+     */
 
+    if (numSigDigs <= DBL_DIG) {
+	if (exponent >= 0) {
+	    if (exponent <= mmaxpow) {
 		/* 
-		 * The significand is an exact integer, and so is 
-		 * 10**exponent. The product will be correct to within
-		 * 1/2 ulp without special handling.
+		 * The significand is an exact integer, and so is
+		 * 10**exponent. The product will be correct to within 1/2 ulp
+		 * without special handling.
 		 */
 
 		retval = (double)(Tcl_WideInt)significand * pow10[ exponent ];
 		goto returnValue;
-
 	    } else {
 		int diff = DBL_DIG - numSigDigs;
-		if ( exponent-diff <= mmaxpow ) {
-
+		if (exponent-diff <= mmaxpow) {
 		    /* 
 		     * 10**exponent is not an exact integer, but
 		     * 10**(exponent-diff) is exact, and so is
-		     * significand*10**diff, so we can still compute
-		     * the value with only one roundoff.
+		     * significand*10**diff, so we can still compute the value
+		     * with only one roundoff.
 		     */
-		    volatile double factor
-			= (double)(Tcl_WideInt)significand * pow10[diff];
+
+		    volatile double factor =
+			    (double)(Tcl_WideInt)significand * pow10[diff];
 		    retval = factor * pow10[exponent-diff];
 		    goto returnValue;
 		}
 	    }
 	} else {
-	    if ( exponent >= -mmaxpow ) {
-
+	    if (exponent >= -mmaxpow) {
 		/* 
 		 * 10**-exponent is an exact integer, and so is the
-		 * significand. Compute the result by one division,
-		 * again with only one rounding.
+		 * significand. Compute the result by one division, again with
+		 * only one rounding.
 		 */
 
 		retval = (double)(Tcl_WideInt)significand / pow10[-exponent];
@@ -1350,26 +1308,29 @@ MakeLowPrecisionDouble( int signum,
     }
 
     /*
-     * All the easy cases have failed.  Promote ths significand
-     * to bignum and call MakeHighPrecisionDouble to do it the hard way.
+     * All the easy cases have failed. Promote ths significand to bignum and
+     * call MakeHighPrecisionDouble to do it the hard way.
      */
 
-    TclBNInitBignumFromWideUInt (&significandBig, significand);
-    retval = MakeHighPrecisionDouble( 0, &significandBig, numSigDigs,
-				      exponent );
+    TclBNInitBignumFromWideUInt(&significandBig, significand);
+    retval = MakeHighPrecisionDouble(0, &significandBig, numSigDigs,
+	    exponent);
     
-    /* Come here to return the computed value */
+    /*
+     * Come here to return the computed value.
+     */
 
   returnValue:
-
-    if ( signum ) {
+    if (signum) {
 	retval = -retval;
     }
 
-    /* On gcc on x86, restore the floating point mode word. */
+    /*
+     * On gcc on x86, restore the floating point mode word.
+     */
 
 #if defined(__GNUC__) && defined(__i386)
-    _FPU_SETCW( oldRoundingMode );
+    _FPU_SETCW(oldRoundingMode);
 #endif
 
     return retval;
@@ -1385,25 +1346,21 @@ MakeLowPrecisionDouble( int signum,
  * Results:
  *	Returns the constructed number.
  *
- * MakeHighPrecisionDouble is used when arbitrary-precision arithmetic
- * is needed to ensure correct rounding.  It begins by calculating a
- * low-precision approximation to the desired number, and then refines
- * the answer in high precision.
+ *	MakeHighPrecisionDouble is used when arbitrary-precision arithmetic is
+ *	needed to ensure correct rounding. It begins by calculating a
+ *	low-precision approximation to the desired number, and then refines
+ *	the answer in high precision.
  *
  *----------------------------------------------------------------------
  */
 
 static double
-MakeHighPrecisionDouble( int signum,
-				/* 1=negative, 0=nonnegative */
-			 mp_int* significand,
-				/* Exact significand of the number */
-			 int numSigDigs,
-				/* Number of significant digits */
-			 int exponent )
-				/* Power of 10 by which to multiply */
+MakeHighPrecisionDouble(
+    int signum,			/* 1=negative, 0=nonnegative */
+    mp_int *significand,	/* Exact significand of the number */
+    int numSigDigs,		/* Number of significant digits */
+    int exponent)		/* Power of 10 by which to multiply */
 {
-
     double retval;
     int machexp;		/* Machine exponent of a power of 10 */
 
@@ -1411,69 +1368,73 @@ MakeHighPrecisionDouble( int signum,
      * With gcc on x86, the floating point rounding mode is double-extended.
      * This causes the result of double-precision calculations to be rounded
      * twice: once to the precision of double-extended and then again to the
-     * precision of double.  Double-rounding introduces gratuitous errors of
-     * 1 ulp, so we need to change rounding mode to 53-bits.
+     * precision of double. Double-rounding introduces gratuitous errors of 1
+     * ulp, so we need to change rounding mode to 53-bits.
      */
 
 #if defined(__GNUC__) && defined(__i386)
     fpu_control_t roundTo53Bits = 0x027f;
     fpu_control_t oldRoundingMode;
-    _FPU_GETCW( oldRoundingMode );
-    _FPU_SETCW( roundTo53Bits );
+    _FPU_GETCW(oldRoundingMode);
+    _FPU_SETCW(roundTo53Bits);
 #endif
 
-    /* Quick checks for over/underflow */
+    /*
+     * Quick checks for over/underflow.
+     */
 
-    if ( numSigDigs + exponent - 1 > maxDigits ) {
+    if (numSigDigs+exponent-1 > maxDigits) {
 	retval = HUGE_VAL;
 	goto returnValue;
     }
-    if ( numSigDigs + exponent - 1 < minDigits ) {
+    if (numSigDigs+exponent-1 < minDigits) {
 	retval = 0;
 	goto returnValue;
     }
 
     /* 
-     * Develop a first approximation to the significand. It is tempting
-     * simply to force bignum to double, but that will overflow on input
-     * numbers like 1.[string repeat 0 1000]1; while this is a not terribly
-     * likely scenario, we still have to deal with it. Use fraction and
-     * exponent instead.  Once we have the significand, multiply by
-     * 10**exponent. Test for overflow. Convert back to a double, and
-     * test for underflow.
+     * Develop a first approximation to the significand. It is tempting simply
+     * to force bignum to double, but that will overflow on input numbers like
+     * 1.[string repeat 0 1000]1; while this is a not terribly likely
+     * scenario, we still have to deal with it. Use fraction and exponent
+     * instead. Once we have the significand, multiply by 10**exponent. Test
+     * for overflow. Convert back to a double, and test for underflow.
      */
 
-    retval = BignumToBiasedFrExp( significand, &machexp );
-    retval = Pow10TimesFrExp( exponent, retval, &machexp );
-    if ( machexp > DBL_MAX_EXP * log2FLT_RADIX ) {
+    retval = BignumToBiasedFrExp(significand, &machexp);
+    retval = Pow10TimesFrExp(exponent, retval, &machexp);
+    if (machexp > DBL_MAX_EXP*log2FLT_RADIX) {
 	retval = HUGE_VAL;
 	goto returnValue;
     }
-    retval = SafeLdExp( retval, machexp );
-    if ( retval < tiny ) {
+    retval = SafeLdExp(retval, machexp);
+    if (retval < tiny) {
 	retval = tiny;
     }
 
     /* 
-     * Refine the result twice. (The second refinement should be 
-     * necessary only if the best approximation is a power of 2
-     * minus 1/2 ulp).
+     * Refine the result twice. (The second refinement should be necessary
+     * only if the best approximation is a power of 2 minus 1/2 ulp).
      */
 
-    retval = RefineApproximation( retval, significand, exponent );
-    retval = RefineApproximation( retval, significand, exponent );
+    retval = RefineApproximation(retval, significand, exponent);
+    retval = RefineApproximation(retval, significand, exponent);
 
-    /* Come here to return the computed value */
+    /*
+     * Come here to return the computed value.
+     */
 
   returnValue:
-    if ( signum ) {
+    if (signum) {
 	retval = -retval;
     }
 
-    /* On gcc on x86, restore the floating point mode word. */
+    /*
+     * On gcc on x86, restore the floating point mode word.
+     */
 
 #if defined(__GNUC__) && defined(__i386)
-    _FPU_SETCW( oldRoundingMode );
+    _FPU_SETCW(oldRoundingMode);
 #endif
     return retval;
 }
@@ -1483,18 +1444,18 @@ MakeHighPrecisionDouble( int signum,
  *
  * MakeNaN --
  *
- *	Makes a "Not a Number" given a set of bits to put in the
- *	tag bits
+ *	Makes a "Not a Number" given a set of bits to put in the tag bits
  *
- * Note that a signalling NaN is never returned.
+ *	Note that a signalling NaN is never returned.
  *
  *----------------------------------------------------------------------
  */
 
 #ifdef IEEE_FLOATING_POINT
 static double
-MakeNaN( int signum,		/* Sign bit (1=negative, 0=nonnegative */
-	 Tcl_WideUInt tags ) 	/* Tag bits to put in the NaN */
+MakeNaN(
+    int signum,			/* Sign bit (1=negative, 0=nonnegative */
+    Tcl_WideUInt tags)	 	/* Tag bits to put in the NaN */
 {
     union {
 	Tcl_WideUInt iv;
@@ -1502,8 +1463,8 @@ MakeNaN( int signum,		/* Sign bit (1=negative, 0=nonnegative */
     } theNaN;
 
     theNaN.iv = tags;
-    theNaN.iv &= ( ((Tcl_WideUInt) 1) << 51 ) - 1;
-    if ( signum ) {
+    theNaN.iv &= (((Tcl_WideUInt) 1) << 51) - 1;
+    if (signum) {
 	theNaN.iv |= ((Tcl_WideUInt) (0x8000 | NAN_START)) << 48;
     } else {
 	theNaN.iv |= ((Tcl_WideUInt) NAN_START) << 48;
@@ -1518,10 +1479,9 @@ MakeNaN( int signum,		/* Sign bit (1=negative, 0=nonnegative */
  *
  * RefineApproximation --
  *
- *	Given a poor approximation to a floating point number, returns
- *	a better one (The better approximation is correct to within
- *	1 ulp, and is entirely correct if the poor approximation is
- *	correct to 1 ulp.)
+ *	Given a poor approximation to a floating point number, returns a
+ *	better one. (The better approximation is correct to within 1 ulp, and
+ *	is entirely correct if the poor approximation is correct to 1 ulp.)
  *
  * Results:
  *	Returns the improved result.
@@ -1530,109 +1490,104 @@ MakeNaN( int signum,		/* Sign bit (1=negative, 0=nonnegative */
  */
 
 static double
-RefineApproximation( double approxResult, 
-				/* Approximate result of conversion */
-		     mp_int* exactSignificand,
-				/* Integer significand */
-		     int exponent )
-				/* Power of 10 to multiply by significand */
+RefineApproximation(
+    double approxResult,	/* Approximate result of conversion */
+    mp_int *exactSignificand,	/* Integer significand */
+    int exponent)		/* Power of 10 to multiply by significand */
 {
-
-    int M2, M5;			/*  Powers of 2 and of 5 needed to put
-				 * the decimal and binary numbers over
-				 * a common denominator. */
+    int M2, M5;			/* Powers of 2 and of 5 needed to put the
+				 * decimal and binary numbers over a common
+				 * denominator. */
     double significand;		/* Sigificand of the binary number */
     int binExponent;		/* Exponent of the binary number */
-
     int msb;			/* Most significant bit position of an
 				 * intermediate result */
     int nDigits;		/* Number of mp_digit's in an intermediate
 				 * result */
-    mp_int twoMv;		/* Approx binary value expressed as an
-				 * exact integer scaled by the multiplier 2M */
-    mp_int twoMd;		/* Exact decimal value expressed as an
-				 * exact integer scaled by the multiplier 2M */
+    mp_int twoMv;		/* Approx binary value expressed as an exact
+				 * integer scaled by the multiplier 2M */
+    mp_int twoMd;		/* Exact decimal value expressed as an exact
+				 * integer scaled by the multiplier 2M */
     int scale;			/* Scale factor for M */
     int multiplier;		/* Power of two to scale M */
-    double num, den;		/* Numerator and denominator of the
-				 * correction term */
+    double num, den;		/* Numerator and denominator of the correction
+				 * term */
     double quot;		/* Correction term */
-    double minincr;		/* Lower bound on the absolute value
-				 * of the correction term. */
+    double minincr;		/* Lower bound on the absolute value of the
+				 * correction term. */
     int i;
 
     /*
-     * The first approximation is always low.  If we find that
-     * it's HUGE_VAL, we're done.
+     * The first approximation is always low. If we find that it's HUGE_VAL,
+     * we're done.
      */
 
-    if ( approxResult == HUGE_VAL ) {
+    if (approxResult == HUGE_VAL) {
 	return approxResult;
     }
 
     /*
-     * Find a common denominator for the decimal and binary fractions.
-     * The common denominator will be 2**M2 + 5**M5.
+     * Find a common denominator for the decimal and binary fractions. The
+     * common denominator will be 2**M2 + 5**M5.
      */
 
-    significand = frexp( approxResult, &binExponent );
+    significand = frexp(approxResult, &binExponent);
     i = mantBits - binExponent;
-    if ( i < 0 ) {
+    if (i < 0) {
 	M2 = 0;
     } else {
 	M2 = i;
     }
-    if ( exponent > 0 ) {
+    if (exponent > 0) {
 	M5 = 0;
     } else {
 	M5 = -exponent;
-	if ( (M5-1) > M2 ) {
+	if ((M5-1) > M2) {
 	    M2 = M5-1;
 	}
     }
 
     /* 
-     * The floating point number is significand*2**binExponent.
-     * Compute the large integer significand*2**(binExponent+M2+1)
-     * The 2**-1 bit of the significand (the most significant) 
-     * corresponds to the 2**(binExponent+M2 + 1) bit of 2*M2*v.
-     * Allocate enough digits to hold that quantity, then
-     * convert the significand to a large integer, scaled
+     * The floating point number is significand*2**binExponent. Compute the
+     * large integer significand*2**(binExponent+M2+1). The 2**-1 bit of the
+     * significand (the most significant) corresponds to the
+     * 2**(binExponent+M2 + 1) bit of 2*M2*v. Allocate enough digits to hold
+     * that quantity, then convert the significand to a large integer, scaled
      * appropriately. Then multiply by the appropriate power of 5.
      */
 
-    msb = binExponent + M2;  /* 1008 */
+    msb = binExponent + M2;	/* 1008 */
     nDigits = msb / DIGIT_BIT + 1;
-    mp_init_size( &twoMv, nDigits );
-    i = ( msb % DIGIT_BIT + 1 ); 
+    mp_init_size(&twoMv, nDigits);
+    i = (msb % DIGIT_BIT + 1);
     twoMv.used = nDigits;
-    significand *= SafeLdExp( 1.0, i );
-    while ( -- nDigits >= 0 ) {
+    significand *= SafeLdExp(1.0, i);
+    while (--nDigits >= 0) {
 	twoMv.dp[nDigits] = (mp_digit) significand;
 	significand -= (mp_digit) significand;
-	significand = SafeLdExp( significand, DIGIT_BIT );
+	significand = SafeLdExp(significand, DIGIT_BIT);
     }
-    for ( i = 0; i <= 8; ++i ) {
-	if ( M5 & ( 1 << i ) ) {
-	    mp_mul( &twoMv, pow5+i, &twoMv );
+    for (i = 0; i <= 8; ++i) {
+	if (M5 & (1 << i)) {
+	    mp_mul(&twoMv, pow5+i, &twoMv);
 	}
     }
     
     /* 
-     * Collect the decimal significand as a high precision integer.
-     * The least significant bit corresponds to bit M2+exponent+1
-     * so it will need to be shifted left by that many bits after
-     * being multiplied by 5**(M5+exponent).
+     * Collect the decimal significand as a high precision integer. The least
+     * significant bit corresponds to bit M2+exponent+1 so it will need to be
+     * shifted left by that many bits after being multiplied by
+     * 5**(M5+exponent).
      */
 
-    mp_init_copy( &twoMd, exactSignificand );
-    for ( i = 0; i <= 8; ++i ) {
-	if ( (M5+exponent) & ( 1 << i ) ) {
-	    mp_mul( &twoMd, pow5+i, &twoMd );
+    mp_init_copy(&twoMd, exactSignificand);
+    for (i=0; i<=8; ++i) {
+	if ((M5+exponent) & (1 << i)) {
+	    mp_mul(&twoMd, pow5+i, &twoMd);
 	}
     }
-    mp_mul_2d( &twoMd, M2+exponent+1, &twoMd );
-    mp_sub( &twoMd, &twoMv, &twoMd );
+    mp_mul_2d(&twoMd, M2+exponent+1, &twoMd);
+    mp_sub(&twoMd, &twoMv, &twoMd);
 
     /*
      * The result, 2Mv-2Md, needs to be divided by 2M to yield a correction
@@ -1642,49 +1597,48 @@ RefineApproximation( double approxResult,
 
     scale = binExponent - mantBits - 1;
 
-    mp_set( &twoMv, 1 );
-    for ( i = 0; i <= 8; ++i ) {
-	if ( M5 & ( 1 << i ) ) {
-	    mp_mul( &twoMv, pow5+i, &twoMv );
+    mp_set(&twoMv, 1);
+    for (i=0; i<=8; ++i) {
+	if (M5 & (1 << i)) {
+	    mp_mul(&twoMv, pow5+i, &twoMv);
 	}
     }
     multiplier = M2 + scale + 1;
-    if ( multiplier > 0 ) {
-	mp_mul_2d( &twoMv, multiplier, &twoMv );
-    } else if ( multiplier < 0 ) {
-	mp_div_2d( &twoMv, -multiplier, &twoMv, NULL );
+    if (multiplier > 0) {
+	mp_mul_2d(&twoMv, multiplier, &twoMv);
+    } else if (multiplier < 0) {
+	mp_div_2d(&twoMv, -multiplier, &twoMv, NULL);
     }
 
     /*
-     * If the result is less than unity, the error is less than 1/2 unit
-     * in the last place, so there's no correction to make.
+     * If the result is less than unity, the error is less than 1/2 unit in
+     * the last place, so there's no correction to make.
      */
 
-    if ( mp_cmp_mag( &twoMd, &twoMv ) == MP_LT ) {
+    if (mp_cmp_mag(&twoMd, &twoMv) == MP_LT) {
 	return approxResult;
     }
 
     /* 
-     * Convert the numerator and denominator of the corrector term
-     * accurately to floating point numbers.
+     * Convert the numerator and denominator of the corrector term accurately
+     * to floating point numbers.
      */
 
-    num = TclBignumToDouble( &twoMd );
-    den = TclBignumToDouble( &twoMv );
+    num = TclBignumToDouble(&twoMd);
+    den = TclBignumToDouble(&twoMv);
 
-    quot = SafeLdExp( num/den, scale );
-    minincr = SafeLdExp( 1.0, binExponent - mantBits );
+    quot = SafeLdExp(num/den, scale);
+    minincr = SafeLdExp(1.0, binExponent-mantBits);
 
-    if ( quot < 0. && quot > -minincr ) {
+    if (quot<0. && quot>-minincr) {
 	quot = -minincr;
-    } else if ( quot > 0. && quot < minincr ) {
+    } else if (quot>0. && quot<minincr) {
 	quot = minincr;
     }
 
-    mp_clear( &twoMd );
-    mp_clear( &twoMv );
+    mp_clear(&twoMd);
+    mp_clear(&twoMv);
 
-    
     return approxResult + quot;
 }
 
@@ -1697,7 +1651,7 @@ RefineApproximation( double approxResult,
  *
  * Results:
  *	Returns the position of the character in the string after which the
- *	decimal point should appear.  Since the string contains only
+ *	decimal point should appear. Since the string contains only
  *	significant digits, the position may be less than zero or greater than
  *	the length of the string.
  *
@@ -1706,24 +1660,26 @@ RefineApproximation( double approxResult,
  *	the sign of the number.
  *
  *----------------------------------------------------------------------
+
  */
 
 int
-TclDoubleDigits( char * string,	/* Buffer in which to store the result,
-				 * must have at least 18 chars */
-		 double v,	/* Number to convert. Must be
-				 * finite, and not NaN */
-		 int *signum )	/* Output: 1 if the number is negative.
-				 * Should handle -0 correctly on the
-				 * IEEE architecture. */
+TclDoubleDigits(
+    char *string,		/* Buffer in which to store the result, must
+				 * have at least 18 chars */
+    double v,			/* Number to convert. Must be finite, and not
+				 * NaN */
+    int *signum)		/* Output: 1 if the number is negative.
+				 * Should handle -0 correctly on the IEEE
+				 * architecture. */
 {
     int e;			/* Power of FLT_RADIX that satisfies
 				 * v = f * FLT_RADIX**e */
     int lowOK, highOK;
     mp_int r;			/* Scaled significand. */
     mp_int s;			/* Divisor such that v = r / s */
-    int smallestSig;		/* Flag == 1 iff v's significand is
-				 * the smallest that can be represented. */
+    int smallestSig;		/* Flag == 1 iff v's significand is the
+				 * smallest that can be represented. */
     mp_int mplus;		/* Scaled epsilon: (r + 2* mplus) == v(+)
 				 * where v(+) is the floating point successor
 				 * of v. */
@@ -1740,7 +1696,9 @@ TclDoubleDigits( char * string,	/* Buffer in which to store the result,
     char c;
     int i, k, n;
 
-    /* Split the number into absolute value and signum. */
+    /*
+     * Split the number into absolute value and signum.
+     */
 
     v = AbsoluteValue(v, signum);
 
@@ -1748,7 +1706,7 @@ TclDoubleDigits( char * string,	/* Buffer in which to store the result,
      * Handle zero specially.
      */
 
-    if ( v == 0.0 ) {
+    if (v == 0.0) {
 	*string++ = '0';
 	*string++ = '\0';
 	return 1;
@@ -1757,8 +1715,8 @@ TclDoubleDigits( char * string,	/* Buffer in which to store the result,
     /* 
      * Find a large integer r, and integer e, such that 
      *         v = r * FLT_RADIX**e
-     * and r is as small as possible.  Also determine whether the
-     * significand is the smallest possible.
+     * and r is as small as possible. Also determine whether the significand
+     * is the smallest possible.
      */
 
     smallestSig = GetIntegerTimesPower(v, &r, &e);
@@ -1807,7 +1765,7 @@ TclDoubleDigits( char * string,	/* Buffer in which to store the result,
 	if (e <= DBL_MIN_EXP-DBL_MANT_DIG || !smallestSig) {
 	    /*
 	     * Either f isn't the smallest significand or e is the smallest
-	     * exponent.  mplus and mminus will both be 1.
+	     * exponent. mplus and mminus will both be 1.
 	     */
 
 	    rfac2 = 1;
@@ -1892,7 +1850,7 @@ TclDoubleDigits( char * string,	/* Buffer in which to store the result,
     /*
      * At this point, k contains the power of ten by which we're scaling the
      * result. r/s is at least 1/10 and strictly less than ten, and v = r/s *
-     * 10**k.  mplus and mminus give the rounding limits.
+     * 10**k. mplus and mminus give the rounding limits.
      */
 
     for (;;) {
@@ -1916,8 +1874,8 @@ TclDoubleDigits( char * string,	/* Buffer in which to store the result,
 	} else {
 	    tc2= (tc2 > 0);
 	}
-	if ( ! tc1 ) {
-	    if ( !tc2 ) {
+	if (!tc1) {
+	    if (!tc2) {
 		*string++ = '0' + i;
 	    } else {
 		c = (char) (i + '1');
@@ -1966,8 +1924,9 @@ TclDoubleDigits( char * string,	/* Buffer in which to store the result,
  */
 
 static double
-AbsoluteValue (double v,	/* Number to split */
-	       int* signum)	/* (Output) Sign of the number 1=-, 0=+ */
+AbsoluteValue(
+    double v,			/* Number to split */
+    int *signum)		/* (Output) Sign of the number 1=-, 0=+ */
 {
     /*
      * Take the absolute value of the number, and report the number's sign.
@@ -2005,32 +1964,28 @@ AbsoluteValue (double v,	/* Number to split */
  *
  * GetIntegerTimesPower --
  *
- *	Converts a floating point number to an exact integer times a
- *	power of the floating point radix.
+ *	Converts a floating point number to an exact integer times a power of
+ *	the floating point radix.
  *
  * Results:
  *	Returns 1 if it converted the smallest significand, 0 otherwise.
  *
  * Side effects:
- *	Initializes the integer value (does not just assign it),
- *	and stores the exponent.
+ *	Initializes the integer value (does not just assign it), and stores
+ *	the exponent.
  *
  *----------------------------------------------------------------------
  */
 
 static int
-GetIntegerTimesPower(double v,	/* Value to convert */
-		     mp_int* rPtr,
-				/* (Output) Integer value */
-		     int* ePtr)	/* (Output) Power of FLT_RADIX by which
-				 * r must be multiplied to yield v*/
+GetIntegerTimesPower(
+    double v,			/* Value to convert */
+    mp_int *rPtr,		/* (Output) Integer value */
+    int *ePtr)			/* (Output) Power of FLT_RADIX by which r must
+				 * be multiplied to yield v*/
 {
-
-    double a;
-    double f;
-    int e;
-    int i;
-    int n;
+    double a, f;
+    int e, i, n;
 
     /*
      * Develop f and e such that v = f * FLT_RADIX**e, with
@@ -2122,10 +2077,10 @@ TclInitDoubleConversion(void)
      * Initialize table of powers of 10 expressed as wide integers.
      */
 
-    maxpow10_wide =
-	(int) floor(sizeof (Tcl_WideUInt) * CHAR_BIT * log (2.) / log (10.));
-    pow10_wide = (Tcl_WideUInt*) Tcl_Alloc ((maxpow10_wide + 1)
-					    * sizeof (Tcl_WideUInt));
+    maxpow10_wide = (int)
+	    floor(sizeof(Tcl_WideUInt) * CHAR_BIT * log(2.) / log(10.));
+    pow10_wide = (Tcl_WideUInt *)
+	    Tcl_Alloc((maxpow10_wide + 1) * sizeof(Tcl_WideUInt));
     u = 1;
     for (i = 0; i < maxpow10_wide; ++i) {
 	pow10_wide[i] = u;
@@ -2138,8 +2093,8 @@ TclInitDoubleConversion(void)
      * decimal digits that represents.
      */
 
-    if ( frexp( (double) FLT_RADIX, &log2FLT_RADIX ) != 0.5 ) {
-	Tcl_Panic( "This code doesn't work on a decimal machine!" );
+    if (frexp((double) FLT_RADIX, &log2FLT_RADIX) != 0.5) {
+	Tcl_Panic("This code doesn't work on a decimal machine!");
     }
     --log2FLT_RADIX;
     mantBits = DBL_MANT_DIG * log2FLT_RADIX;
@@ -2150,8 +2105,8 @@ TclInitDoubleConversion(void)
      * in a double.
      */
 
-    x = (int) (DBL_MANT_DIG * log((double) FLT_RADIX) / log( 5.0 ));
-    if ( x < MAXPOW ) {
+    x = (int) (DBL_MANT_DIG * log((double) FLT_RADIX) / log(5.0));
+    if (x < MAXPOW) {
 	mmaxpow = x;
     } else {
 	mmaxpow = MAXPOW;
@@ -2161,14 +2116,16 @@ TclInitDoubleConversion(void)
 	d *= 10.0;
     }
 
-    /* Initialize a table of large powers of five. */
+    /*
+     * Initialize a table of large powers of five.
+     */
 
-    for ( i = 0; i < 9; ++i ) {
-	mp_init( pow5 + i );
+    for (i=0; i<9; ++i) {
+	mp_init(pow5 + i);
     }
-    mp_set( pow5, 5 );
-    for ( i = 0; i < 8; ++i ) {
-	mp_sqr( pow5+i, pow5+i+1 );
+    mp_set(pow5, 5);
+    for (i=0; i<8; ++i) {
+	mp_sqr(pow5+i, pow5+i+1);
     }
 
     /* 
@@ -2178,14 +2135,13 @@ TclInitDoubleConversion(void)
      * the significand of a double.
      */
 
-    tiny = SafeLdExp( 1.0, DBL_MIN_EXP * log2FLT_RADIX - mantBits );
+    tiny = SafeLdExp(1.0, DBL_MIN_EXP * log2FLT_RADIX - mantBits);
     maxDigits = (int) ((DBL_MAX_EXP * log((double) FLT_RADIX)
-			+ 0.5 * log(10.))
-		       / log( 10. ));
-    minDigits = (int) floor ( ( DBL_MIN_EXP - DBL_MANT_DIG )
-			      * log( (double) FLT_RADIX ) / log( 10. ) );
-    mantDIGIT = ( mantBits + DIGIT_BIT - 1 ) / DIGIT_BIT;
-    log10_DIGIT_MAX = (int) floor (DIGIT_BIT * log(2.) / log (10.));
+	    + 0.5 * log(10.)) / log(10.));
+    minDigits = (int) floor((DBL_MIN_EXP - DBL_MANT_DIG)
+	    * log((double) FLT_RADIX) / log(10.));
+    mantDIGIT = (mantBits + DIGIT_BIT-1) / DIGIT_BIT;
+    log10_DIGIT_MAX = (int) floor(DIGIT_BIT * log(2.) / log(10.));
 }
 
 /*
@@ -2208,9 +2164,10 @@ void
 TclFinalizeDoubleConversion()
 {
     int i;
-    Tcl_Free ((char*)pow10_wide);
-    for ( i = 0; i < 9; ++i ) {
-	mp_clear( pow5 + i );
+
+    Tcl_Free((char*)pow10_wide);
+    for (i=0; i<9; ++i) {
+	mp_clear(pow5 + i);
     }
 }
 
@@ -2219,28 +2176,32 @@ TclFinalizeDoubleConversion()
  *
  * TclInitBignumFromDouble --
  *
- *	Extracts the integer part of a double and converts it to
- *	an arbitrary precision integer.
+ *	Extracts the integer part of a double and converts it to an arbitrary
+ *	precision integer.
  *
  * Results:
  *	None.
  *
  * Side effects:
- *	Initializes the bignum supplied, and stores the converted number
- *      in it.
+ *	Initializes the bignum supplied, and stores the converted number * in
+ *	it.
  *
  *----------------------------------------------------------------------
  */
 
 int
-TclInitBignumFromDouble(Tcl_Interp *interp,	/* For error message */
-			double d,	/* Number to convert */
-			mp_int* b)	/* Place to store the result */
+TclInitBignumFromDouble(
+    Tcl_Interp *interp,		/* For error message */
+    double d,			/* Number to convert */
+    mp_int *b)			/* Place to store the result */
 {
     double fract;
     int expt;
 
-    /* Infinite values can't convert to bignum */
+    /*
+     * Infinite values can't convert to bignum.
+     */
+
     if (TclIsInfinite(d)) {
 	if (interp != NULL) {
 	    char *s = "integer value too large to represent";
@@ -2249,6 +2210,7 @@ TclInitBignumFromDouble(Tcl_Interp *interp,	/* For error message */
 	}
 	return TCL_ERROR;
     }
+
     fract = frexp(d,&expt);
     if (expt <= 0) {
 	mp_init(b);
@@ -2256,6 +2218,7 @@ TclInitBignumFromDouble(Tcl_Interp *interp,	/* For error message */
     } else {
 	Tcl_WideInt w = (Tcl_WideInt) ldexp(fract, mantBits);
 	int shift = expt - mantBits;
+
 	TclBNInitBignumFromWideInt(b, w);
 	if (shift < 0) {
 	    mp_div_2d(b, -shift, b, NULL);
@@ -2275,14 +2238,15 @@ TclInitBignumFromDouble(Tcl_Interp *interp,	/* For error message */
  *	number.
  *
  * Results:
- *	Returns the converted number.  Sets errno to ERANGE if the number is
+ *	Returns the converted number. Sets errno to ERANGE if the number is
  *	too large to convert.
  *
  *----------------------------------------------------------------------
  */
 
 double
-TclBignumToDouble(mp_int *a)	/* Integer to convert. */
+TclBignumToDouble(
+    mp_int *a)			/* Integer to convert. */
 {
     mp_int b;
     int bits;
@@ -2344,7 +2308,8 @@ TclBignumToDouble(mp_int *a)	/* Integer to convert. */
 }
 
 double
-TclCeil(mp_int *a)	/* Integer to convert. */
+TclCeil(
+    mp_int *a)			/* Integer to convert. */
 {
     double r = 0.0;
     mp_int b;
@@ -2386,7 +2351,8 @@ TclCeil(mp_int *a)	/* Integer to convert. */
 }
 
 double
-TclFloor(mp_int *a)	/* Integer to convert. */
+TclFloor(
+    mp_int *a)			/* Integer to convert. */
 {
     double r = 0.0;
     mp_int b;
@@ -2425,11 +2391,11 @@ TclFloor(mp_int *a)	/* Integer to convert. */
  *
  * BignumToBiasedFrExp --
  *
- *	Convert an arbitrary-precision integer to a native floating
- *	point number in the range [0.5,1) times a power of two.
- *	NOTE: Intentionally converts to a number that's a few
- *	ulp too small, so that RefineApproximation will not overflow
- *	near the high end of the machine's arithmetic range.
+ *	Convert an arbitrary-precision integer to a native floating point
+ *	number in the range [0.5,1) times a power of two. NOTE: Intentionally
+ *	converts to a number that's a few ulp too small, so that
+ *	RefineApproximation will not overflow near the high end of the
+ *	machine's arithmetic range.
  *
  * Results:
  *	Returns the converted number.
@@ -2441,10 +2407,9 @@ TclFloor(mp_int *a)	/* Integer to convert. */
  */
 
 static double
-BignumToBiasedFrExp( mp_int* a,
-				/* Integer to convert */
-		     int* machexp )
-				/* Power of two */
+BignumToBiasedFrExp(
+    mp_int *a,			/* Integer to convert */
+    int *machexp)		/* Power of two */
 {
     mp_int b;
     int bits;
@@ -2452,36 +2417,38 @@ BignumToBiasedFrExp( mp_int* a,
     int i;
     double r;
 
-    /* Determine how many bits we need, and extract that many from 
-     * the input. Round to nearest unit in the last place. */
+    /*
+     * Determine how many bits we need, and extract that many from the input.
+     * Round to nearest unit in the last place.
+     */
 
-    bits = mp_count_bits( a );
+    bits = mp_count_bits(a);
     shift = mantBits - 2 - bits;
-    mp_init( &b );
-    if ( shift > 0 ) {
-	mp_mul_2d( a, shift, &b );
-    } else if ( shift < 0 ) {
-	mp_div_2d( a, -shift, &b, NULL );
+    mp_init(&b);
+    if (shift > 0) {
+	mp_mul_2d(a, shift, &b);
+    } else if (shift < 0) {
+	mp_div_2d(a, -shift, &b, NULL);
     } else {
-	mp_copy( a, &b );
+	mp_copy(a, &b);
     }
 
-    /* Accumulate the result, one mp_digit at a time */
+    /*
+     * Accumulate the result, one mp_digit at a time.
+     */
 
     r = 0.0;
-    for ( i = b.used-1; i >= 0; --i ) {
-	r = ldexp( r, DIGIT_BIT ) + b.dp[i];
+    for (i=b.used-1; i>=0; --i) {
+	r = ldexp(r, DIGIT_BIT) + b.dp[i];
     }
-    mp_clear( &b );
+    mp_clear(&b);
 
-    /* Return the result with the appropriate sign. */
+    /*
+     * Return the result with the appropriate sign.
+     */
 
     *machexp = bits - mantBits + 2;
-    if ( a->sign == MP_ZPOS ) {
-	return r;
-    } else {
-	return -r;
-    }
+    return ((a->sign == MP_ZPOS) ? r : -r);
 }
 
 /*
@@ -2496,47 +2463,48 @@ BignumToBiasedFrExp( mp_int* a,
  *	Returns the significand of the result.
  *
  * Side effects:
- *	Overwrites the 'machexp' parameter with the exponent of the
- *	result.
+ *	Overwrites the 'machexp' parameter with the exponent of the result.
  *
- * Assumes that 'exponent' is such that 10**exponent would be a double,
- * even though 'fraction*10**(machexp+exponent)' might overflow.
+ * Assumes that 'exponent' is such that 10**exponent would be a double, even
+ * though 'fraction*10**(machexp+exponent)' might overflow.
  *
  *----------------------------------------------------------------------
  */
 
 static double
-Pow10TimesFrExp( int exponent, 	/* Power of 10 to multiply by */
-		 double fraction,
-				/* Significand of multiplicand */
-		 int* machexp )	/* On input, exponent of multiplicand.
-				 * On output, exponent of result. */
+Pow10TimesFrExp(
+    int exponent,	 	/* Power of 10 to multiply by */
+    double fraction,		/* Significand of multiplicand */
+    int *machexp)		/* On input, exponent of multiplicand. On
+				 * output, exponent of result. */
 {
     int i, j;
     int expt = *machexp;
     double retval = fraction;
 
-    if ( exponent > 0 ) {
-
-	/* Multiply by 10**exponent */
+    if (exponent > 0) {
+	/*
+	 * Multiply by 10**exponent
+	 */
 	
-	retval = frexp( retval * pow10[ exponent & 0xf ], &j );
+	retval = frexp(retval * pow10[exponent&0xf], &j);
 	expt += j;
-	for ( i = 4; i < 9; ++i ) {
-	    if ( exponent & (1<<i) ) {
-		retval = frexp( retval * pow_10_2_n[ i ], &j );
+	for (i=4; i<9; ++i) {
+	    if (exponent & (1<<i)) {
+		retval = frexp(retval * pow_10_2_n[i], &j);
 		expt += j;
 	    }
 	}
-    } else if ( exponent < 0 ) {
-
-	/* Divide by 10**-exponent */
+    } else if (exponent < 0) {
+	/*
+	 * Divide by 10**-exponent
+	 */
 
-	retval = frexp( retval / pow10[ (-exponent) & 0xf ], &j );
+	retval = frexp(retval / pow10[(-exponent) & 0xf], &j);
 	expt += j;
-	for ( i = 4; i < 9; ++i ) {
-	    if ( (-exponent) & (1<<i) ) {
-		retval = frexp( retval / pow_10_2_n[ i ], &j );
+	for (i=4; i<9; ++i) {
+	    if ((-exponent) & (1<<i)) {
+		retval = frexp(retval / pow_10_2_n[i], &j);
 		expt += j;
 	    }
 	}
@@ -2544,7 +2512,6 @@ Pow10TimesFrExp( int exponent, 	/* Power of 10 to multiply by */
 
     *machexp = expt;
     return retval;
-    
 }
 
 /*
@@ -2566,10 +2533,13 @@ Pow10TimesFrExp( int exponent, 	/* Power of 10 to multiply by */
  */
 
 static double
-SafeLdExp(double fract, int expt)
+SafeLdExp(
+    double fract,
+    int expt)
 {
     int minexpt = DBL_MIN_EXP * log2FLT_RADIX;
     volatile double a, b, retval;
+
     if (expt < minexpt) {
 	a = ldexp(fract, expt - mantBits - minexpt);
 	b = ldexp(1.0, mantBits + minexpt);
@@ -2598,8 +2568,9 @@ SafeLdExp(double fract, int expt)
  */
 
 void
-TclFormatNaN(double value,	/* The Not-a-Number to format. */
-	     char *buffer)	/* String representation. */
+TclFormatNaN(
+    double value,		/* The Not-a-Number to format. */
+    char *buffer)		/* String representation. */
 {
 #ifndef IEEE_FLOATING_POINT
     strcpy(buffer, "NaN");
@@ -2626,3 +2597,11 @@ TclFormatNaN(double value,	/* The Not-a-Number to format. */
     }
 #endif /* IEEE_FLOATING_POINT */
 }
+
+/*
+ * Local Variables:
+ * mode: c
+ * c-basic-offset: 4
+ * fill-column: 78
+ * End:
+ */