mirror of
https://github.com/postgres/postgres.git
synced 2025-06-29 10:41:53 +03:00
8.4 pgindent run, with new combined Linux/FreeBSD/MinGW typedef list
provided by Andrew.
This commit is contained in:
Bruce Momjian
@ -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 */
|
||||
|
||||
Reference in New Issue
Block a user