Skip to content

P
Postgres FD Implementation
Commit f68dc5d8 authored by Bruce Momjian's avatar Bruce Momjian
Browse files
Options

More formatting.c variable renaming, for clarity

parent 8cce08f1
Hide whitespace changes
Inline Side-by-side
Showing with 310 additions and 310 deletions
src/backend/utils/adt/formatting.c
View file @ f68dc5d8
......@@ -310,7 +310,7 @@ typedef struct
zero_start, /* position of first zero */
zero_end, /* position of last zero */
need_locale; /* needs it locale */
} NUMDesc;
} FmtDesc;
/* ----------
* Flags for NUMBER version
......@@ -377,7 +377,7 @@ typedef struct
FormatNode format[NUM_CACHE_SIZE + 1];
char str[NUM_CACHE_SIZE + 1];
int age;
NUMDesc Num;
FmtDesc Fmt;
} NUMCacheEntry;
/* global cache for --- date/time part */
......@@ -910,7 +910,7 @@ static const int NUM_index[KeyWord_INDEX_SIZE] = {
typedef struct NUMProc
{
bool is_to_char;
NUMDesc *Num; /* number description */
FmtDesc *Fmt; /* number description */
int sign, /* '-' or '+' */
sign_wrote, /* was sign write */
......@@ -923,8 +923,8 @@ typedef struct NUMProc
read_post, /* to_number - number of dec. digit */
read_pre; /* to_number - number non-dec. digit */
char *number, /* string with number */
*number_p, /* pointer to current number position */
char *numstr, /* string with number */
*numstr_p, /* pointer to current number position */
*inout, /* in / out buffer */
*inout_p, /* pointer to current inout position */
*last_relevant, /* last relevant number after decimal point */
......@@ -944,9 +944,9 @@ typedef struct NUMProc
static const KeyWord *index_seq_search(char *str, const KeyWord *kw,
const int *index);
static const KeySuffix *suff_search(char *str, const KeySuffix *suf, int type);
static void NUMDesc_prepare(NUMDesc *num, FormatNode *n);
static void FmtDesc_prepare(FmtDesc *Fmt, FormatNode *n);
static void parse_format(FormatNode *node, char *str, const KeyWord *kw,
const KeySuffix *suf, const int *index, int ver, NUMDesc *Num);
const KeySuffix *suf, const int *index, int ver, FmtDesc *Fmt);
static void DCH_to_char(FormatNode *node, bool is_interval,
TmToChar *in, char *out, Oid collid);
......@@ -971,14 +971,14 @@ static int from_char_seq_search(int *dest, char **src, const char *const * array
static void do_to_timestamp(text *date_txt, text *fmt,
struct pg_tm * tm, fsec_t *fsec);
static char *fill_str(char *str, int c, int max);
static FormatNode *NUM_cache(int len, NUMDesc *Num, text *pars_str, bool *shouldFree);
static FormatNode *NUM_cache(int len, FmtDesc *Fmt, text *pars_str, bool *shouldFree);
static char *int_to_roman(int number);
static void NUM_prepare_locale(NUMProc *Np);
static char *get_last_relevant_decnum(char *num);
static void NUM_numpart_from_char(NUMProc *Np, int id, int input_len);
static void NUM_numpart_to_char(NUMProc *Np, int id);
static char *NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
char *number, int from_char_input_len, int to_char_out_pre_spaces,
static char *NUM_processor(FormatNode *node, FmtDesc *Fmt, char *inout,
char *numstr, int from_char_input_len, int to_char_out_pre_spaces,
int sign, bool is_to_char, Oid collid);
static DCHCacheEntry *DCH_cache_search(char *str);
static DCHCacheEntry *DCH_cache_getnew(char *str);
......@@ -1035,11 +1035,11 @@ suff_search(char *str, const KeySuffix *suf, int type)
}
/* ----------
* Prepare NUMDesc (number description struct) via FormatNode struct
* Prepare FmtDesc (number description struct) via FormatNode struct
* ----------
*/
static void
NUMDesc_prepare(NUMDesc *num, FormatNode *n)
FmtDesc_prepare(FmtDesc *Fmt, FormatNode *n)
{
if (n->type != NODE_TYPE_ACTION)
return;
......@@ -1050,7 +1050,7 @@ NUMDesc_prepare(NUMDesc *num, FormatNode *n)
*/
PG_TRY();
{
if (IS_EEEE(num) && n->key->id != NUM_E)
if (IS_EEEE(Fmt) && n->key->id != NUM_E)
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("\"EEEE\" must be the last pattern used")));
......@@ -1058,156 +1058,156 @@ NUMDesc_prepare(NUMDesc *num, FormatNode *n)
switch (n->key->id)
{
case NUM_9:
if (IS_BRACKET(num))
if (IS_BRACKET(Fmt))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("\"9\" must be ahead of \"PR\"")));
if (IS_MULTI(num))
if (IS_MULTI(Fmt))
{
++num->multi;
++Fmt->multi;
break;
}
if (IS_DECIMAL(num))
++num->post;
if (IS_DECIMAL(Fmt))
++Fmt->post;
else
++num->pre;
++Fmt->pre;
break;
case NUM_0:
if (IS_BRACKET(num))
if (IS_BRACKET(Fmt))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("\"0\" must be ahead of \"PR\"")));
if (!IS_ZERO(num) && !IS_DECIMAL(num))
if (!IS_ZERO(Fmt) && !IS_DECIMAL(Fmt))
{
num->flag |= NUM_F_ZERO;
num->zero_start = num->pre + 1;
Fmt->flag |= NUM_F_ZERO;
Fmt->zero_start = Fmt->pre + 1;
}
if (!IS_DECIMAL(num))
++num->pre;
if (!IS_DECIMAL(Fmt))
++Fmt->pre;
else
++num->post;
++Fmt->post;
num->zero_end = num->pre + num->post;
Fmt->zero_end = Fmt->pre + Fmt->post;
break;
case NUM_B:
if (num->pre == 0 && num->post == 0 && (!IS_ZERO(num)))
num->flag |= NUM_F_BLANK;
if (Fmt->pre == 0 && Fmt->post == 0 && (!IS_ZERO(Fmt)))
Fmt->flag |= NUM_F_BLANK;
break;
case NUM_D:
num->flag |= NUM_F_LDECIMAL;
num->need_locale = TRUE;
Fmt->flag |= NUM_F_LDECIMAL;
Fmt->need_locale = TRUE;
/* FALLTHROUGH */
case NUM_DEC:
if (IS_DECIMAL(num))
if (IS_DECIMAL(Fmt))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("multiple decimal points")));
if (IS_MULTI(num))
if (IS_MULTI(Fmt))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("cannot use \"V\" and decimal point together")));
num->flag |= NUM_F_DECIMAL;
Fmt->flag |= NUM_F_DECIMAL;
break;
case NUM_FM:
num->flag |= NUM_F_FILLMODE;
Fmt->flag |= NUM_F_FILLMODE;
break;
case NUM_S:
if (IS_LSIGN(num))
if (IS_LSIGN(Fmt))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("cannot use \"S\" twice")));
if (IS_PLUS(num) || IS_MINUS(num) || IS_BRACKET(num))
if (IS_PLUS(Fmt) || IS_MINUS(Fmt) || IS_BRACKET(Fmt))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("cannot use \"S\" and \"PL\"/\"MI\"/\"SG\"/\"PR\" together")));
if (!IS_DECIMAL(num))
if (!IS_DECIMAL(Fmt))
{
num->lsign = NUM_LSIGN_PRE;
num->pre_lsign_num = num->pre;
num->need_locale = TRUE;
num->flag |= NUM_F_LSIGN;
Fmt->lsign = NUM_LSIGN_PRE;
Fmt->pre_lsign_num = Fmt->pre;
Fmt->need_locale = TRUE;
Fmt->flag |= NUM_F_LSIGN;
}
else if (num->lsign == NUM_LSIGN_NONE)
else if (Fmt->lsign == NUM_LSIGN_NONE)
{
num->lsign = NUM_LSIGN_POST;
num->need_locale = TRUE;
num->flag |= NUM_F_LSIGN;
Fmt->lsign = NUM_LSIGN_POST;
Fmt->need_locale = TRUE;
Fmt->flag |= NUM_F_LSIGN;
}
break;
case NUM_MI:
if (IS_LSIGN(num))
if (IS_LSIGN(Fmt))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("cannot use \"S\" and \"MI\" together")));
num->flag |= NUM_F_MINUS;
if (IS_DECIMAL(num))
num->flag |= NUM_F_MINUS_POST;
Fmt->flag |= NUM_F_MINUS;
if (IS_DECIMAL(Fmt))
Fmt->flag |= NUM_F_MINUS_POST;
break;
case NUM_PL:
if (IS_LSIGN(num))
if (IS_LSIGN(Fmt))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("cannot use \"S\" and \"PL\" together")));
num->flag |= NUM_F_PLUS;
if (IS_DECIMAL(num))
num->flag |= NUM_F_PLUS_POST;
Fmt->flag |= NUM_F_PLUS;
if (IS_DECIMAL(Fmt))
Fmt->flag |= NUM_F_PLUS_POST;
break;
case NUM_SG:
if (IS_LSIGN(num))
if (IS_LSIGN(Fmt))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("cannot use \"S\" and \"SG\" together")));
num->flag |= NUM_F_MINUS;
num->flag |= NUM_F_PLUS;
Fmt->flag |= NUM_F_MINUS;
Fmt->flag |= NUM_F_PLUS;
break;
case NUM_PR:
if (IS_LSIGN(num) || IS_PLUS(num) || IS_MINUS(num))
if (IS_LSIGN(Fmt) || IS_PLUS(Fmt) || IS_MINUS(Fmt))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("cannot use \"PR\" and \"S\"/\"PL\"/\"MI\"/\"SG\" together")));
num->flag |= NUM_F_BRACKET;
Fmt->flag |= NUM_F_BRACKET;
break;
case NUM_rn:
case NUM_RN:
num->flag |= NUM_F_ROMAN;
Fmt->flag |= NUM_F_ROMAN;
break;
case NUM_L:
case NUM_G:
num->need_locale = TRUE;
Fmt->need_locale = TRUE;
break;
case NUM_V:
if (IS_DECIMAL(num))
if (IS_DECIMAL(Fmt))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("cannot use \"V\" and decimal point together")));
num->flag |= NUM_F_MULTI;
Fmt->flag |= NUM_F_MULTI;
break;
case NUM_E:
if (IS_EEEE(num))
if (IS_EEEE(Fmt))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("cannot use \"EEEE\" twice")));
if (IS_BLANK(num) || IS_FILLMODE(num) || IS_LSIGN(num) ||
IS_BRACKET(num) || IS_MINUS(num) || IS_PLUS(num) ||
IS_ROMAN(num) || IS_MULTI(num))
if (IS_BLANK(Fmt) || IS_FILLMODE(Fmt) || IS_LSIGN(Fmt) ||
IS_BRACKET(Fmt) || IS_MINUS(Fmt) || IS_PLUS(Fmt) ||
IS_ROMAN(Fmt) || IS_MULTI(Fmt))
ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR),
errmsg("\"EEEE\" is incompatible with other formats"),
errdetail("\"EEEE\" may only be used together with digit and decimal point patterns.")));
num->flag |= NUM_F_EEEE;
Fmt->flag |= NUM_F_EEEE;
break;
}
}
......@@ -1231,7 +1231,7 @@ NUMDesc_prepare(NUMDesc *num, FormatNode *n)
*/
static void
parse_format(FormatNode *node, char *str, const KeyWord *kw,
const KeySuffix *suf, const int *index, int ver, NUMDesc *Num)
const KeySuffix *suf, const int *index, int ver, FmtDesc *Fmt)
{
const KeySuffix *s;
FormatNode *n;
......@@ -1271,10 +1271,10 @@ parse_format(FormatNode *node, char *str, const KeyWord *kw,
str += n->key->len;
/*
* NUM version: Prepare global NUMDesc struct
* NUM version: Prepare global FmtDesc struct
*/
if (ver == NUM_TYPE)
NUMDesc_prepare(Num, n);
FmtDesc_prepare(Fmt, n);
/*
* Postfix
......@@ -3772,7 +3772,7 @@ NUM_cache_getnew(char *str)
++n_NUMCache;
}
zeroize_NUM(&ent->Num);
zeroize_NUM(&ent->Fmt);
last_NUMCacheEntry = ent;
return ent;
......@@ -3821,7 +3821,7 @@ NUM_cache_remove(NUMCacheEntry *ent)
* ----------
*/
static FormatNode *
NUM_cache(int len, NUMDesc *Num, text *pars_str, bool *shouldFree)
NUM_cache(int len, FmtDesc *Fmt, text *pars_str, bool *shouldFree)
{
FormatNode *format = NULL;
char *str;
......@@ -3839,10 +3839,10 @@ NUM_cache(int len, NUMDesc *Num, text *pars_str, bool *shouldFree)
*shouldFree = true;
zeroize_NUM(Num);
zeroize_NUM(Fmt);
parse_format(format, str, NUM_keywords,
NULL, NUM_index, NUM_TYPE, Num);
NULL, NUM_index, NUM_TYPE, Fmt);
(format + len)->type = NODE_TYPE_END; /* Paranoia? */
}
......@@ -3864,7 +3864,7 @@ NUM_cache(int len, NUMDesc *Num, text *pars_str, bool *shouldFree)
* to the cache.
*/
parse_format(ent->format, str, NUM_keywords,
NULL, NUM_index, NUM_TYPE, &ent->Num);
NULL, NUM_index, NUM_TYPE, &ent->Fmt);
(ent->format + len)->type = NODE_TYPE_END; /* Paranoia? */
}
......@@ -3874,15 +3874,15 @@ NUM_cache(int len, NUMDesc *Num, text *pars_str, bool *shouldFree)
/*
* Copy cache to used struct
*/
Num->flag = ent->Num.flag;
Num->lsign = ent->Num.lsign;
Num->pre = ent->Num.pre;
Num->post = ent->Num.post;
Num->pre_lsign_num = ent->Num.pre_lsign_num;
Num->need_locale = ent->Num.need_locale;
Num->multi = ent->Num.multi;
Num->zero_start = ent->Num.zero_start;
Num->zero_end = ent->Num.zero_end;
Fmt->flag = ent->Fmt.flag;
Fmt->lsign = ent->Fmt.lsign;
Fmt->pre = ent->Fmt.pre;
Fmt->post = ent->Fmt.post;
Fmt->pre_lsign_num = ent->Fmt.pre_lsign_num;
Fmt->need_locale = ent->Fmt.need_locale;
Fmt->multi = ent->Fmt.multi;
Fmt->zero_start = ent->Fmt.zero_start;
Fmt->zero_end = ent->Fmt.zero_end;
}
#ifdef DEBUG_TO_FROM_CHAR
......@@ -3947,7 +3947,7 @@ int_to_roman(int number)
static void
NUM_prepare_locale(NUMProc *Np)
{
if (Np->Num->need_locale)
if (Np->Fmt->need_locale)
{
struct lconv *lconv;
......@@ -3978,7 +3978,7 @@ NUM_prepare_locale(NUMProc *Np)
else
Np->decimal = ".";
if (!IS_LDECIMAL(Np->Num))
if (!IS_LDECIMAL(Np->Fmt))
Np->decimal = ".";
/*
......@@ -4079,7 +4079,7 @@ NUM_numpart_from_char(NUMProc *Np, int id, int input_len)
/*
* read sign before number
*/
if (*Np->number == ' ' && (id == NUM_0 || id == NUM_9) &&
if (*Np->numstr == ' ' && (id == NUM_0 || id == NUM_9) &&
(Np->read_pre + Np->read_post) == 0)
{
#ifdef DEBUG_TO_FROM_CHAR
......@@ -4090,7 +4090,7 @@ NUM_numpart_from_char(NUMProc *Np, int id, int input_len)
/*
* locale sign
*/
if (IS_LSIGN(Np->Num) && Np->Num->lsign == NUM_LSIGN_PRE)
if (IS_LSIGN(Np->Fmt) && Np->Fmt->lsign == NUM_LSIGN_PRE)
{
int x = 0;
......@@ -4102,14 +4102,14 @@ NUM_numpart_from_char(NUMProc *Np, int id, int input_len)
strncmp(Np->inout_p, Np->L_negative_sign, x) == 0)
{
Np->inout_p += x;
*Np->number = '-';
*Np->numstr = '-';
}
else if ((x = strlen(Np->L_positive_sign)) &&
AMOUNT_TEST(x) &&
strncmp(Np->inout_p, Np->L_positive_sign, x) == 0)
{
Np->inout_p += x;
*Np->number = '+';
*Np->numstr = '+';
}
}
else
......@@ -4121,15 +4121,15 @@ NUM_numpart_from_char(NUMProc *Np, int id, int input_len)
/*
* simple + - < >
*/
if (*Np->inout_p == '-' || (IS_BRACKET(Np->Num) &&
if (*Np->inout_p == '-' || (IS_BRACKET(Np->Fmt) &&
*Np->inout_p == '<'))
{
*Np->number = '-'; /* set - */
*Np->numstr = '-'; /* set - */
Np->inout_p++;
}
else if (*Np->inout_p == '+')
{
*Np->number = '+'; /* set + */
*Np->numstr = '+'; /* set + */
Np->inout_p++;
}
}
......@@ -4139,7 +4139,7 @@ NUM_numpart_from_char(NUMProc *Np, int id, int input_len)
return;
#ifdef DEBUG_TO_FROM_CHAR
elog(DEBUG_elog_output, "Scan for numbers (%c), current number: '%s'", *Np->inout_p, Np->number);
elog(DEBUG_elog_output, "Scan for numbers (%c), current number: '%s'", *Np->inout_p, Np->numstr);
#endif
/*
......@@ -4147,11 +4147,11 @@ NUM_numpart_from_char(NUMProc *Np, int id, int input_len)
*/
if (isdigit((unsigned char) *Np->inout_p))
{
if (Np->read_dec && Np->read_post == Np->Num->post)
if (Np->read_dec && Np->read_post == Np->Fmt->post)
return;
*Np->number_p = *Np->inout_p;
Np->number_p++;
*Np->numstr_p = *Np->inout_p;
Np->numstr_p++;
if (Np->read_dec)
Np->read_post++;
......@@ -4164,10 +4164,10 @@ NUM_numpart_from_char(NUMProc *Np, int id, int input_len)
elog(DEBUG_elog_output, "Read digit (%c)", *Np->inout_p);
#endif
}
else if (IS_DECIMAL(Np->Num) && Np->read_dec == FALSE)
else if (IS_DECIMAL(Np->Fmt) && Np->read_dec == FALSE)
{
/*
* We need not test IS_LDECIMAL(Np->Num) explicitly here, because
* We need not test IS_LDECIMAL(Np->Fmt) explicitly here, because
* Np->decimal is always just "." if we don't have a D format token.
* So we just unconditionally match to Np->decimal.
*/
......@@ -4180,8 +4180,8 @@ NUM_numpart_from_char(NUMProc *Np, int id, int input_len)
if (x && AMOUNT_TEST(x) && strncmp(Np->inout_p, Np->decimal, x) == 0)
{
Np->inout_p += x - 1;
*Np->number_p = '.';
Np->number_p++;
*Np->numstr_p = '.';
Np->numstr_p++;
Np->read_dec = TRUE;
isread = TRUE;
}
......@@ -4199,14 +4199,14 @@ NUM_numpart_from_char(NUMProc *Np, int id, int input_len)
* FM9999.9999999S -> 123.001- 9.9S -> .5- FM9.999999MI ->
* 5.01-
*/
if (*Np->number == ' ' && Np->read_pre + Np->read_post > 0)
if (*Np->numstr == ' ' && Np->read_pre + Np->read_post > 0)
{
/*
* locale sign (NUM_S) is always anchored behind a last number, if: -
* locale sign expected - last read char was NUM_0/9 or NUM_DEC - and
* next char is not digit
*/
if (IS_LSIGN(Np->Num) && isread &&
if (IS_LSIGN(Np->Fmt) && isread &&
(Np->inout_p + 1) <= Np->inout + input_len &&
!isdigit((unsigned char) *(Np->inout_p + 1)))
{
......@@ -4221,16 +4221,16 @@ NUM_numpart_from_char(NUMProc *Np, int id, int input_len)
strncmp(Np->inout_p, Np->L_negative_sign, x) == 0)
{
Np->inout_p += x - 1; /* -1 .. NUM_processor() do inout_p++ */
*Np->number = '-';
*Np->numstr = '-';
}
else if ((x = strlen(Np->L_positive_sign)) &&
AMOUNT_TEST(x) &&
strncmp(Np->inout_p, Np->L_positive_sign, x) == 0)
{
Np->inout_p += x - 1; /* -1 .. NUM_processor() do inout_p++ */
*Np->number = '+';
*Np->numstr = '+';
}
if (*Np->number == ' ')
if (*Np->numstr == ' ')
/* no sign read */
Np->inout_p = tmp;
}
......@@ -4241,12 +4241,12 @@ NUM_numpart_from_char(NUMProc *Np, int id, int input_len)
*
* FM9.999999MI -> 5.01-
*
* if (.... && IS_LSIGN(Np->Num)==FALSE) prevents read wrong formats
* if (.... && IS_LSIGN(Np->Fmt)==FALSE) prevents read wrong formats
* like to_number('1 -', '9S') where sign is not anchored to last
* number.
*/
else if (isread == FALSE && IS_LSIGN(Np->Num) == FALSE &&
(IS_PLUS(Np->Num) || IS_MINUS(Np->Num)))
else if (isread == FALSE && IS_LSIGN(Np->Fmt) == FALSE &&
(IS_PLUS(Np->Fmt) || IS_MINUS(Np->Fmt)))
{
#ifdef DEBUG_TO_FROM_CHAR
elog(DEBUG_elog_output, "Try read simple post-sign (%c)", *Np->inout_p);
......@@ -4257,16 +4257,16 @@ NUM_numpart_from_char(NUMProc *Np, int id, int input_len)
*/
if (*Np->inout_p == '-' || *Np->inout_p == '+')
/* NUM_processor() do inout_p++ */
*Np->number = *Np->inout_p;
*Np->numstr = *Np->inout_p;
}
}
}
#define IS_PREDEC_SPACE(_n) \
(IS_ZERO((_n)->Num)==FALSE && \
(_n)->number == (_n)->number_p && \
*(_n)->number == '0' && \
(_n)->Num->post != 0)
(IS_ZERO((_n)->Fmt)==FALSE && \
(_n)->numstr == (_n)->numstr_p && \
*(_n)->numstr == '0' && \
(_n)->Fmt->post != 0)
/* ----------
* Add digit or sign to number-string
......@@ -4277,7 +4277,7 @@ NUM_numpart_to_char(NUMProc *Np, int id)
{
int end;
if (IS_ROMAN(Np->Num))
if (IS_ROMAN(Np->Fmt))
return;
/* Note: in this elog() output not set '\0' in 'inout' */
......@@ -4292,7 +4292,7 @@ NUM_numpart_to_char(NUMProc *Np, int id)
"SIGN_WROTE: %d, CURRENT: %d, NUMBER_P: \"%s\", INOUT: \"%s\"",
Np->sign_wrote,
Np->num_curr,
Np->number_p,
Np->numstr_p,
Np->inout);
#endif
Np->num_in = FALSE;
......@@ -4302,12 +4302,12 @@ NUM_numpart_to_char(NUMProc *Np, int id)
* handle "9.9" --> " .1"
*/
if (Np->sign_wrote == FALSE &&
(Np->num_curr >= Np->out_pre_spaces || (IS_ZERO(Np->Num) && Np->Num->zero_start == Np->num_curr)) &&
(Np->num_curr >= Np->out_pre_spaces || (IS_ZERO(Np->Fmt) && Np->Fmt->zero_start == Np->num_curr)) &&
(IS_PREDEC_SPACE(Np) == FALSE || (Np->last_relevant && *Np->last_relevant == '.')))
{
if (IS_LSIGN(Np->Num))
if (IS_LSIGN(Np->Fmt))
{
if (Np->Num->lsign == NUM_LSIGN_PRE)
if (Np->Fmt->lsign == NUM_LSIGN_PRE)
{
if (Np->sign == '-')
strcpy(Np->inout_p, Np->L_negative_sign);
......@@ -4317,7 +4317,7 @@ NUM_numpart_to_char(NUMProc *Np, int id)
Np->sign_wrote = TRUE;
}
}
else if (IS_BRACKET(Np->Num))
else if (IS_BRACKET(Np->Fmt))
{
*Np->inout_p = Np->sign == '+' ? ' ' : '<';
++Np->inout_p;
......@@ -4325,7 +4325,7 @@ NUM_numpart_to_char(NUMProc *Np, int id)
}
else if (Np->sign == '+')
{
if (!IS_FILLMODE(Np->Num))
if (!IS_FILLMODE(Np->Fmt))
{
*Np->inout_p = ' '; /* Write + */
++Np->inout_p;
......@@ -4347,20 +4347,20 @@ NUM_numpart_to_char(NUMProc *Np, int id)
if (id == NUM_9 || id == NUM_0 || id == NUM_D || id == NUM_DEC)
{
if (Np->num_curr < Np->out_pre_spaces &&
(Np->Num->zero_start > Np->num_curr || !IS_ZERO(Np->Num)))
(Np->Fmt->zero_start > Np->num_curr || !IS_ZERO(Np->Fmt)))
{
/*
* Write blank space
*/
if (!IS_FILLMODE(Np->Num))
if (!IS_FILLMODE(Np->Fmt))
{
*Np->inout_p = ' '; /* Write ' ' */
++Np->inout_p;
}
}
else if (IS_ZERO(Np->Num) &&
else if (IS_ZERO(Np->Fmt) &&
Np->num_curr < Np->out_pre_spaces &&
Np->Num->zero_start <= Np->num_curr)
Np->Fmt->zero_start <= Np->num_curr)
{
/*
* Write ZERO
......@@ -4374,7 +4374,7 @@ NUM_numpart_to_char(NUMProc *Np, int id)
/*
* Write Decimal point
*/
if (*Np->number_p == '.')
if (*Np->numstr_p == '.')
{
if (!Np->last_relevant || *Np->last_relevant != '.')
{
......@@ -4385,7 +4385,7 @@ NUM_numpart_to_char(NUMProc *Np, int id)
/*
* Ora 'n' -- FM9.9 --> 'n.'
*/
else if (IS_FILLMODE(Np->Num) &&
else if (IS_FILLMODE(Np->Fmt) &&
Np->last_relevant && *Np->last_relevant == '.')
{
strcpy(Np->inout_p, Np->decimal); /* Write DEC/D */
......@@ -4397,7 +4397,7 @@ NUM_numpart_to_char(NUMProc *Np, int id)
/*
* Write Digits
*/
if (Np->last_relevant && Np->number_p > Np->last_relevant &&
if (Np->last_relevant && Np->numstr_p > Np->last_relevant &&
id != NUM_0)
;
......@@ -4406,7 +4406,7 @@ NUM_numpart_to_char(NUMProc *Np, int id)
*/
else if (IS_PREDEC_SPACE(Np))
{
if (!IS_FILLMODE(Np->Num))
if (!IS_FILLMODE(Np->Fmt))
{
*Np->inout_p = ' ';
++Np->inout_p;
......@@ -4423,27 +4423,27 @@ NUM_numpart_to_char(NUMProc *Np, int id)
}
else
{
*Np->inout_p = *Np->number_p; /* Write DIGIT */
*Np->inout_p = *Np->numstr_p; /* Write DIGIT */
++Np->inout_p;
Np->num_in = TRUE;
}
}
++Np->number_p;
++Np->numstr_p;
}
end = Np->num_count + (Np->out_pre_spaces ? 1 : 0) + (IS_DECIMAL(Np->Num) ? 1 : 0);
end = Np->num_count + (Np->out_pre_spaces ? 1 : 0) + (IS_DECIMAL(Np->Fmt) ? 1 : 0);
if (Np->last_relevant && Np->last_relevant == Np->number_p)
if (Np->last_relevant && Np->last_relevant == Np->numstr_p)
end = Np->num_curr;
if (Np->num_curr + 1 == end)
{
if (Np->sign_wrote == TRUE && IS_BRACKET(Np->Num))
if (Np->sign_wrote == TRUE && IS_BRACKET(Np->Fmt))
{
*Np->inout_p = Np->sign == '+' ? ' ' : '>';
++Np->inout_p;
}
else if (IS_LSIGN(Np->Num) && Np->Num->lsign == NUM_LSIGN_POST)
else if (IS_LSIGN(Np->Fmt) && Np->Fmt->lsign == NUM_LSIGN_POST)
{
if (Np->sign == '-')
strcpy(Np->inout_p, Np->L_negative_sign);
......@@ -4458,8 +4458,8 @@ NUM_numpart_to_char(NUMProc *Np, int id)
}
static char *
NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
char *number, int from_char_input_len, int to_char_out_pre_spaces,
NUM_processor(FormatNode *node, FmtDesc *Fmt, char *inout,
char *numstr, int from_char_input_len, int to_char_out_pre_spaces,
int sign, bool is_to_char, Oid collid)
{
FormatNode *n;
......@@ -4468,48 +4468,48 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
MemSet(Np, 0, sizeof(NUMProc));
Np->Num = Num;
Np->Fmt = Fmt;
Np->is_to_char = is_to_char;
Np->number = number;
Np->numstr = numstr;
Np->inout = inout;
Np->last_relevant = NULL;
Np->read_post = 0;
Np->read_pre = 0;
Np->read_dec = FALSE;
if (Np->Num->zero_start)
--Np->Num->zero_start;
if (Np->Fmt->zero_start)
--Np->Fmt->zero_start;
if (IS_EEEE(Np->Num))
if (IS_EEEE(Np->Fmt))
{
if (!Np->is_to_char)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("\"EEEE\" not supported for input")));
return strcpy(inout, number);
return strcpy(inout, numstr);
}
/*
* Roman correction
*/
if (IS_ROMAN(Np->Num))
if (IS_ROMAN(Np->Fmt))
{
if (!Np->is_to_char)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("\"RN\" not supported for input")));
Np->Num->lsign = Np->Num->pre_lsign_num = Np->Num->post =
Np->Num->pre = Np->out_pre_spaces = Np->sign = 0;
Np->Fmt->lsign = Np->Fmt->pre_lsign_num = Np->Fmt->post =
Np->Fmt->pre = Np->out_pre_spaces = Np->sign = 0;
if (IS_FILLMODE(Np->Num))
if (IS_FILLMODE(Np->Fmt))
{
Np->Num->flag = 0;
Np->Num->flag |= NUM_F_FILLMODE;
Np->Fmt->flag = 0;
Np->Fmt->flag |= NUM_F_FILLMODE;
}
else
Np->Num->flag = 0;
Np->Num->flag |= NUM_F_ROMAN;
Np->Fmt->flag = 0;
Np->Fmt->flag |= NUM_F_ROMAN;
}
/*
......@@ -4520,9 +4520,9 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
Np->sign = sign;
/* MI/PL/SG - write sign itself and not in number */
if (IS_PLUS(Np->Num) || IS_MINUS(Np->Num))
if (IS_PLUS(Np->Fmt) || IS_MINUS(Np->Fmt))
{
if (IS_PLUS(Np->Num) && IS_MINUS(Np->Num) == FALSE)
if (IS_PLUS(Np->Fmt) && IS_MINUS(Np->Fmt) == FALSE)
Np->sign_wrote = FALSE; /* need sign */
else
Np->sign_wrote = TRUE; /* needn't sign */
......@@ -4531,21 +4531,21 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
{
if (Np->sign != '-')
{
if (IS_BRACKET(Np->Num) && IS_FILLMODE(Np->Num))
Np->Num->flag &= ~NUM_F_BRACKET;
if (IS_MINUS(Np->Num))
Np->Num->flag &= ~NUM_F_MINUS;
if (IS_BRACKET(Np->Fmt) && IS_FILLMODE(Np->Fmt))
Np->Fmt->flag &= ~NUM_F_BRACKET;
if (IS_MINUS(Np->Fmt))
Np->Fmt->flag &= ~NUM_F_MINUS;
}
else if (Np->sign != '+' && IS_PLUS(Np->Num))
Np->Num->flag &= ~NUM_F_PLUS;
else if (Np->sign != '+' && IS_PLUS(Np->Fmt))
Np->Fmt->flag &= ~NUM_F_PLUS;
if (Np->sign == '+' && IS_FILLMODE(Np->Num) && IS_LSIGN(Np->Num) == FALSE)
if (Np->sign == '+' && IS_FILLMODE(Np->Fmt) && IS_LSIGN(Np->Fmt) == FALSE)
Np->sign_wrote = TRUE; /* needn't sign */
else
Np->sign_wrote = FALSE; /* need sign */
if (Np->Num->lsign == NUM_LSIGN_PRE && Np->Num->pre == Np->Num->pre_lsign_num)
Np->Num->lsign = NUM_LSIGN_POST;
if (Np->Fmt->lsign == NUM_LSIGN_PRE && Np->Fmt->pre == Np->Fmt->pre_lsign_num)
Np->Fmt->lsign = NUM_LSIGN_POST;
}
}
else
......@@ -4554,25 +4554,25 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
/*
* Count
*/
Np->num_count = Np->Num->post + Np->Num->pre - 1;
Np->num_count = Np->Fmt->post + Np->Fmt->pre - 1;
if (is_to_char)
{
Np->out_pre_spaces = to_char_out_pre_spaces;
if (IS_FILLMODE(Np->Num) && IS_DECIMAL(Np->Num))
if (IS_FILLMODE(Np->Fmt) && IS_DECIMAL(Np->Fmt))
{
Np->last_relevant = get_last_relevant_decnum(Np->number);
Np->last_relevant = get_last_relevant_decnum(Np->numstr);
/*
* If any '0' specifiers are present, make sure we don't strip
* those digits.
*/
if (Np->last_relevant && Np->Num->zero_end > Np->out_pre_spaces)
if (Np->last_relevant && Np->Fmt->zero_end > Np->out_pre_spaces)
{
char *last_zero;
last_zero = Np->number + (Np->Num->zero_end - Np->out_pre_spaces);
last_zero = Np->numstr + (Np->Fmt->zero_end - Np->out_pre_spaces);
if (Np->last_relevant < last_zero)
Np->last_relevant = last_zero;
}
......@@ -4584,8 +4584,8 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
else
{
Np->out_pre_spaces = 0;
*Np->number = ' '; /* sign space */
*(Np->number + 1) = '\0';
*Np->numstr = ' '; /* sign space */
*(Np->numstr + 1) = '\0';
}
Np->num_in = 0;
......@@ -4595,22 +4595,22 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
elog(DEBUG_elog_output,
"\n\tSIGN: '%c'\n\tNUM: '%s'\n\tPRE: %d\n\tPOST: %d\n\tNUM_COUNT: %d\n\tNUM_PRE: %d\n\tSIGN_WROTE: %s\n\tZERO: %s\n\tZERO_START: %d\n\tZERO_END: %d\n\tLAST_RELEVANT: %s\n\tBRACKET: %s\n\tPLUS: %s\n\tMINUS: %s\n\tFILLMODE: %s\n\tROMAN: %s\n\tEEEE: %s",
Np->sign,
Np->number,
Np->Num->pre,
Np->Num->post,
Np->numstr,
Np->Fmt->pre,
Np->Fmt->post,
Np->num_count,
Np->out_pre_spaces,
Np->sign_wrote ? "Yes" : "No",
IS_ZERO(Np->Num) ? "Yes" : "No",
Np->Num->zero_start,
Np->Num->zero_end,
IS_ZERO(Np->Fmt) ? "Yes" : "No",
Np->Fmt->zero_start,
Np->Fmt->zero_end,
Np->last_relevant ? Np->last_relevant : "<not set>",
IS_BRACKET(Np->Num) ? "Yes" : "No",
IS_PLUS(Np->Num) ? "Yes" : "No",
IS_MINUS(Np->Num) ? "Yes" : "No",
IS_FILLMODE(Np->Num) ? "Yes" : "No",
IS_ROMAN(Np->Num) ? "Yes" : "No",
IS_EEEE(Np->Num) ? "Yes" : "No"
IS_BRACKET(Np->Fmt) ? "Yes" : "No",
IS_PLUS(Np->Fmt) ? "Yes" : "No",
IS_MINUS(Np->Fmt) ? "Yes" : "No",
IS_FILLMODE(Np->Fmt) ? "Yes" : "No",
IS_ROMAN(Np->Fmt) ? "Yes" : "No",
IS_EEEE(Np->Fmt) ? "Yes" : "No"
);
#endif
......@@ -4623,9 +4623,9 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
* Processor direct cycle
*/
if (Np->is_to_char)
Np->number_p = Np->number;
Np->numstr_p = Np->numstr;
else
Np->number_p = Np->number + 1; /* first char is space for sign */
Np->numstr_p = Np->numstr + 1; /* first char is space for sign */
for (n = node, Np->inout_p = Np->inout; n->type != NODE_TYPE_END; n++)
{
......@@ -4673,7 +4673,7 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
{
if (!Np->num_in)
{
if (IS_FILLMODE(Np->Num))
if (IS_FILLMODE(Np->Fmt))
continue;
else
*Np->inout_p = ' ';
......@@ -4685,7 +4685,7 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
{
if (!Np->num_in)
{
if (IS_FILLMODE(Np->Num))
if (IS_FILLMODE(Np->Fmt))
continue;
}
}
......@@ -4696,7 +4696,7 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
{
if (!Np->num_in)
{
if (IS_FILLMODE(Np->Num))
if (IS_FILLMODE(Np->Fmt))
continue;
else
{
......@@ -4716,7 +4716,7 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
{
if (!Np->num_in)
{
if (IS_FILLMODE(Np->Num))
if (IS_FILLMODE(Np->Fmt))
continue;
}
Np->inout_p += strlen(Np->L_thousands_sep) - 1;
......@@ -4734,48 +4734,48 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
break;
case NUM_RN:
if (IS_FILLMODE(Np->Num))
if (IS_FILLMODE(Np->Fmt))
{
strcpy(Np->inout_p, Np->number_p);
strcpy(Np->inout_p, Np->numstr_p);
Np->inout_p += strlen(Np->inout_p) - 1;
}
else
{
sprintf(Np->inout_p, "%15s", Np->number_p);
sprintf(Np->inout_p, "%15s", Np->numstr_p);
Np->inout_p += strlen(Np->inout_p) - 1;
}
break;
case NUM_rn:
if (IS_FILLMODE(Np->Num))
if (IS_FILLMODE(Np->Fmt))
{
strcpy(Np->inout_p, asc_tolower_z(Np->number_p));
strcpy(Np->inout_p, asc_tolower_z(Np->numstr_p));
Np->inout_p += strlen(Np->inout_p) - 1;
}
else
{
sprintf(Np->inout_p, "%15s", asc_tolower_z(Np->number_p));
sprintf(Np->inout_p, "%15s", asc_tolower_z(Np->numstr_p));
Np->inout_p += strlen(Np->inout_p) - 1;
}
break;
case NUM_th:
if (IS_ROMAN(Np->Num) || *Np->number == '#' ||
Np->sign == '-' || IS_DECIMAL(Np->Num))
if (IS_ROMAN(Np->Fmt) || *Np->numstr == '#' ||
Np->sign == '-' || IS_DECIMAL(Np->Fmt))
continue;
if (Np->is_to_char)
strcpy(Np->inout_p, get_th(Np->number, TH_LOWER));
strcpy(Np->inout_p, get_th(Np->numstr, TH_LOWER));
Np->inout_p += 1;
break;
case NUM_TH:
if (IS_ROMAN(Np->Num) || *Np->number == '#' ||
Np->sign == '-' || IS_DECIMAL(Np->Num))
if (IS_ROMAN(Np->Fmt) || *Np->numstr == '#' ||
Np->sign == '-' || IS_DECIMAL(Np->Fmt))
continue;
if (Np->is_to_char)
strcpy(Np->inout_p, get_th(Np->number, TH_UPPER));
strcpy(Np->inout_p, get_th(Np->numstr, TH_UPPER));
Np->inout_p += 1;
break;
......@@ -4784,7 +4784,7 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
{
if (Np->sign == '-')
*Np->inout_p = '-';
else if (IS_FILLMODE(Np->Num))
else if (IS_FILLMODE(Np->Fmt))
continue;
else
*Np->inout_p = ' ';
......@@ -4792,7 +4792,7 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
else
{
if (*Np->inout_p == '-')
*Np->number = '-';
*Np->numstr = '-';
}
break;
......@@ -4801,7 +4801,7 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
{
if (Np->sign == '+')
*Np->inout_p = '+';
else if (IS_FILLMODE(Np->Num))
else if (IS_FILLMODE(Np->Fmt))
continue;
else
*Np->inout_p = ' ';
......@@ -4809,7 +4809,7 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
else
{
if (*Np->inout_p == '+')
*Np->number = '+';
*Np->numstr = '+';
}
break;
......@@ -4820,9 +4820,9 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
else
{
if (*Np->inout_p == '-')
*Np->number = '-';
*Np->numstr = '-';
else if (*Np->inout_p == '+')
*Np->number = '+';
*Np->numstr = '+';
}
break;
......@@ -4850,20 +4850,20 @@ NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
}
else
{
if (*(Np->number_p - 1) == '.')
*(Np->number_p - 1) = '\0';
if (*(Np->numstr_p - 1) == '.')
*(Np->numstr_p - 1) = '\0';
else
*Np->number_p = '\0';
*Np->numstr_p = '\0';
/*
* Correction - precision of dec. number
*/
Np->Num->post = Np->read_post;
Np->Fmt->post = Np->read_post;
#ifdef DEBUG_TO_FROM_CHAR
elog(DEBUG_elog_output, "TO_NUMBER (number): '%s'", Np->number);
elog(DEBUG_elog_output, "TO_NUMBER (numstr): '%s'", Np->numstr);
#endif
return Np->number;
return Np->numstr;
}
}
......@@ -4878,7 +4878,7 @@ do { \
if (len <= 0 || len >= (INT_MAX-VARHDRSZ)/NUM_MAX_ITEM_SIZ) \
PG_RETURN_TEXT_P(cstring_to_text("")); \
result = (text *) palloc0((len * NUM_MAX_ITEM_SIZ) + 1 + VARHDRSZ); \
format = NUM_cache(len, &Num, fmt, &shouldFree); \
format = NUM_cache(len, &Fmt, fmt, &shouldFree); \
} while (0)
/* ----------
......@@ -4889,7 +4889,7 @@ do { \
do { \
int len; \
\
NUM_processor(format, &Num, VARDATA(result), numstr, 0, out_pre_spaces, sign, true, PG_GET_COLLATION()); \
NUM_processor(format, &Fmt, VARDATA(result), numstr, 0, out_pre_spaces, sign, true, PG_GET_COLLATION()); \
\
if (shouldFree) \
pfree(format); \
......@@ -4912,7 +4912,7 @@ numeric_to_number(PG_FUNCTION_ARGS)
{
text *value = PG_GETARG_TEXT_P(0);
text *fmt = PG_GETARG_TEXT_P(1);
NUMDesc Num;
FmtDesc Fmt;
Datum result;
FormatNode *format;
char *numstr;
......@@ -4926,15 +4926,15 @@ numeric_to_number(PG_FUNCTION_ARGS)
if (len <= 0 || len >= INT_MAX / NUM_MAX_ITEM_SIZ)
PG_RETURN_NULL();
format = NUM_cache(len, &Num, fmt, &shouldFree);
format = NUM_cache(len, &Fmt, fmt, &shouldFree);
numstr = (char *) palloc((len * NUM_MAX_ITEM_SIZ) + 1);
NUM_processor(format, &Num, VARDATA(value), numstr,
NUM_processor(format, &Fmt, VARDATA(value), numstr,
VARSIZE(value) - VARHDRSZ, 0, 0, false, PG_GET_COLLATION());
scale = Num.post;
precision = Max(0, Num.pre) + scale;
scale = Fmt.post;
precision = Max(0, Fmt.pre) + scale;
if (shouldFree)
pfree(format);
......@@ -4956,7 +4956,7 @@ numeric_to_char(PG_FUNCTION_ARGS)
{
Numeric value = PG_GETARG_NUMERIC(0);
text *fmt = PG_GETARG_TEXT_P(1);
NUMDesc Num;
FmtDesc Fmt;
FormatNode *format;
text *result;
bool shouldFree;
......@@ -4972,7 +4972,7 @@ numeric_to_char(PG_FUNCTION_ARGS)
/*
* On DateType depend part (numeric)
*/
if (IS_ROMAN(&Num))
if (IS_ROMAN(&Fmt))
{
x = DatumGetNumeric(DirectFunctionCall2(numeric_round,
NumericGetDatum(value),
......@@ -4981,9 +4981,9 @@ numeric_to_char(PG_FUNCTION_ARGS)
int_to_roman(DatumGetInt32(DirectFunctionCall1(numeric_int4,
NumericGetDatum(x))));
}
else if (IS_EEEE(&Num))
else if (IS_EEEE(&Fmt))
{
orgnum = numeric_out_sci(value, Num.post);
orgnum = numeric_out_sci(value, Fmt.post);
/*
* numeric_out_sci() does not emit a sign for positive numbers. We
......@@ -4996,10 +4996,10 @@ numeric_to_char(PG_FUNCTION_ARGS)
* Allow 6 characters for the leading sign, the decimal point,
* "e", the exponent's sign and two exponent digits.
*/
numstr = (char *) palloc(Num.pre + Num.post + 7);
fill_str(numstr, '#', Num.pre + Num.post + 6);
numstr = (char *) palloc(Fmt.pre + Fmt.post + 7);
fill_str(numstr, '#', Fmt.pre + Fmt.post + 6);
*numstr = ' ';
*(numstr + Num.pre + 1) = '.';
*(numstr + Fmt.pre + 1) = '.';
}
else if (*orgnum != '-')
{
......@@ -5017,12 +5017,12 @@ numeric_to_char(PG_FUNCTION_ARGS)
int numstr_pre_len;
Numeric val = value;
if (IS_MULTI(&Num))
if (IS_MULTI(&Fmt))
{
Numeric a = DatumGetNumeric(DirectFunctionCall1(int4_numeric,
Int32GetDatum(10)));
Numeric b = DatumGetNumeric(DirectFunctionCall1(int4_numeric,
Int32GetDatum(Num.multi)));
Int32GetDatum(Fmt.multi)));
x = DatumGetNumeric(DirectFunctionCall2(numeric_power,
NumericGetDatum(a),
......@@ -5030,12 +5030,12 @@ numeric_to_char(PG_FUNCTION_ARGS)
val = DatumGetNumeric(DirectFunctionCall2(numeric_mul,
NumericGetDatum(value),
NumericGetDatum(x)));
Num.pre += Num.multi;
Fmt.pre += Fmt.multi;
}
x = DatumGetNumeric(DirectFunctionCall2(numeric_round,
NumericGetDatum(val),
Int32GetDatum(Num.post)));
Int32GetDatum(Fmt.post)));
orgnum = DatumGetCString(DirectFunctionCall1(numeric_out,
NumericGetDatum(x)));
......@@ -5056,14 +5056,14 @@ numeric_to_char(PG_FUNCTION_ARGS)
numstr_pre_len = strlen(numstr);
/* needs padding? */
if (numstr_pre_len < Num.pre)
out_pre_spaces = Num.pre - numstr_pre_len;
if (numstr_pre_len < Fmt.pre)
out_pre_spaces = Fmt.pre - numstr_pre_len;
/* overflowed prefix digit format? */
else if (numstr_pre_len > Num.pre)
else if (numstr_pre_len > Fmt.pre)
{
numstr = (char *) palloc(Num.pre + Num.post + 2);
fill_str(numstr, '#', Num.pre + Num.post + 1);
*(numstr + Num.pre) = '.';
numstr = (char *) palloc(Fmt.pre + Fmt.post + 2);
fill_str(numstr, '#', Fmt.pre + Fmt.post + 1);
*(numstr + Fmt.pre) = '.';
}
}
......@@ -5080,7 +5080,7 @@ int4_to_char(PG_FUNCTION_ARGS)
{
int32 value = PG_GETARG_INT32(0);
text *fmt = PG_GETARG_TEXT_P(1);
NUMDesc Num;
FmtDesc Fmt;
FormatNode *format;
text *result;
bool shouldFree;
......@@ -5094,15 +5094,15 @@ int4_to_char(PG_FUNCTION_ARGS)
/*
* On DateType depend part (int32)
*/
if (IS_ROMAN(&Num))
if (IS_ROMAN(&Fmt))
numstr = orgnum = int_to_roman(value);
else if (IS_EEEE(&Num))
else if (IS_EEEE(&Fmt))
{
/* we can do it easily because float8 won't lose any precision */
float8 val = (float8) value;
orgnum = (char *) palloc(MAXDOUBLEWIDTH + 1);
snprintf(orgnum, MAXDOUBLEWIDTH + 1, "%+.*e", Num.post, val);
snprintf(orgnum, MAXDOUBLEWIDTH + 1, "%+.*e", Fmt.post, val);
/*
* Swap a leading positive sign for a space.
......@@ -5116,11 +5116,11 @@ int4_to_char(PG_FUNCTION_ARGS)
{
int numstr_pre_len;
if (IS_MULTI(&Num))
if (IS_MULTI(&Fmt))
{
orgnum = DatumGetCString(DirectFunctionCall1(int4out,
Int32GetDatum(value * ((int32) pow((double) 10, (double) Num.multi)))));
Num.pre += Num.multi;
Int32GetDatum(value * ((int32) pow((double) 10, (double) Fmt.multi)))));
Fmt.pre += Fmt.multi;
}
else
{
......@@ -5139,26 +5139,26 @@ int4_to_char(PG_FUNCTION_ARGS)
numstr_pre_len = strlen(orgnum);
/* post-decimal digits? Pad out with zeros. */
if (Num.post)
if (Fmt.post)
{
numstr = (char *) palloc(numstr_pre_len + Num.post + 2);
numstr = (char *) palloc(numstr_pre_len + Fmt.post + 2);
strcpy(numstr, orgnum);
*(numstr + numstr_pre_len) = '.';
memset(numstr + numstr_pre_len + 1, '0', Num.post);
*(numstr + numstr_pre_len + Num.post + 1) = '\0';
memset(numstr + numstr_pre_len + 1, '0', Fmt.post);
*(numstr + numstr_pre_len + Fmt.post + 1) = '\0';
}
else
numstr = orgnum;
/* needs padding? */
if (numstr_pre_len < Num.pre)
out_pre_spaces = Num.pre - numstr_pre_len;
if (numstr_pre_len < Fmt.pre)
out_pre_spaces = Fmt.pre - numstr_pre_len;
/* overflowed prefix digit format? */
else if (numstr_pre_len > Num.pre)
else if (numstr_pre_len > Fmt.pre)
{
numstr = (char *) palloc(Num.pre + Num.post + 2);
fill_str(numstr, '#', Num.pre + Num.post + 1);
*(numstr + Num.pre) = '.';
numstr = (char *) palloc(Fmt.pre + Fmt.post + 2);
fill_str(numstr, '#', Fmt.pre + Fmt.post + 1);
*(numstr + Fmt.pre) = '.';
}
}
......@@ -5175,7 +5175,7 @@ int8_to_char(PG_FUNCTION_ARGS)
{
int64 value = PG_GETARG_INT64(0);
text *fmt = PG_GETARG_TEXT_P(1);
NUMDesc Num;
FmtDesc Fmt;
FormatNode *format;
text *result;
bool shouldFree;
......@@ -5189,20 +5189,20 @@ int8_to_char(PG_FUNCTION_ARGS)
/*
* On DateType depend part (int32)
*/
if (IS_ROMAN(&Num))
if (IS_ROMAN(&Fmt))
{
/* Currently don't support int8 conversion to roman... */
numstr = orgnum = int_to_roman(DatumGetInt32(
DirectFunctionCall1(int84, Int64GetDatum(value))));
}
else if (IS_EEEE(&Num))
else if (IS_EEEE(&Fmt))
{
/* to avoid loss of precision, must go via numeric not float8 */
Numeric val;
val = DatumGetNumeric(DirectFunctionCall1(int8_numeric,
Int64GetDatum(value)));
orgnum = numeric_out_sci(val, Num.post);
orgnum = numeric_out_sci(val, Fmt.post);
/*
* numeric_out_sci() does not emit a sign for positive numbers. We
......@@ -5224,15 +5224,15 @@ int8_to_char(PG_FUNCTION_ARGS)
{
int numstr_pre_len;
if (IS_MULTI(&Num))
if (IS_MULTI(&Fmt))
{
double multi = pow((double) 10, (double) Num.multi);
double multi = pow((double) 10, (double) Fmt.multi);
value = DatumGetInt64(DirectFunctionCall2(int8mul,
Int64GetDatum(value),
DirectFunctionCall1(dtoi8,
Float8GetDatum(multi))));
Num.pre += Num.multi;
Fmt.pre += Fmt.multi;
}
orgnum = DatumGetCString(DirectFunctionCall1(int8out,
......@@ -5249,26 +5249,26 @@ int8_to_char(PG_FUNCTION_ARGS)
numstr_pre_len = strlen(orgnum);
/* post-decimal digits? Pad out with zeros. */
if (Num.post)
if (Fmt.post)
{
numstr = (char *) palloc(numstr_pre_len + Num.post + 2);
numstr = (char *) palloc(numstr_pre_len + Fmt.post + 2);
strcpy(numstr, orgnum);
*(numstr + numstr_pre_len) = '.';
memset(numstr + numstr_pre_len + 1, '0', Num.post);
*(numstr + numstr_pre_len + Num.post + 1) = '\0';
memset(numstr + numstr_pre_len + 1, '0', Fmt.post);
*(numstr + numstr_pre_len + Fmt.post + 1) = '\0';
}
else
numstr = orgnum;
/* needs padding? */
if (numstr_pre_len < Num.pre)
out_pre_spaces = Num.pre - numstr_pre_len;
if (numstr_pre_len < Fmt.pre)
out_pre_spaces = Fmt.pre - numstr_pre_len;
/* overflowed prefix digit format? */
else if (numstr_pre_len > Num.pre)
else if (numstr_pre_len > Fmt.pre)
{
numstr = (char *) palloc(Num.pre + Num.post + 2);
fill_str(numstr, '#', Num.pre + Num.post + 1);
*(numstr + Num.pre) = '.';
numstr = (char *) palloc(Fmt.pre + Fmt.post + 2);
fill_str(numstr, '#', Fmt.pre + Fmt.post + 1);
*(numstr + Fmt.pre) = '.';
}
}
......@@ -5285,7 +5285,7 @@ float4_to_char(PG_FUNCTION_ARGS)
{
float4 value = PG_GETARG_FLOAT4(0);
text *fmt = PG_GETARG_TEXT_P(1);
NUMDesc Num;
FmtDesc Fmt;
FormatNode *format;
text *result;
bool shouldFree;
......@@ -5297,9 +5297,9 @@ float4_to_char(PG_FUNCTION_ARGS)
NUM_TOCHAR_prepare;
if (IS_ROMAN(&Num))
if (IS_ROMAN(&Fmt))
numstr = orgnum = int_to_roman((int) rint(value));
else if (IS_EEEE(&Num))
else if (IS_EEEE(&Fmt))
{
numstr = orgnum = (char *) palloc(MAXDOUBLEWIDTH + 1);
if (isnan(value) || is_infinite(value))
......@@ -5308,14 +5308,14 @@ float4_to_char(PG_FUNCTION_ARGS)
* Allow 6 characters for the leading sign, the decimal point,
* "e", the exponent's sign and two exponent digits.
*/
numstr = (char *) palloc(Num.pre + Num.post + 7);
fill_str(numstr, '#', Num.pre + Num.post + 6);
numstr = (char *) palloc(Fmt.pre + Fmt.post + 7);
fill_str(numstr, '#', Fmt.pre + Fmt.post + 6);
*numstr = ' ';
*(numstr + Num.pre + 1) = '.';
*(numstr + Fmt.pre + 1) = '.';
}
else
{
snprintf(orgnum, MAXDOUBLEWIDTH + 1, "%+.*e", Num.post, value);
snprintf(orgnum, MAXDOUBLEWIDTH + 1, "%+.*e", Fmt.post, value);
/*
* Swap a leading positive sign for a space.
......@@ -5331,12 +5331,12 @@ float4_to_char(PG_FUNCTION_ARGS)
float4 val = value;
int numstr_pre_len;
if (IS_MULTI(&Num))
if (IS_MULTI(&Fmt))
{
float multi = pow((double) 10, (double) Num.multi);
float multi = pow((double) 10, (double) Fmt.multi);
val = value * multi;
Num.pre += Num.multi;
Fmt.pre += Fmt.multi;
}
orgnum = (char *) palloc(MAXFLOATWIDTH + 1);
......@@ -5345,10 +5345,10 @@ float4_to_char(PG_FUNCTION_ARGS)
/* adjust post digits to fit max float digits */
if (numstr_pre_len >= FLT_DIG)
Num.post = 0;
else if (numstr_pre_len + Num.post > FLT_DIG)
Num.post = FLT_DIG - numstr_pre_len;
snprintf(orgnum, MAXFLOATWIDTH + 1, "%.*f", Num.post, val);
Fmt.post = 0;
else if (numstr_pre_len + Fmt.post > FLT_DIG)
Fmt.post = FLT_DIG - numstr_pre_len;
snprintf(orgnum, MAXFLOATWIDTH + 1, "%.*f", Fmt.post, val);
if (*orgnum == '-')
{ /* < 0 */
......@@ -5367,14 +5367,14 @@ float4_to_char(PG_FUNCTION_ARGS)
numstr_pre_len = strlen(numstr);
/* needs padding? */
if (numstr_pre_len < Num.pre)
out_pre_spaces = Num.pre - numstr_pre_len;
if (numstr_pre_len < Fmt.pre)
out_pre_spaces = Fmt.pre - numstr_pre_len;
/* overflowed prefix digit format? */
else if (numstr_pre_len > Num.pre)
else if (numstr_pre_len > Fmt.pre)
{
numstr = (char *) palloc(Num.pre + Num.post + 2);
fill_str(numstr, '#', Num.pre + Num.post + 1);
*(numstr + Num.pre) = '.';
numstr = (char *) palloc(Fmt.pre + Fmt.post + 2);
fill_str(numstr, '#', Fmt.pre + Fmt.post + 1);
*(numstr + Fmt.pre) = '.';
}
}
......@@ -5391,7 +5391,7 @@ float8_to_char(PG_FUNCTION_ARGS)
{
float8 value = PG_GETARG_FLOAT8(0);
text *fmt = PG_GETARG_TEXT_P(1);
NUMDesc Num;
FmtDesc Fmt;
FormatNode *format;
text *result;
bool shouldFree;
......@@ -5403,9 +5403,9 @@ float8_to_char(PG_FUNCTION_ARGS)
NUM_TOCHAR_prepare;
if (IS_ROMAN(&Num))
if (IS_ROMAN(&Fmt))
numstr = orgnum = int_to_roman((int) rint(value));
else if (IS_EEEE(&Num))
else if (IS_EEEE(&Fmt))
{
numstr = orgnum = (char *) palloc(MAXDOUBLEWIDTH + 1);
if (isnan(value) || is_infinite(value))
......@@ -5414,14 +5414,14 @@ float8_to_char(PG_FUNCTION_ARGS)
* Allow 6 characters for the leading sign, the decimal point,
* "e", the exponent's sign and two exponent digits.
*/
numstr = (char *) palloc(Num.pre + Num.post + 7);
fill_str(numstr, '#', Num.pre + Num.post + 6);
numstr = (char *) palloc(Fmt.pre + Fmt.post + 7);
fill_str(numstr, '#', Fmt.pre + Fmt.post + 6);
*numstr = ' ';
*(numstr + Num.pre + 1) = '.';
*(numstr + Fmt.pre + 1) = '.';
}
else
{
snprintf(orgnum, MAXDOUBLEWIDTH + 1, "%+.*e", Num.post, value);
snprintf(orgnum, MAXDOUBLEWIDTH + 1, "%+.*e", Fmt.post, value);
/*
* Swap a leading positive sign for a space.
......@@ -5437,22 +5437,22 @@ float8_to_char(PG_FUNCTION_ARGS)
float8 val = value;
int numstr_pre_len;
if (IS_MULTI(&Num))
if (IS_MULTI(&Fmt))
{
double multi = pow((double) 10, (double) Num.multi);
double multi = pow((double) 10, (double) Fmt.multi);
val = value * multi;
Num.pre += Num.multi;
Fmt.pre += Fmt.multi;
}
orgnum = (char *) palloc(MAXDOUBLEWIDTH + 1);
numstr_pre_len = snprintf(orgnum, MAXDOUBLEWIDTH + 1, "%.0f", fabs(val));
/* adjust post digits to fit max double digits */
if (numstr_pre_len >= DBL_DIG)
Num.post = 0;
else if (numstr_pre_len + Num.post > DBL_DIG)
Num.post = DBL_DIG - numstr_pre_len;
snprintf(orgnum, MAXDOUBLEWIDTH + 1, "%.*f", Num.post, val);
Fmt.post = 0;
else if (numstr_pre_len + Fmt.post > DBL_DIG)
Fmt.post = DBL_DIG - numstr_pre_len;
snprintf(orgnum, MAXDOUBLEWIDTH + 1, "%.*f", Fmt.post, val);
if (*orgnum == '-')
{ /* < 0 */
......@@ -5471,14 +5471,14 @@ float8_to_char(PG_FUNCTION_ARGS)
numstr_pre_len = strlen(numstr);
/* needs padding? */
if (numstr_pre_len < Num.pre)
out_pre_spaces = Num.pre - numstr_pre_len;
if (numstr_pre_len < Fmt.pre)
out_pre_spaces = Fmt.pre - numstr_pre_len;
/* overflowed prefix digit format? */
else if (numstr_pre_len > Num.pre)
else if (numstr_pre_len > Fmt.pre)
{
numstr = (char *) palloc(Num.pre + Num.post + 2);
fill_str(numstr, '#', Num.pre + Num.post + 1);
*(numstr + Num.pre) = '.';
numstr = (char *) palloc(Fmt.pre + Fmt.post + 2);
fill_str(numstr, '#', Fmt.pre + Fmt.post + 1);
*(numstr + Fmt.pre) = '.';
}
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment