8.4 pgindent run, with new combined Linux/FreeBSD/MinGW typedef list

provided by Andrew.

1 files changed, 48 insertions, 44 deletions

diff --git a/src/backend/utils/adt/numeric.c b/src/backend/utils/adt/numeric.c
index 0fbca231756..ba3721b12b3 100644
--- a/src/backend/utils/adt/numeric.c
+++ b/src/backend/utils/adt/numeric.c
@@ -14,7 +14,7 @@
  * Copyright (c) 1998-2009, PostgreSQL Global Development Group
  *
  * IDENTIFICATION
- *	  $PostgreSQL: pgsql/src/backend/utils/adt/numeric.c,v 1.117 2009/04/08 22:08:40 tgl Exp $
+ *	  $PostgreSQL: pgsql/src/backend/utils/adt/numeric.c,v 1.118 2009/06/11 14:49:03 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -90,7 +90,7 @@ typedef int16 NumericDigit;
 
 
 /* ----------
- * NumericVar is the format we use for arithmetic.  The digit-array part
+ * NumericVar is the format we use for arithmetic.	The digit-array part
  * is the same as the NumericData storage format, but the header is more
  * complex.
  *
@@ -243,7 +243,7 @@ static void free_var(NumericVar *var);
 static void zero_var(NumericVar *var);
 
 static const char *set_var_from_str(const char *str, const char *cp,
-									NumericVar *dest);
+				 NumericVar *dest);
 static void set_var_from_num(Numeric value, NumericVar *dest);
 static void set_var_from_var(NumericVar *value, NumericVar *dest);
 static char *get_str_from_var(NumericVar *var, int dscale);
@@ -271,7 +271,7 @@ static void mul_var(NumericVar *var1, NumericVar *var2, NumericVar *result,
 static void div_var(NumericVar *var1, NumericVar *var2, NumericVar *result,
 		int rscale, bool round);
 static void div_var_fast(NumericVar *var1, NumericVar *var2, NumericVar *result,
-		int rscale, bool round);
+			 int rscale, bool round);
 static int	select_div_scale(NumericVar *var1, NumericVar *var2);
 static void mod_var(NumericVar *var1, NumericVar *var2, NumericVar *result);
 static void ceil_var(NumericVar *var, NumericVar *result);
@@ -348,8 +348,8 @@ numeric_in(PG_FUNCTION_ARGS)
 			if (!isspace((unsigned char) *cp))
 				ereport(ERROR,
 						(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
-					 errmsg("invalid input syntax for type numeric: \"%s\"",
-							str)));
+					  errmsg("invalid input syntax for type numeric: \"%s\"",
+							 str)));
 			cp++;
 		}
 	}
@@ -367,16 +367,16 @@ numeric_in(PG_FUNCTION_ARGS)
 		/*
 		 * We duplicate a few lines of code here because we would like to
 		 * throw any trailing-junk syntax error before any semantic error
-		 * resulting from apply_typmod.  We can't easily fold the two
-		 * cases together because we mustn't apply apply_typmod to a NaN.
+		 * resulting from apply_typmod.  We can't easily fold the two cases
+		 * together because we mustn't apply apply_typmod to a NaN.
 		 */
 		while (*cp)
 		{
 			if (!isspace((unsigned char) *cp))
 				ereport(ERROR,
 						(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
-					 errmsg("invalid input syntax for type numeric: \"%s\"",
-							str)));
+					  errmsg("invalid input syntax for type numeric: \"%s\"",
+							 str)));
 			cp++;
 		}
 
@@ -1938,8 +1938,8 @@ numeric_power(PG_FUNCTION_ARGS)
 
 	/*
 	 * The SQL spec requires that we emit a particular SQLSTATE error code for
-	 * certain error conditions.  Specifically, we don't return a divide-by-zero
-	 * error code for 0 ^ -1.
+	 * certain error conditions.  Specifically, we don't return a
+	 * divide-by-zero error code for 0 ^ -1.
 	 */
 	if (cmp_var(&arg1, &const_zero) == 0 &&
 		cmp_var(&arg2, &const_zero) < 0)
@@ -2654,9 +2654,9 @@ int2_sum(PG_FUNCTION_ARGS)
 	/*
 	 * If we're invoked by nodeAgg, we can cheat and modify our first
 	 * parameter in-place to avoid palloc overhead. If not, we need to return
-	 * the new value of the transition variable.
-	 * (If int8 is pass-by-value, then of course this is useless as well
-	 * as incorrect, so just ifdef it out.)
+	 * the new value of the transition variable. (If int8 is pass-by-value,
+	 * then of course this is useless as well as incorrect, so just ifdef it
+	 * out.)
 	 */
 #ifndef USE_FLOAT8_BYVAL		/* controls int8 too */
 	if (fcinfo->context &&
@@ -2705,9 +2705,9 @@ int4_sum(PG_FUNCTION_ARGS)
 	/*
 	 * If we're invoked by nodeAgg, we can cheat and modify our first
 	 * parameter in-place to avoid palloc overhead. If not, we need to return
-	 * the new value of the transition variable.
-	 * (If int8 is pass-by-value, then of course this is useless as well
-	 * as incorrect, so just ifdef it out.)
+	 * the new value of the transition variable. (If int8 is pass-by-value,
+	 * then of course this is useless as well as incorrect, so just ifdef it
+	 * out.)
 	 */
 #ifndef USE_FLOAT8_BYVAL		/* controls int8 too */
 	if (fcinfo->context &&
@@ -4209,6 +4209,7 @@ div_var(NumericVar *var1, NumericVar *var2, NumericVar *result,
 	/* If rounding needed, figure one more digit to ensure correct result */
 	if (round)
 		res_ndigits++;
+
 	/*
 	 * The working dividend normally requires res_ndigits + var2ndigits
 	 * digits, but make it at least var1ndigits so we can load all of var1
@@ -4222,8 +4223,8 @@ div_var(NumericVar *var1, NumericVar *var2, NumericVar *result,
 	/*
 	 * We need a workspace with room for the working dividend (div_ndigits+1
 	 * digits) plus room for the possibly-normalized divisor (var2ndigits
-	 * digits).  It is convenient also to have a zero at divisor[0] with
-	 * the actual divisor data in divisor[1 .. var2ndigits].  Transferring the
+	 * digits).  It is convenient also to have a zero at divisor[0] with the
+	 * actual divisor data in divisor[1 .. var2ndigits].  Transferring the
 	 * digits into the workspace also allows us to realloc the result (which
 	 * might be the same as either input var) before we begin the main loop.
 	 * Note that we use palloc0 to ensure that divisor[0], dividend[0], and
@@ -4244,8 +4245,8 @@ div_var(NumericVar *var1, NumericVar *var2, NumericVar *result,
 	if (var2ndigits == 1)
 	{
 		/*
-		 * If there's only a single divisor digit, we can use a fast path
-		 * (cf. Knuth section 4.3.1 exercise 16).
+		 * If there's only a single divisor digit, we can use a fast path (cf.
+		 * Knuth section 4.3.1 exercise 16).
 		 */
 		divisor1 = divisor[1];
 		carry = 0;
@@ -4264,12 +4265,12 @@ div_var(NumericVar *var1, NumericVar *var2, NumericVar *result,
 		 *
 		 * We need the first divisor digit to be >= NBASE/2.  If it isn't,
 		 * make it so by scaling up both the divisor and dividend by the
-		 * factor "d".  (The reason for allocating dividend[0] above is to
+		 * factor "d".	(The reason for allocating dividend[0] above is to
 		 * leave room for possible carry here.)
 		 */
 		if (divisor[1] < HALF_NBASE)
 		{
-			int		d = NBASE / (divisor[1] + 1);
+			int			d = NBASE / (divisor[1] + 1);
 
 			carry = 0;
 			for (i = var2ndigits; i > 0; i--)
@@ -4295,22 +4296,22 @@ div_var(NumericVar *var1, NumericVar *var2, NumericVar *result,
 		divisor2 = divisor[2];
 
 		/*
-		 * Begin the main loop.  Each iteration of this loop produces the
-		 * j'th quotient digit by dividing dividend[j .. j + var2ndigits]
-		 * by the divisor; this is essentially the same as the common manual
+		 * Begin the main loop.  Each iteration of this loop produces the j'th
+		 * quotient digit by dividing dividend[j .. j + var2ndigits] by the
+		 * divisor; this is essentially the same as the common manual
 		 * procedure for long division.
 		 */
 		for (j = 0; j < res_ndigits; j++)
 		{
 			/* Estimate quotient digit from the first two dividend digits */
-			int		next2digits = dividend[j] * NBASE + dividend[j+1];
-			int		qhat;
+			int			next2digits = dividend[j] * NBASE + dividend[j + 1];
+			int			qhat;
 
 			/*
 			 * If next2digits are 0, then quotient digit must be 0 and there's
-			 * no need to adjust the working dividend.  It's worth testing
-			 * here to fall out ASAP when processing trailing zeroes in
-			 * a dividend.
+			 * no need to adjust the working dividend.	It's worth testing
+			 * here to fall out ASAP when processing trailing zeroes in a
+			 * dividend.
 			 */
 			if (next2digits == 0)
 			{
@@ -4322,14 +4323,15 @@ div_var(NumericVar *var1, NumericVar *var2, NumericVar *result,
 				qhat = NBASE - 1;
 			else
 				qhat = next2digits / divisor1;
+
 			/*
 			 * Adjust quotient digit if it's too large.  Knuth proves that
-			 * after this step, the quotient digit will be either correct
-			 * or just one too large.  (Note: it's OK to use dividend[j+2]
-			 * here because we know the divisor length is at least 2.)
+			 * after this step, the quotient digit will be either correct or
+			 * just one too large.	(Note: it's OK to use dividend[j+2] here
+			 * because we know the divisor length is at least 2.)
 			 */
 			while (divisor2 * qhat >
-				   (next2digits - qhat * divisor1) * NBASE + dividend[j+2])
+				   (next2digits - qhat * divisor1) * NBASE + dividend[j + 2])
 				qhat--;
 
 			/* As above, need do nothing more when quotient digit is 0 */
@@ -5253,16 +5255,16 @@ power_var(NumericVar *base, NumericVar *exp, NumericVar *result)
 	}
 
 	/*
-	 *	This avoids log(0) for cases of 0 raised to a non-integer.
-	 *	0 ^ 0 handled by power_var_int().
+	 * This avoids log(0) for cases of 0 raised to a non-integer. 0 ^ 0
+	 * handled by power_var_int().
 	 */
 	if (cmp_var(base, &const_zero) == 0)
 	{
 		set_var_from_var(&const_zero, result);
-		result->dscale = NUMERIC_MIN_SIG_DIGITS;	/* no need to round */
+		result->dscale = NUMERIC_MIN_SIG_DIGITS;		/* no need to round */
 		return;
 	}
-	
+
 	init_var(&ln_base);
 	init_var(&ln_num);
 
@@ -5330,11 +5332,13 @@ power_var_int(NumericVar *base, int exp, NumericVar *result, int rscale)
 	switch (exp)
 	{
 		case 0:
+
 			/*
-			 *	While 0 ^ 0 can be either 1 or indeterminate (error), we
-			 *	treat it as 1 because most programming languages do this.
-			 *	SQL:2003 also requires a return value of 1.
-			 *	http://en.wikipedia.org/wiki/Exponentiation#Zero_to_the_zero_power
+			 * While 0 ^ 0 can be either 1 or indeterminate (error), we treat
+			 * it as 1 because most programming languages do this. SQL:2003
+			 * also requires a return value of 1.
+			 * http://en.wikipedia.org/wiki/Exponentiation#Zero_to_the_zero_pow
+			 * er
 			 */
 			set_var_from_var(&const_one, result);
 			result->dscale = rscale;	/* no need to round */