From f68dc5d86b9f287f80f4417f5a24d876eb13771d Mon Sep 17 00:00:00 2001 From: Bruce Momjian Date: Fri, 12 Sep 2014 20:34:25 -0400 Subject: [PATCH] More formatting.c variable renaming, for clarity --- src/backend/utils/adt/formatting.c | 620 ++++++++++++++--------------- 1 file changed, 310 insertions(+), 310 deletions(-) diff --git a/src/backend/utils/adt/formatting.c b/src/backend/utils/adt/formatting.c index d5ff246c7b..d9d97ca6d6 100644 --- a/src/backend/utils/adt/formatting.c +++ b/src/backend/utils/adt/formatting.c @@ -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 : "", - 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) = '.'; } }