#include "postgres.h"
#include <ctype.h>
#include <unistd.h>
#include <math.h>
#include <float.h>
#include <limits.h>
#include <wctype.h>
#include "catalog/pg_collation.h"
#include "catalog/pg_type.h"
#include "mb/pg_wchar.h"
#include "nodes/miscnodes.h"
#include "parser/scansup.h"
#include "utils/builtins.h"
#include "utils/date.h"
#include "utils/datetime.h"
#include "utils/formatting.h"
#include "utils/memutils.h"
#include "utils/numeric.h"
#include "utils/pg_locale.h"
#include "varatt.h"

Include dependency graph for formatting.c:

Data Structures
struct	KeySuffix

struct	KeyWord

struct	FormatNode

struct	NUMDesc

struct	DCHCacheEntry

struct	NUMCacheEntry

struct	TmFromChar

struct	fmt_tm

struct	TmToChar

struct	NUMProc

Macros
#define	DCH_FLAG 0x1 /* DATE-TIME flag */

#define	NUM_FLAG 0x2 /* NUMBER flag */

#define	STD_FLAG 0x4 /* STANDARD flag */

#define	KeyWord_INDEX_SIZE ('~' - ' ')

#define	KeyWord_INDEX_FILTER(_c) ((_c) <= ' ' \|\| (_c) >= '~' ? 0 : 1)

#define	DCH_MAX_ITEM_SIZ 12 /* max localized day name */

#define	NUM_MAX_ITEM_SIZ 8 /* roman number (RN has 15 chars) */

#define	NODE_TYPE_END 1

#define	NODE_TYPE_ACTION 2

#define	NODE_TYPE_CHAR 3

#define	NODE_TYPE_SEPARATOR 4

#define	NODE_TYPE_SPACE 5

#define	SUFFTYPE_PREFIX 1

#define	SUFFTYPE_POSTFIX 2

#define	CLOCK_24_HOUR 0

#define	CLOCK_12_HOUR 1

#define	ADJUST_YEAR(year, is_interval) ((is_interval) ? (year) : ((year) <= 0 ? -((year) - 1) : (year)))

#define	A_D_STR "A.D."

#define	a_d_STR "a.d."

#define	AD_STR "AD"

#define	ad_STR "ad"

#define	B_C_STR "B.C."

#define	b_c_STR "b.c."

#define	BC_STR "BC"

#define	bc_STR "bc"

#define	A_M_STR "A.M."

#define	a_m_STR "a.m."

#define	AM_STR "AM"

#define	am_STR "am"

#define	P_M_STR "P.M."

#define	p_m_STR "p.m."

#define	PM_STR "PM"

#define	pm_STR "pm"

#define	TH_UPPER 1

#define	TH_LOWER 2

#define	NUM_F_DECIMAL (1 << 1)

#define	NUM_F_LDECIMAL (1 << 2)

#define	NUM_F_ZERO (1 << 3)

#define	NUM_F_BLANK (1 << 4)

#define	NUM_F_FILLMODE (1 << 5)

#define	NUM_F_LSIGN (1 << 6)

#define	NUM_F_BRACKET (1 << 7)

#define	NUM_F_MINUS (1 << 8)

#define	NUM_F_PLUS (1 << 9)

#define	NUM_F_ROMAN (1 << 10)

#define	NUM_F_MULTI (1 << 11)

#define	NUM_F_PLUS_POST (1 << 12)

#define	NUM_F_MINUS_POST (1 << 13)

#define	NUM_F_EEEE (1 << 14)

#define	NUM_LSIGN_PRE (-1)

#define	NUM_LSIGN_POST 1

#define	NUM_LSIGN_NONE 0

#define	IS_DECIMAL(_f) ((_f)->flag & NUM_F_DECIMAL)

#define	IS_LDECIMAL(_f) ((_f)->flag & NUM_F_LDECIMAL)

#define	IS_ZERO(_f) ((_f)->flag & NUM_F_ZERO)

#define	IS_BLANK(_f) ((_f)->flag & NUM_F_BLANK)

#define	IS_FILLMODE(_f) ((_f)->flag & NUM_F_FILLMODE)

#define	IS_BRACKET(_f) ((_f)->flag & NUM_F_BRACKET)

#define	IS_MINUS(_f) ((_f)->flag & NUM_F_MINUS)

#define	IS_LSIGN(_f) ((_f)->flag & NUM_F_LSIGN)

#define	IS_PLUS(_f) ((_f)->flag & NUM_F_PLUS)

#define	IS_ROMAN(_f) ((_f)->flag & NUM_F_ROMAN)

#define	IS_MULTI(_f) ((_f)->flag & NUM_F_MULTI)

#define	IS_EEEE(_f) ((_f)->flag & NUM_F_EEEE)

#define	DCH_CACHE_OVERHEAD MAXALIGN(sizeof(bool) + sizeof(int))

#define	NUM_CACHE_OVERHEAD MAXALIGN(sizeof(bool) + sizeof(int) + sizeof(NUMDesc))

#define	DCH_CACHE_SIZE ((2048 - DCH_CACHE_OVERHEAD) / (sizeof(FormatNode) + sizeof(char)) - 1)

#define	NUM_CACHE_SIZE ((1024 - NUM_CACHE_OVERHEAD) / (sizeof(FormatNode) + sizeof(char)) - 1)

#define	DCH_CACHE_ENTRIES 20

#define	NUM_CACHE_ENTRIES 20

#define	ZERO_tmfc(_X) memset(_X, 0, sizeof(TmFromChar))

#define	DEBUG_TMFC(_X)

#define	DEBUG_TM(_X)

#define	tmtcTm(_X) (&(_X)->tm)

#define	tmtcTzn(_X) ((_X)->tzn)

#define	tmtcFsec(_X) ((_X)->fsec)

#define	COPY_tm(_DST, _SRC)

#define	ZERO_tm(_X)

#define	ZERO_tmtc(_X)

#define	INVALID_FOR_INTERVAL

#define	DCH_S_FM 0x01

#define	DCH_S_TH 0x02

#define	DCH_S_th 0x04

#define	DCH_S_SP 0x08

#define	DCH_S_TM 0x10

#define	S_THth(_s) ((((_s) & DCH_S_TH) \|\| ((_s) & DCH_S_th)) ? 1 : 0)

#define	S_TH(_s) (((_s) & DCH_S_TH) ? 1 : 0)

#define	S_th(_s) (((_s) & DCH_S_th) ? 1 : 0)

#define	S_TH_TYPE(_s) (((_s) & DCH_S_TH) ? TH_UPPER : TH_LOWER)

#define	S_FM(_s) (((_s) & DCH_S_FM) ? 1 : 0)

#define	S_SP(_s) (((_s) & DCH_S_SP) ? 1 : 0)

#define	S_TM(_s) (((_s) & DCH_S_TM) ? 1 : 0)

#define	TM_SUFFIX_LEN 2

#define	DCH_DATED 0x01

#define	DCH_TIMED 0x02

#define	DCH_ZONED 0x04

#define	SKIP_THth(ptr, _suf)

#define	DCH_to_char_fsec(frac_fmt, frac_val)

#define	zeroize_NUM(_n)

#define	OVERLOAD_TEST (Np->inout_p >= Np->inout + input_len)

#define	AMOUNT_TEST(s) (Np->inout_p <= Np->inout + (input_len - (s)))

#define	IS_PREDEC_SPACE(_n)

#define	NUM_TOCHAR_prepare

#define	NUM_TOCHAR_finish

Typedefs
typedef struct TmToChar	TmToChar

typedef struct NUMProc	NUMProc

Enumerations
enum	FromCharDateMode { FROM_CHAR_DATE_NONE = 0 , FROM_CHAR_DATE_GREGORIAN , FROM_CHAR_DATE_ISOWEEK }

enum	DCH_poz { DCH_A_D , DCH_A_M , DCH_AD , DCH_AM , DCH_B_C , DCH_BC , DCH_CC , DCH_DAY , DCH_DDD , DCH_DD , DCH_DY , DCH_Day , DCH_Dy , DCH_D , DCH_FF1 , DCH_FF2 , DCH_FF3 , DCH_FF4 , DCH_FF5 , DCH_FF6 , DCH_FX , DCH_HH24 , DCH_HH12 , DCH_HH , DCH_IDDD , DCH_ID , DCH_IW , DCH_IYYY , DCH_IYY , DCH_IY , DCH_I , DCH_J , DCH_MI , DCH_MM , DCH_MONTH , DCH_MON , DCH_MS , DCH_Month , DCH_Mon , DCH_OF , DCH_P_M , DCH_PM , DCH_Q , DCH_RM , DCH_SSSSS , DCH_SSSS , DCH_SS , DCH_TZH , DCH_TZM , DCH_TZ , DCH_US , DCH_WW , DCH_W , DCH_Y_YYY , DCH_YYYY , DCH_YYY , DCH_YY , DCH_Y , DCH_a_d , DCH_a_m , DCH_ad , DCH_am , DCH_b_c , DCH_bc , DCH_cc , DCH_day , DCH_ddd , DCH_dd , DCH_dy , DCH_d , DCH_ff1 , DCH_ff2 , DCH_ff3 , DCH_ff4 , DCH_ff5 , DCH_ff6 , DCH_fx , DCH_hh24 , DCH_hh12 , DCH_hh , DCH_iddd , DCH_id , DCH_iw , DCH_iyyy , DCH_iyy , DCH_iy , DCH_i , DCH_j , DCH_mi , DCH_mm , DCH_month , DCH_mon , DCH_ms , DCH_of , DCH_p_m , DCH_pm , DCH_q , DCH_rm , DCH_sssss , DCH_ssss , DCH_ss , DCH_tzh , DCH_tzm , DCH_tz , DCH_us , DCH_ww , DCH_w , DCH_y_yyy , DCH_yyyy , DCH_yyy , DCH_yy , DCH_y , _DCH_last_ }

enum	NUM_poz { NUM_COMMA , NUM_DEC , NUM_0 , NUM_9 , NUM_B , NUM_C , NUM_D , NUM_E , NUM_FM , NUM_G , NUM_L , NUM_MI , NUM_PL , NUM_PR , NUM_RN , NUM_SG , NUM_SP , NUM_S , NUM_TH , NUM_V , NUM_b , NUM_c , NUM_d , NUM_e , NUM_fm , NUM_g , NUM_l , NUM_mi , NUM_pl , NUM_pr , NUM_rn , NUM_sg , NUM_sp , NUM_s , NUM_th , NUM_v , _NUM_last_ }

Functions
static const KeyWord *	index_seq_search (const char str, const KeyWord kw, const int *index)

static const KeySuffix *	suff_search (const char str, const KeySuffix suf, int type)

static bool	is_separator_char (const char *str)

static void	NUMDesc_prepare (NUMDesc num, FormatNode n)

static void	parse_format (FormatNode node, const char str, const KeyWord kw, const KeySuffix suf, const int index, uint32 flags, NUMDesc Num)

static void	DCH_to_char (FormatNode node, bool is_interval, TmToChar in, char *out, Oid collid)

static void	DCH_from_char (FormatNode node, const char in, TmFromChar out, Oid collid, bool std, Node escontext)

static const char *	get_th (char *num, int type)

static char *	str_numth (char dest, char num, int type)

static int	adjust_partial_year_to_2020 (int year)

static int	strspace_len (const char *str)

static bool	from_char_set_mode (TmFromChar tmfc, const FromCharDateMode mode, Node escontext)

static bool	from_char_set_int (int dest, const int value, const FormatNode node, Node *escontext)

static int	from_char_parse_int_len (int dest, const char src, const int len, FormatNode node, Node *escontext)

static int	from_char_parse_int (int dest, const char src, FormatNode node, Node *escontext)

static int	seq_search_ascii (const char name, const char const array, int len)

static int	seq_search_localized (const char name, char array, int len, Oid collid)

static bool	from_char_seq_search (int dest, const char src, const char const array, char localized_array, Oid collid, FormatNode node, Node *escontext)

static bool	do_to_timestamp (text date_txt, text fmt, Oid collid, bool std, struct pg_tm tm, fsec_t fsec, int fprec, uint32 flags, Node *escontext)

static char *	fill_str (char *str, int c, int max)

static FormatNode *	NUM_cache (int len, NUMDesc Num, 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 input_len, int to_char_out_pre_spaces, int sign, bool is_to_char, Oid collid)

static DCHCacheEntry *	DCH_cache_getnew (const char *str, bool std)

static DCHCacheEntry *	DCH_cache_search (const char *str, bool std)

static DCHCacheEntry *	DCH_cache_fetch (const char *str, bool std)

static NUMCacheEntry *	NUM_cache_getnew (const char *str)

static NUMCacheEntry *	NUM_cache_search (const char *str)

static NUMCacheEntry *	NUM_cache_fetch (const char *str)

char *	str_tolower (const char *buff, size_t nbytes, Oid collid)

char *	str_toupper (const char *buff, size_t nbytes, Oid collid)

char *	str_initcap (const char *buff, size_t nbytes, Oid collid)

char *	asc_tolower (const char *buff, size_t nbytes)

char *	asc_toupper (const char *buff, size_t nbytes)

char *	asc_initcap (const char *buff, size_t nbytes)

static char *	str_tolower_z (const char *buff, Oid collid)

static char *	str_toupper_z (const char *buff, Oid collid)

static char *	str_initcap_z (const char *buff, Oid collid)

static char *	asc_tolower_z (const char *buff)

static char *	asc_toupper_z (const char *buff)

static bool	is_next_separator (FormatNode *n)

static void	DCH_prevent_counter_overflow (void)

static int	DCH_datetime_type (FormatNode *node)

static text *	datetime_to_char_body (TmToChar tmtc, text fmt, bool is_interval, Oid collid)

Datum	timestamp_to_char (PG_FUNCTION_ARGS)

Datum	timestamptz_to_char (PG_FUNCTION_ARGS)

Datum	interval_to_char (PG_FUNCTION_ARGS)

Datum	to_timestamp (PG_FUNCTION_ARGS)

Datum	to_date (PG_FUNCTION_ARGS)

Datum	parse_datetime (text date_txt, text fmt, Oid collid, bool strict, Oid typid, int32 typmod, int tz, Node escontext)

static void	NUM_prevent_counter_overflow (void)

static void	NUM_eat_non_data_chars (NUMProc *Np, int n, int input_len)

Datum	numeric_to_number (PG_FUNCTION_ARGS)

Datum	numeric_to_char (PG_FUNCTION_ARGS)

Datum	int4_to_char (PG_FUNCTION_ARGS)

Datum	int8_to_char (PG_FUNCTION_ARGS)

Datum	float4_to_char (PG_FUNCTION_ARGS)

Datum	float8_to_char (PG_FUNCTION_ARGS)

Variables
static const char *const	months_full []

static const char *const	days_short []

static const char *const	adbc_strings [] = {ad_STR, bc_STR, AD_STR, BC_STR, NULL}

static const char *const	adbc_strings_long [] = {a_d_STR, b_c_STR, A_D_STR, B_C_STR, NULL}

static const char *const	ampm_strings [] = {am_STR, pm_STR, AM_STR, PM_STR, NULL}

static const char *const	ampm_strings_long [] = {a_m_STR, p_m_STR, A_M_STR, P_M_STR, NULL}

static const char *const	rm_months_upper []

static const char *const	rm_months_lower []

static const char *const	rm1 [] = {"I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", NULL}

static const char *const	rm10 [] = {"X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC", NULL}

static const char *const	rm100 [] = {"C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM", NULL}

static const char *const	numTH [] = {"ST", "ND", "RD", "TH", NULL}

static const char *const	numth [] = {"st", "nd", "rd", "th", NULL}

static DCHCacheEntry *	DCHCache [DCH_CACHE_ENTRIES]

static int	n_DCHCache = 0

static int	DCHCounter = 0

static NUMCacheEntry *	NUMCache [NUM_CACHE_ENTRIES]

static int	n_NUMCache = 0

static int	NUMCounter = 0

static const KeySuffix	DCH_suff []

static const KeyWord	DCH_keywords []

static const KeyWord	NUM_keywords []

static const int	DCH_index [KeyWord_INDEX_SIZE]

static const int	NUM_index [KeyWord_INDEX_SIZE]

Macro Definition Documentation

◆ A_D_STR

#define A_D_STR "A.D."

Definition at line 195 of file formatting.c.

◆ a_d_STR

#define a_d_STR "a.d."

Definition at line 196 of file formatting.c.

◆ A_M_STR

#define A_M_STR "A.M."

Definition at line 222 of file formatting.c.

◆ a_m_STR

#define a_m_STR "a.m."

Definition at line 223 of file formatting.c.

◆ AD_STR

#define AD_STR "AD"

Definition at line 197 of file formatting.c.

◆ ad_STR

#define ad_STR "ad"

Definition at line 198 of file formatting.c.

◆ ADJUST_YEAR

#define ADJUST_YEAR	(	year,
		is_interval
	)	((is_interval) ? (year) : ((year) <= 0 ? -((year) - 1) : (year)))

Definition at line 193 of file formatting.c.

◆ AM_STR

#define AM_STR "AM"

Definition at line 224 of file formatting.c.

◆ am_STR

#define am_STR "am"

Definition at line 225 of file formatting.c.

◆ AMOUNT_TEST

#define AMOUNT_TEST ( s ) (Np->inout_p <= Np->inout + (input_len - (s)))

Definition at line 5167 of file formatting.c.

◆ B_C_STR

#define B_C_STR "B.C."

Definition at line 200 of file formatting.c.

◆ b_c_STR

#define b_c_STR "b.c."

Definition at line 201 of file formatting.c.

◆ BC_STR

#define BC_STR "BC"

Definition at line 202 of file formatting.c.

◆ bc_STR

#define bc_STR "bc"

Definition at line 203 of file formatting.c.

◆ CLOCK_12_HOUR

#define CLOCK_12_HOUR 1

Definition at line 170 of file formatting.c.

◆ CLOCK_24_HOUR

#define CLOCK_24_HOUR 0

Definition at line 169 of file formatting.c.

◆ COPY_tm

#define COPY_tm	(	_DST,
		_SRC
	)

Value:

do {    \
    (_DST)->tm_sec = (_SRC)->tm_sec; \
    (_DST)->tm_min = (_SRC)->tm_min; \
    (_DST)->tm_hour = (_SRC)->tm_hour; \
    (_DST)->tm_mday = (_SRC)->tm_mday; \
    (_DST)->tm_mon = (_SRC)->tm_mon; \
    (_DST)->tm_year = (_SRC)->tm_year; \
    (_DST)->tm_wday = (_SRC)->tm_wday; \
    (_DST)->tm_yday = (_SRC)->tm_yday; \
    (_DST)->tm_gmtoff = (_SRC)->tm_gmtoff; \
} while(0)

Definition at line 483 of file formatting.c.

◆ DCH_CACHE_ENTRIES

#define DCH_CACHE_ENTRIES 20

Definition at line 364 of file formatting.c.

◆ DCH_CACHE_OVERHEAD

#define DCH_CACHE_OVERHEAD MAXALIGN(sizeof(bool) + sizeof(int))

Definition at line 354 of file formatting.c.

◆ DCH_CACHE_SIZE

#define DCH_CACHE_SIZE ((2048 - DCH_CACHE_OVERHEAD) / (sizeof(FormatNode) + sizeof(char)) - 1)

Definition at line 359 of file formatting.c.

◆ DCH_DATED

#define DCH_DATED 0x01

Definition at line 1015 of file formatting.c.

◆ DCH_FLAG

#define DCH_FLAG 0x1 /* DATE-TIME flag */

Definition at line 98 of file formatting.c.

◆ DCH_MAX_ITEM_SIZ

#define DCH_MAX_ITEM_SIZ 12 /* max localized day name */

Definition at line 113 of file formatting.c.

◆ DCH_S_FM

#define DCH_S_FM 0x01

Definition at line 531 of file formatting.c.

◆ DCH_S_SP

#define DCH_S_SP 0x08

Definition at line 534 of file formatting.c.

◆ DCH_S_TH

#define DCH_S_TH 0x02

Definition at line 532 of file formatting.c.

◆ DCH_S_th

#define DCH_S_th 0x04

Definition at line 533 of file formatting.c.

◆ DCH_S_TM

#define DCH_S_TM 0x10

Definition at line 535 of file formatting.c.

◆ DCH_TIMED

#define DCH_TIMED 0x02

Definition at line 1016 of file formatting.c.

◆ DCH_to_char_fsec

#define DCH_to_char_fsec	(	frac_fmt,
		frac_val
	)

Value:

                sprintf(s, frac_fmt, (int) (frac_val)); \
                if (S_THth(n->suffix)) \
                    str_numth(s, s, S_TH_TYPE(n->suffix)); \
                s += strlen(s)

◆ DCH_ZONED

#define DCH_ZONED 0x04

Definition at line 1017 of file formatting.c.

◆ DEBUG_TM

#define DEBUG_TM ( _X )

Definition at line 447 of file formatting.c.

◆ DEBUG_TMFC

#define DEBUG_TMFC ( _X )

Definition at line 446 of file formatting.c.

◆ INVALID_FOR_INTERVAL

#define INVALID_FOR_INTERVAL

Value:

do { \
    if (is_interval) \
        ereport(ERROR, \
                (errcode(ERRCODE_INVALID_DATETIME_FORMAT), \
                 errmsg("invalid format specification for an interval value"), \
                 errhint("Intervals are not tied to specific calendar dates."))); \
} while(0)

Definition at line 514 of file formatting.c.

◆ IS_BLANK

#define IS_BLANK ( _f ) ((_f)->flag & NUM_F_BLANK)

Definition at line 326 of file formatting.c.

◆ IS_BRACKET

#define IS_BRACKET ( _f ) ((_f)->flag & NUM_F_BRACKET)

Definition at line 328 of file formatting.c.

◆ IS_DECIMAL

#define IS_DECIMAL ( _f ) ((_f)->flag & NUM_F_DECIMAL)

Definition at line 323 of file formatting.c.

◆ IS_EEEE

#define IS_EEEE ( _f ) ((_f)->flag & NUM_F_EEEE)

Definition at line 334 of file formatting.c.

◆ IS_FILLMODE

#define IS_FILLMODE ( _f ) ((_f)->flag & NUM_F_FILLMODE)

Definition at line 327 of file formatting.c.

◆ IS_LDECIMAL

#define IS_LDECIMAL ( _f ) ((_f)->flag & NUM_F_LDECIMAL)

Definition at line 324 of file formatting.c.

◆ IS_LSIGN

#define IS_LSIGN ( _f ) ((_f)->flag & NUM_F_LSIGN)

Definition at line 330 of file formatting.c.

◆ IS_MINUS

#define IS_MINUS ( _f ) ((_f)->flag & NUM_F_MINUS)

Definition at line 329 of file formatting.c.

◆ IS_MULTI

#define IS_MULTI ( _f ) ((_f)->flag & NUM_F_MULTI)

Definition at line 333 of file formatting.c.

◆ IS_PLUS

#define IS_PLUS ( _f ) ((_f)->flag & NUM_F_PLUS)

Definition at line 331 of file formatting.c.

◆ IS_PREDEC_SPACE

#define IS_PREDEC_SPACE ( _n )

Value:

        (IS_ZERO((_n)->Num)==false && \
         (_n)->number == (_n)->number_p && \
         *(_n)->number == '0' && \
                 (_n)->Num->post != 0)

Definition at line 5378 of file formatting.c.

◆ IS_ROMAN

#define IS_ROMAN ( _f ) ((_f)->flag & NUM_F_ROMAN)

Definition at line 332 of file formatting.c.

◆ IS_ZERO

#define IS_ZERO ( _f ) ((_f)->flag & NUM_F_ZERO)

Definition at line 325 of file formatting.c.

◆ KeyWord_INDEX_FILTER

#define KeyWord_INDEX_FILTER ( _c ) ((_c) <= ' ' || (_c) >= '~' ? 0 : 1)

Definition at line 107 of file formatting.c.

◆ KeyWord_INDEX_SIZE

#define KeyWord_INDEX_SIZE ('~' - ' ')

Definition at line 106 of file formatting.c.

◆ NODE_TYPE_ACTION

#define NODE_TYPE_ACTION 2

Definition at line 161 of file formatting.c.

◆ NODE_TYPE_CHAR

#define NODE_TYPE_CHAR 3

Definition at line 162 of file formatting.c.

◆ NODE_TYPE_END

#define NODE_TYPE_END 1

Definition at line 160 of file formatting.c.

◆ NODE_TYPE_SEPARATOR

#define NODE_TYPE_SEPARATOR 4

Definition at line 163 of file formatting.c.

◆ NODE_TYPE_SPACE

#define NODE_TYPE_SPACE 5

Definition at line 164 of file formatting.c.

◆ NUM_CACHE_ENTRIES

#define NUM_CACHE_ENTRIES 20

Definition at line 365 of file formatting.c.

◆ NUM_CACHE_OVERHEAD

#define NUM_CACHE_OVERHEAD MAXALIGN(sizeof(bool) + sizeof(int) + sizeof(NUMDesc))

Definition at line 356 of file formatting.c.

◆ NUM_CACHE_SIZE

#define NUM_CACHE_SIZE ((1024 - NUM_CACHE_OVERHEAD) / (sizeof(FormatNode) + sizeof(char)) - 1)

Definition at line 361 of file formatting.c.

◆ NUM_F_BLANK

#define NUM_F_BLANK (1 << 4)

Definition at line 303 of file formatting.c.

◆ NUM_F_BRACKET

#define NUM_F_BRACKET (1 << 7)

Definition at line 306 of file formatting.c.

◆ NUM_F_DECIMAL

#define NUM_F_DECIMAL (1 << 1)

Definition at line 300 of file formatting.c.

◆ NUM_F_EEEE

#define NUM_F_EEEE (1 << 14)

Definition at line 313 of file formatting.c.

◆ NUM_F_FILLMODE

#define NUM_F_FILLMODE (1 << 5)

Definition at line 304 of file formatting.c.

◆ NUM_F_LDECIMAL

#define NUM_F_LDECIMAL (1 << 2)

Definition at line 301 of file formatting.c.

◆ NUM_F_LSIGN

#define NUM_F_LSIGN (1 << 6)

Definition at line 305 of file formatting.c.

◆ NUM_F_MINUS

#define NUM_F_MINUS (1 << 8)

Definition at line 307 of file formatting.c.

◆ NUM_F_MINUS_POST

#define NUM_F_MINUS_POST (1 << 13)

Definition at line 312 of file formatting.c.

◆ NUM_F_MULTI

#define NUM_F_MULTI (1 << 11)

Definition at line 310 of file formatting.c.

◆ NUM_F_PLUS

#define NUM_F_PLUS (1 << 9)

Definition at line 308 of file formatting.c.

◆ NUM_F_PLUS_POST

#define NUM_F_PLUS_POST (1 << 12)

Definition at line 311 of file formatting.c.

◆ NUM_F_ROMAN

#define NUM_F_ROMAN (1 << 10)

Definition at line 309 of file formatting.c.

◆ NUM_F_ZERO

#define NUM_F_ZERO (1 << 3)

Definition at line 302 of file formatting.c.

◆ NUM_FLAG

#define NUM_FLAG 0x2 /* NUMBER flag */

Definition at line 99 of file formatting.c.

◆ NUM_LSIGN_NONE

#define NUM_LSIGN_NONE 0

Definition at line 317 of file formatting.c.

◆ NUM_LSIGN_POST

#define NUM_LSIGN_POST 1

Definition at line 316 of file formatting.c.

◆ NUM_LSIGN_PRE

#define NUM_LSIGN_PRE (-1)

Definition at line 315 of file formatting.c.

◆ NUM_MAX_ITEM_SIZ

#define NUM_MAX_ITEM_SIZ 8 /* roman number (RN has 15 chars) */

Definition at line 114 of file formatting.c.

◆ NUM_TOCHAR_finish

#define NUM_TOCHAR_finish

Value:

do { \
    int     len; \
									\
	NUM_processor(format, &Num, VARDATA(result), numstr, 0, out_pre_spaces, sign, true, PG_GET_COLLATION()); \
									\
	if (shouldFree)                    \
        pfree(format);              \
                                    \
    /*                              \
     * Convert null-terminated representation of result to standard text. \
     * The result is usually much bigger than it needs to be, but there \
     * seems little point in realloc'ing it smaller. \
     */                             \
    len = strlen(VARDATA(result));  \
    SET_VARSIZE(result, len + VARHDRSZ); \
} while (0)

Definition at line 6089 of file formatting.c.

◆ NUM_TOCHAR_prepare

#define NUM_TOCHAR_prepare

Value:

do { \
    int len = VARSIZE_ANY_EXHDR(fmt); \
    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);       \
} while (0)

Definition at line 6076 of file formatting.c.

◆ OVERLOAD_TEST

#define OVERLOAD_TEST (Np->inout_p >= Np->inout + input_len)

Definition at line 5166 of file formatting.c.

◆ P_M_STR

#define P_M_STR "P.M."

Definition at line 227 of file formatting.c.

◆ p_m_STR

#define p_m_STR "p.m."

Definition at line 228 of file formatting.c.

◆ PM_STR

#define PM_STR "PM"

Definition at line 229 of file formatting.c.

◆ pm_STR

#define pm_STR "pm"

Definition at line 230 of file formatting.c.

◆ S_FM

#define S_FM ( _s ) (((_s) & DCH_S_FM) ? 1 : 0)

Definition at line 547 of file formatting.c.

◆ S_SP

#define S_SP ( _s ) (((_s) & DCH_S_SP) ? 1 : 0)

Definition at line 548 of file formatting.c.

◆ S_TH

#define S_TH ( _s ) (((_s) & DCH_S_TH) ? 1 : 0)

Definition at line 542 of file formatting.c.

◆ S_th

#define S_th ( _s ) (((_s) & DCH_S_th) ? 1 : 0)

Definition at line 543 of file formatting.c.

◆ S_TH_TYPE

#define S_TH_TYPE ( _s ) (((_s) & DCH_S_TH) ? TH_UPPER : TH_LOWER)

Definition at line 544 of file formatting.c.

◆ S_THth

#define S_THth ( _s ) ((((_s) & DCH_S_TH) || ((_s) & DCH_S_th)) ? 1 : 0)

Definition at line 541 of file formatting.c.

◆ S_TM

#define S_TM ( _s ) (((_s) & DCH_S_TM) ? 1 : 0)

Definition at line 549 of file formatting.c.

◆ SKIP_THth

#define SKIP_THth	(	ptr,
		_suf
	)

Value:

    do { \
        if (S_THth(_suf)) \
        { \
            if (*(ptr)) (ptr) += pg_mblen(ptr); \
            if (*(ptr)) (ptr) += pg_mblen(ptr); \
        } \
    } while (0)

Definition at line 2137 of file formatting.c.

◆ STD_FLAG

#define STD_FLAG 0x4 /* STANDARD flag */

Definition at line 100 of file formatting.c.

◆ SUFFTYPE_POSTFIX

#define SUFFTYPE_POSTFIX 2

Definition at line 167 of file formatting.c.

◆ SUFFTYPE_PREFIX

#define SUFFTYPE_PREFIX 1

Definition at line 166 of file formatting.c.

◆ TH_LOWER

#define TH_LOWER 2

Definition at line 277 of file formatting.c.

◆ TH_UPPER

#define TH_UPPER 1

Definition at line 276 of file formatting.c.

◆ TM_SUFFIX_LEN

#define TM_SUFFIX_LEN 2

Definition at line 555 of file formatting.c.

◆ tmtcFsec

#define tmtcFsec ( _X ) ((_X)->fsec)

Definition at line 480 of file formatting.c.

◆ tmtcTm

#define tmtcTm ( _X ) (&(_X)->tm)

Definition at line 478 of file formatting.c.

◆ tmtcTzn

#define tmtcTzn ( _X ) ((_X)->tzn)

Definition at line 479 of file formatting.c.

◆ ZERO_tm

#define ZERO_tm ( _X )

Value:

do {    \
    memset(_X, 0, sizeof(*(_X))); \
    (_X)->tm_mday = (_X)->tm_mon = 1; \
} while(0)

Definition at line 497 of file formatting.c.

◆ ZERO_tmfc

#define ZERO_tmfc ( _X ) memset(_X, 0, sizeof(TmFromChar))

Definition at line 427 of file formatting.c.

◆ ZERO_tmtc

#define ZERO_tmtc ( _X )

Value:

do { \
    ZERO_tm( tmtcTm(_X) ); \
    tmtcFsec(_X) = 0; \
    tmtcTzn(_X) = NULL; \
} while(0)

Definition at line 503 of file formatting.c.

◆ zeroize_NUM

#define zeroize_NUM ( _n )

Value:

do { \
    (_n)->flag      = 0;    \
    (_n)->lsign     = 0;    \
    (_n)->pre       = 0;    \
    (_n)->post      = 0;    \
    (_n)->pre_lsign_num = 0;    \
    (_n)->need_locale   = 0;    \
    (_n)->multi     = 0;    \
    (_n)->zero_start    = 0;    \
    (_n)->zero_end      = 0;    \
} while(0)

Definition at line 4814 of file formatting.c.

Typedef Documentation

◆ NUMProc

typedef struct NUMProc NUMProc

◆ TmToChar

typedef struct TmToChar TmToChar

Enumeration Type Documentation

◆ DCH_poz

enum DCH_poz

Enumerator
DCH_A_D
DCH_A_M
DCH_AD
DCH_AM
DCH_B_C
DCH_BC
DCH_CC
DCH_DAY
DCH_DDD
DCH_DD
DCH_DY
DCH_Day
DCH_Dy
DCH_D
DCH_FF1
DCH_FF2
DCH_FF3
DCH_FF4
DCH_FF5
DCH_FF6
DCH_FX
DCH_HH24
DCH_HH12
DCH_HH
DCH_IDDD
DCH_ID
DCH_IW
DCH_IYYY
DCH_IYY
DCH_IY
DCH_I
DCH_J
DCH_MI
DCH_MM
DCH_MONTH
DCH_MON
DCH_MS
DCH_Month
DCH_Mon
DCH_OF
DCH_P_M
DCH_PM
DCH_Q
DCH_RM
DCH_SSSSS
DCH_SSSS
DCH_SS
DCH_TZH
DCH_TZM
DCH_TZ
DCH_US
DCH_WW
DCH_W
DCH_Y_YYY
DCH_YYYY
DCH_YYY
DCH_YY
DCH_Y
DCH_a_d
DCH_a_m
DCH_ad
DCH_am
DCH_b_c
DCH_bc
DCH_cc
DCH_day
DCH_ddd
DCH_dd
DCH_dy
DCH_d
DCH_ff1
DCH_ff2
DCH_ff3
DCH_ff4
DCH_ff5
DCH_ff6
DCH_fx
DCH_hh24
DCH_hh12
DCH_hh
DCH_iddd
DCH_id
DCH_iw
DCH_iyyy
DCH_iyy
DCH_iy
DCH_i
DCH_j
DCH_mi
DCH_mm
DCH_month
DCH_mon
DCH_ms
DCH_of
DCH_p_m
DCH_pm
DCH_q
DCH_rm
DCH_sssss
DCH_ssss
DCH_ss
DCH_tzh
DCH_tzm
DCH_tz
DCH_us
DCH_ww
DCH_w
DCH_y_yyy
DCH_yyyy
DCH_yyy
DCH_yy
DCH_y
_DCH_last_

Definition at line 598 of file formatting.c.

 {
     DCH_A_D,
     DCH_A_M,
     DCH_AD,
     DCH_AM,
     DCH_B_C,
     DCH_BC,
     DCH_CC,
     DCH_DAY,
     DCH_DDD,
     DCH_DD,
     DCH_DY,
     DCH_Day,
     DCH_Dy,
     DCH_D,
     DCH_FF1,
     DCH_FF2,
     DCH_FF3,
     DCH_FF4,
     DCH_FF5,
     DCH_FF6,
     DCH_FX,                     /* global suffix */
     DCH_HH24,
     DCH_HH12,
     DCH_HH,
     DCH_IDDD,
     DCH_ID,
     DCH_IW,
     DCH_IYYY,
     DCH_IYY,
     DCH_IY,
     DCH_I,
     DCH_J,
     DCH_MI,
     DCH_MM,
     DCH_MONTH,
     DCH_MON,
     DCH_MS,
     DCH_Month,
     DCH_Mon,
     DCH_OF,
     DCH_P_M,
     DCH_PM,
     DCH_Q,
     DCH_RM,
     DCH_SSSSS,
     DCH_SSSS,
     DCH_SS,
     DCH_TZH,
     DCH_TZM,
     DCH_TZ,
     DCH_US,
     DCH_WW,
     DCH_W,
     DCH_Y_YYY,
     DCH_YYYY,
     DCH_YYY,
     DCH_YY,
     DCH_Y,
     DCH_a_d,
     DCH_a_m,
     DCH_ad,
     DCH_am,
     DCH_b_c,
     DCH_bc,
     DCH_cc,
     DCH_day,
     DCH_ddd,
     DCH_dd,
     DCH_dy,
     DCH_d,
     DCH_ff1,
     DCH_ff2,
     DCH_ff3,
     DCH_ff4,
     DCH_ff5,
     DCH_ff6,
     DCH_fx,
     DCH_hh24,
     DCH_hh12,
     DCH_hh,
     DCH_iddd,
     DCH_id,
     DCH_iw,
     DCH_iyyy,
     DCH_iyy,
     DCH_iy,
     DCH_i,
     DCH_j,
     DCH_mi,
     DCH_mm,
     DCH_month,
     DCH_mon,
     DCH_ms,
     DCH_of,
     DCH_p_m,
     DCH_pm,
     DCH_q,
     DCH_rm,
     DCH_sssss,
     DCH_ssss,
     DCH_ss,
     DCH_tzh,
     DCH_tzm,
     DCH_tz,
     DCH_us,
     DCH_ww,
     DCH_w,
     DCH_y_yyy,
     DCH_yyyy,
     DCH_yyy,
     DCH_yy,
     DCH_y,
  
     /* last */
     _DCH_last_
 }           DCH_poz;

◆ FromCharDateMode

enum FromCharDateMode

Enumerator
FROM_CHAR_DATE_NONE
FROM_CHAR_DATE_GREGORIAN
FROM_CHAR_DATE_ISOWEEK

Definition at line 136 of file formatting.c.

 {
     FROM_CHAR_DATE_NONE = 0,    /* Value does not affect date mode. */
     FROM_CHAR_DATE_GREGORIAN,   /* Gregorian (day, month, year) style date */
     FROM_CHAR_DATE_ISOWEEK      /* ISO 8601 week date */
 } FromCharDateMode;

◆ NUM_poz

enum NUM_poz

Enumerator
NUM_COMMA
NUM_DEC
NUM_0
NUM_9
NUM_B
NUM_C
NUM_D
NUM_E
NUM_FM
NUM_G
NUM_L
NUM_MI
NUM_PL
NUM_PR
NUM_RN
NUM_SG
NUM_SP
NUM_S
NUM_TH
NUM_V
NUM_b
NUM_c
NUM_d
NUM_e
NUM_fm
NUM_g
NUM_l
NUM_mi
NUM_pl
NUM_pr
NUM_rn
NUM_sg
NUM_sp
NUM_s
NUM_th
NUM_v
_NUM_last_

Definition at line 717 of file formatting.c.

 {
     NUM_COMMA,
     NUM_DEC,
     NUM_0,
     NUM_9,
     NUM_B,
     NUM_C,
     NUM_D,
     NUM_E,
     NUM_FM,
     NUM_G,
     NUM_L,
     NUM_MI,
     NUM_PL,
     NUM_PR,
     NUM_RN,
     NUM_SG,
     NUM_SP,
     NUM_S,
     NUM_TH,
     NUM_V,
     NUM_b,
     NUM_c,
     NUM_d,
     NUM_e,
     NUM_fm,
     NUM_g,
     NUM_l,
     NUM_mi,
     NUM_pl,
     NUM_pr,
     NUM_rn,
     NUM_sg,
     NUM_sp,
     NUM_s,
     NUM_th,
     NUM_v,
  
     /* last */
     _NUM_last_
 }           NUM_poz;

Function Documentation

◆ adjust_partial_year_to_2020()

static int adjust_partial_year_to_2020 ( int year )

static

Definition at line 2218 of file formatting.c.

 {
     /*
      * Adjust all dates toward 2020; this is effectively what happens when we
      * assume '70' is 1970 and '69' is 2069.
      */
     /* Force 0-69 into the 2000's */
     if (year < 70)
         return year + 2000;
     /* Force 70-99 into the 1900's */
     else if (year < 100)
         return year + 1900;
     /* Force 100-519 into the 2000's */
     else if (year < 520)
         return year + 2000;
     /* Force 520-999 into the 1000's */
     else if (year < 1000)
         return year + 1000;
     else
         return year;
 }

Referenced by DCH_from_char().

◆ asc_initcap()

char* asc_initcap	(	const char *	buff,
		size_t	nbytes
	)

Definition at line 2068 of file formatting.c.

 {
     char       *result;
     char       *p;
     int         wasalnum = false;
  
     if (!buff)
         return NULL;
  
     result = pnstrdup(buff, nbytes);
  
     for (p = result; *p; p++)
     {
         char        c;
  
         if (wasalnum)
             *p = c = pg_ascii_tolower((unsigned char) *p);
         else
             *p = c = pg_ascii_toupper((unsigned char) *p);
         /* we don't trust isalnum() here */
         wasalnum = ((c >= 'A' && c <= 'Z') ||
                     (c >= 'a' && c <= 'z') ||
                     (c >= '0' && c <= '9'));
     }
  
     return result;
 }

References pg_ascii_tolower(), pg_ascii_toupper(), and pnstrdup().

Referenced by str_initcap().

◆ asc_tolower()

char* asc_tolower	(	const char *	buff,
		size_t	nbytes
	)

Definition at line 2022 of file formatting.c.

 {
     char       *result;
     char       *p;
  
     if (!buff)
         return NULL;
  
     result = pnstrdup(buff, nbytes);
  
     for (p = result; *p; p++)
         *p = pg_ascii_tolower((unsigned char) *p);
  
     return result;
 }

References pg_ascii_tolower(), and pnstrdup().

Referenced by asc_tolower_z(), and str_tolower().

◆ asc_tolower_z()

static char* asc_tolower_z ( const char * buff )

static

Definition at line 2117 of file formatting.c.

 {
     return asc_tolower(buff, strlen(buff));
 }

References asc_tolower().

Referenced by DCH_to_char(), and NUM_processor().

◆ asc_toupper()

char* asc_toupper	(	const char *	buff,
		size_t	nbytes
	)

Definition at line 2045 of file formatting.c.

 {
     char       *result;
     char       *p;
  
     if (!buff)
         return NULL;
  
     result = pnstrdup(buff, nbytes);
  
     for (p = result; *p; p++)
         *p = pg_ascii_toupper((unsigned char) *p);
  
     return result;
 }

References pg_ascii_toupper(), and pnstrdup().

Referenced by asc_toupper_z(), and str_toupper().

◆ asc_toupper_z()

static char* asc_toupper_z ( const char * buff )

static

Definition at line 2123 of file formatting.c.

 {
     return asc_toupper(buff, strlen(buff));
 }

References asc_toupper().

Referenced by DCH_to_char().

◆ datetime_to_char_body()

static text* datetime_to_char_body	(	TmToChar *	tmtc,
		text *	fmt,
		bool	is_interval,
		Oid	collid
	)

static

Definition at line 3993 of file formatting.c.

 {
     FormatNode *format;
     char       *fmt_str,
                *result;
     bool        incache;
     int         fmt_len;
     text       *res;
  
     /*
      * Convert fmt to C string
      */
     fmt_str = text_to_cstring(fmt);
     fmt_len = strlen(fmt_str);
  
     /*
      * Allocate workspace for result as C string
      */
     result = palloc((fmt_len * DCH_MAX_ITEM_SIZ) + 1);
     *result = '\0';
  
     if (fmt_len > DCH_CACHE_SIZE)
     {
         /*
          * Allocate new memory if format picture is bigger than static cache
          * and do not use cache (call parser always)
          */
         incache = false;
  
         format = (FormatNode *) palloc((fmt_len + 1) * sizeof(FormatNode));
  
         parse_format(format, fmt_str, DCH_keywords,
                      DCH_suff, DCH_index, DCH_FLAG, NULL);
     }
     else
     {
         /*
          * Use cache buffers
          */
         DCHCacheEntry *ent = DCH_cache_fetch(fmt_str, false);
  
         incache = true;
         format = ent->format;
     }
  
     /* The real work is here */
     DCH_to_char(format, is_interval, tmtc, result, collid);
  
     if (!incache)
         pfree(format);
  
     pfree(fmt_str);
  
     /* convert C-string result to TEXT format */
     res = cstring_to_text(result);
  
     pfree(result);
     return res;
 }

References collid, cstring_to_text(), DCH_cache_fetch(), DCH_CACHE_SIZE, DCH_FLAG, DCH_index, DCH_keywords, DCH_MAX_ITEM_SIZ, DCH_suff, DCH_to_char(), fmt, DCHCacheEntry::format, format, palloc(), parse_format(), pfree(), res, and text_to_cstring().

Referenced by interval_to_char(), timestamp_to_char(), and timestamptz_to_char().

◆ DCH_cache_fetch()

static DCHCacheEntry * DCH_cache_fetch	(	const char *	str,
		bool	std
	)

static

Definition at line 3966 of file formatting.c.

 {
     DCHCacheEntry *ent;
  
     if ((ent = DCH_cache_search(str, std)) == NULL)
     {
         /*
          * Not in the cache, must run parser and save a new format-picture to
          * the cache.  Do not mark the cache entry valid until parsing
          * succeeds.
          */
         ent = DCH_cache_getnew(str, std);
  
         parse_format(ent->format, str, DCH_keywords, DCH_suff, DCH_index,
                      DCH_FLAG | (std ? STD_FLAG : 0), NULL);
  
         ent->valid = true;
     }
     return ent;
 }

References DCH_cache_getnew(), DCH_cache_search(), DCH_FLAG, DCH_index, DCH_keywords, DCH_suff, DCHCacheEntry::format, parse_format(), STD_FLAG, generate_unaccent_rules::str, and DCHCacheEntry::valid.

Referenced by datetime_to_char_body(), and do_to_timestamp().

◆ DCH_cache_getnew()

static DCHCacheEntry * DCH_cache_getnew	(	const char *	str,
		bool	std
	)

static

Definition at line 3885 of file formatting.c.

 {
     DCHCacheEntry *ent;
  
     /* Ensure we can advance DCHCounter below */
     DCH_prevent_counter_overflow();
  
     /*
      * If cache is full, remove oldest entry (or recycle first not-valid one)
      */
     if (n_DCHCache >= DCH_CACHE_ENTRIES)
     {
         DCHCacheEntry *old = DCHCache[0];
  
 #ifdef DEBUG_TO_FROM_CHAR
         elog(DEBUG_elog_output, "cache is full (%d)", n_DCHCache);
 #endif
         if (old->valid)
         {
             for (int i = 1; i < DCH_CACHE_ENTRIES; i++)
             {
                 ent = DCHCache[i];
                 if (!ent->valid)
                 {
                     old = ent;
                     break;
                 }
                 if (ent->age < old->age)
                     old = ent;
             }
         }
 #ifdef DEBUG_TO_FROM_CHAR
         elog(DEBUG_elog_output, "OLD: '%s' AGE: %d", old->str, old->age);
 #endif
         old->valid = false;
         strlcpy(old->str, str, DCH_CACHE_SIZE + 1);
         old->age = (++DCHCounter);
         /* caller is expected to fill format, then set valid */
         return old;
     }
     else
     {
 #ifdef DEBUG_TO_FROM_CHAR
         elog(DEBUG_elog_output, "NEW (%d)", n_DCHCache);
 #endif
         Assert(DCHCache[n_DCHCache] == NULL);
         DCHCache[n_DCHCache] = ent = (DCHCacheEntry *)
             MemoryContextAllocZero(TopMemoryContext, sizeof(DCHCacheEntry));
         ent->valid = false;
         strlcpy(ent->str, str, DCH_CACHE_SIZE + 1);
         ent->std = std;
         ent->age = (++DCHCounter);
         /* caller is expected to fill format, then set valid */
         ++n_DCHCache;
         return ent;
     }
 }

References DCHCacheEntry::age, Assert(), DCH_CACHE_ENTRIES, DCH_CACHE_SIZE, DCH_prevent_counter_overflow(), DCHCache, DCHCounter, elog(), i, MemoryContextAllocZero(), n_DCHCache, DCHCacheEntry::std, generate_unaccent_rules::str, DCHCacheEntry::str, strlcpy(), TopMemoryContext, and DCHCacheEntry::valid.

Referenced by DCH_cache_fetch().

◆ DCH_cache_search()

static DCHCacheEntry * DCH_cache_search	(	const char *	str,
		bool	std
	)

static

Definition at line 3945 of file formatting.c.

 {
     /* Ensure we can advance DCHCounter below */
     DCH_prevent_counter_overflow();
  
     for (int i = 0; i < n_DCHCache; i++)
     {
         DCHCacheEntry *ent = DCHCache[i];
  
         if (ent->valid && strcmp(ent->str, str) == 0 && ent->std == std)
         {
             ent->age = (++DCHCounter);
             return ent;
         }
     }
  
     return NULL;
 }

References DCHCacheEntry::age, DCH_prevent_counter_overflow(), DCHCache, DCHCounter, i, n_DCHCache, DCHCacheEntry::std, generate_unaccent_rules::str, DCHCacheEntry::str, and DCHCacheEntry::valid.

Referenced by DCH_cache_fetch().

◆ DCH_datetime_type()

static int DCH_datetime_type ( FormatNode * node )

static

Definition at line 3788 of file formatting.c.

 {
     FormatNode *n;
     int         flags = 0;
  
     for (n = node; n->type != NODE_TYPE_END; n++)
     {
         if (n->type != NODE_TYPE_ACTION)
             continue;
  
         switch (n->key->id)
         {
             case DCH_FX:
                 break;
             case DCH_A_M:
             case DCH_P_M:
             case DCH_a_m:
             case DCH_p_m:
             case DCH_AM:
             case DCH_PM:
             case DCH_am:
             case DCH_pm:
             case DCH_HH:
             case DCH_HH12:
             case DCH_HH24:
             case DCH_MI:
             case DCH_SS:
             case DCH_MS:        /* millisecond */
             case DCH_US:        /* microsecond */
             case DCH_FF1:
             case DCH_FF2:
             case DCH_FF3:
             case DCH_FF4:
             case DCH_FF5:
             case DCH_FF6:
             case DCH_SSSS:
                 flags |= DCH_TIMED;
                 break;
             case DCH_tz:
             case DCH_TZ:
             case DCH_OF:
             case DCH_TZH:
             case DCH_TZM:
                 flags |= DCH_ZONED;
                 break;
             case DCH_A_D:
             case DCH_B_C:
             case DCH_a_d:
             case DCH_b_c:
             case DCH_AD:
             case DCH_BC:
             case DCH_ad:
             case DCH_bc:
             case DCH_MONTH:
             case DCH_Month:
             case DCH_month:
             case DCH_MON:
             case DCH_Mon:
             case DCH_mon:
             case DCH_MM:
             case DCH_DAY:
             case DCH_Day:
             case DCH_day:
             case DCH_DY:
             case DCH_Dy:
             case DCH_dy:
             case DCH_DDD:
             case DCH_IDDD:
             case DCH_DD:
             case DCH_D:
             case DCH_ID:
             case DCH_WW:
             case DCH_Q:
             case DCH_CC:
             case DCH_Y_YYY:
             case DCH_YYYY:
             case DCH_IYYY:
             case DCH_YYY:
             case DCH_IYY:
             case DCH_YY:
             case DCH_IY:
             case DCH_Y:
             case DCH_I:
             case DCH_RM:
             case DCH_rm:
             case DCH_W:
             case DCH_J:
                 flags |= DCH_DATED;
                 break;
         }
     }
  
     return flags;
 }

References DCH_A_D, DCH_a_d, DCH_A_M, DCH_a_m, DCH_AD, DCH_ad, DCH_AM, DCH_am, DCH_B_C, DCH_b_c, DCH_BC, DCH_bc, DCH_CC, DCH_D, DCH_DATED, DCH_DAY, DCH_Day, DCH_day, DCH_DD, DCH_DDD, DCH_DY, DCH_Dy, DCH_dy, DCH_FF1, DCH_FF2, DCH_FF3, DCH_FF4, DCH_FF5, DCH_FF6, DCH_FX, DCH_HH, DCH_HH12, DCH_HH24, DCH_I, DCH_ID, DCH_IDDD, DCH_IY, DCH_IYY, DCH_IYYY, DCH_J, DCH_MI, DCH_MM, DCH_MON, DCH_Mon, DCH_mon, DCH_MONTH, DCH_Month, DCH_month, DCH_MS, DCH_OF, DCH_P_M, DCH_p_m, DCH_PM, DCH_pm, DCH_Q, DCH_RM, DCH_rm, DCH_SS, DCH_SSSS, DCH_TIMED, DCH_TZ, DCH_tz, DCH_TZH, DCH_TZM, DCH_US, DCH_W, DCH_WW, DCH_Y, DCH_Y_YYY, DCH_YY, DCH_YYY, DCH_YYYY, DCH_ZONED, KeyWord::id, FormatNode::key, NODE_TYPE_ACTION, NODE_TYPE_END, and FormatNode::type.

Referenced by do_to_timestamp().

◆ DCH_from_char()

static void DCH_from_char	(	FormatNode *	node,
		const char *	in,
		TmFromChar *	out,
		Oid	collid,
		bool	std,
		Node *	escontext
	)

static

Definition at line 3276 of file formatting.c.

 {
     FormatNode *n;
     const char *s;
     int         len,
                 value;
     bool        fx_mode = std;
  
     /* number of extra skipped characters (more than given in format string) */
     int         extra_skip = 0;
  
     /* cache localized days and months */
     cache_locale_time();
  
     for (n = node, s = in; n->type != NODE_TYPE_END && *s != '\0'; n++)
     {
         /*
          * Ignore spaces at the beginning of the string and before fields when
          * not in FX (fixed width) mode.
          */
         if (!fx_mode && (n->type != NODE_TYPE_ACTION || n->key->id != DCH_FX) &&
             (n->type == NODE_TYPE_ACTION || n == node))
         {
             while (*s != '\0' && isspace((unsigned char) *s))
             {
                 s++;
                 extra_skip++;
             }
         }
  
         if (n->type == NODE_TYPE_SPACE || n->type == NODE_TYPE_SEPARATOR)
         {
             if (std)
             {
                 /*
                  * Standard mode requires strict matching between format
                  * string separators/spaces and input string.
                  */
                 Assert(n->character[0] && !n->character[1]);
  
                 if (*s == n->character[0])
                     s++;
                 else
                     ereturn(escontext,,
                             (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                              errmsg("unmatched format separator \"%c\"",
                                     n->character[0])));
             }
             else if (!fx_mode)
             {
                 /*
                  * In non FX (fixed format) mode one format string space or
                  * separator match to one space or separator in input string.
                  * Or match nothing if there is no space or separator in the
                  * current position of input string.
                  */
                 extra_skip--;
                 if (isspace((unsigned char) *s) || is_separator_char(s))
                 {
                     s++;
                     extra_skip++;
                 }
             }
             else
             {
                 /*
                  * In FX mode, on format string space or separator we consume
                  * exactly one character from input string.  Notice we don't
                  * insist that the consumed character match the format's
                  * character.
                  */
                 s += pg_mblen(s);
             }
             continue;
         }
         else if (n->type != NODE_TYPE_ACTION)
         {
             /*
              * Text character, so consume one character from input string.
              * Notice we don't insist that the consumed character match the
              * format's character.
              */
             if (!fx_mode)
             {
                 /*
                  * In non FX mode we might have skipped some extra characters
                  * (more than specified in format string) before.  In this
                  * case we don't skip input string character, because it might
                  * be part of field.
                  */
                 if (extra_skip > 0)
                     extra_skip--;
                 else
                     s += pg_mblen(s);
             }
             else
             {
                 int         chlen = pg_mblen(s);
  
                 /*
                  * Standard mode requires strict match of format characters.
                  */
                 if (std && n->type == NODE_TYPE_CHAR &&
                     strncmp(s, n->character, chlen) != 0)
                     ereturn(escontext,,
                             (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                              errmsg("unmatched format character \"%s\"",
                                     n->character)));
  
                 s += chlen;
             }
             continue;
         }
  
         if (!from_char_set_mode(out, n->key->date_mode, escontext))
             return;
  
         switch (n->key->id)
         {
             case DCH_FX:
                 fx_mode = true;
                 break;
             case DCH_A_M:
             case DCH_P_M:
             case DCH_a_m:
             case DCH_p_m:
                 if (!from_char_seq_search(&value, &s, ampm_strings_long,
                                           NULL, InvalidOid,
                                           n, escontext))
                     return;
                 if (!from_char_set_int(&out->pm, value % 2, n, escontext))
                     return;
                 out->clock = CLOCK_12_HOUR;
                 break;
             case DCH_AM:
             case DCH_PM:
             case DCH_am:
             case DCH_pm:
                 if (!from_char_seq_search(&value, &s, ampm_strings,
                                           NULL, InvalidOid,
                                           n, escontext))
                     return;
                 if (!from_char_set_int(&out->pm, value % 2, n, escontext))
                     return;
                 out->clock = CLOCK_12_HOUR;
                 break;
             case DCH_HH:
             case DCH_HH12:
                 if (from_char_parse_int_len(&out->hh, &s, 2, n, escontext) < 0)
                     return;
                 out->clock = CLOCK_12_HOUR;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_HH24:
                 if (from_char_parse_int_len(&out->hh, &s, 2, n, escontext) < 0)
                     return;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_MI:
                 if (from_char_parse_int(&out->mi, &s, n, escontext) < 0)
                     return;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_SS:
                 if (from_char_parse_int(&out->ss, &s, n, escontext) < 0)
                     return;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_MS:        /* millisecond */
                 len = from_char_parse_int_len(&out->ms, &s, 3, n, escontext);
                 if (len < 0)
                     return;
  
                 /*
                  * 25 is 0.25 and 250 is 0.25 too; 025 is 0.025 and not 0.25
                  */
                 out->ms *= len == 1 ? 100 :
                     len == 2 ? 10 : 1;
  
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_FF1:
             case DCH_FF2:
             case DCH_FF3:
             case DCH_FF4:
             case DCH_FF5:
             case DCH_FF6:
                 out->ff = n->key->id - DCH_FF1 + 1;
                 /* fall through */
             case DCH_US:        /* microsecond */
                 len = from_char_parse_int_len(&out->us, &s,
                                               n->key->id == DCH_US ? 6 :
                                               out->ff, n, escontext);
                 if (len < 0)
                     return;
  
                 out->us *= len == 1 ? 100000 :
                     len == 2 ? 10000 :
                     len == 3 ? 1000 :
                     len == 4 ? 100 :
                     len == 5 ? 10 : 1;
  
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_SSSS:
                 if (from_char_parse_int(&out->ssss, &s, n, escontext) < 0)
                     return;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_tz:
             case DCH_TZ:
             case DCH_OF:
                 ereturn(escontext,,
                         (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
                          errmsg("formatting field \"%s\" is only supported in to_char",
                                 n->key->name)));
                 break;
             case DCH_TZH:
  
                 /*
                  * Value of TZH might be negative.  And the issue is that we
                  * might swallow minus sign as the separator.  So, if we have
                  * skipped more characters than specified in the format
                  * string, then we consider prepending last skipped minus to
                  * TZH.
                  */
                 if (*s == '+' || *s == '-' || *s == ' ')
                 {
                     out->tzsign = *s == '-' ? -1 : +1;
                     s++;
                 }
                 else
                 {
                     if (extra_skip > 0 && *(s - 1) == '-')
                         out->tzsign = -1;
                     else
                         out->tzsign = +1;
                 }
  
                 if (from_char_parse_int_len(&out->tzh, &s, 2, n, escontext) < 0)
                     return;
                 break;
             case DCH_TZM:
                 /* assign positive timezone sign if TZH was not seen before */
                 if (!out->tzsign)
                     out->tzsign = +1;
                 if (from_char_parse_int_len(&out->tzm, &s, 2, n, escontext) < 0)
                     return;
                 break;
             case DCH_A_D:
             case DCH_B_C:
             case DCH_a_d:
             case DCH_b_c:
                 if (!from_char_seq_search(&value, &s, adbc_strings_long,
                                           NULL, InvalidOid,
                                           n, escontext))
                     return;
                 if (!from_char_set_int(&out->bc, value % 2, n, escontext))
                     return;
                 break;
             case DCH_AD:
             case DCH_BC:
             case DCH_ad:
             case DCH_bc:
                 if (!from_char_seq_search(&value, &s, adbc_strings,
                                           NULL, InvalidOid,
                                           n, escontext))
                     return;
                 if (!from_char_set_int(&out->bc, value % 2, n, escontext))
                     return;
                 break;
             case DCH_MONTH:
             case DCH_Month:
             case DCH_month:
                 if (!from_char_seq_search(&value, &s, months_full,
                                           S_TM(n->suffix) ? localized_full_months : NULL,
                                           collid,
                                           n, escontext))
                     return;
                 if (!from_char_set_int(&out->mm, value + 1, n, escontext))
                     return;
                 break;
             case DCH_MON:
             case DCH_Mon:
             case DCH_mon:
                 if (!from_char_seq_search(&value, &s, months,
                                           S_TM(n->suffix) ? localized_abbrev_months : NULL,
                                           collid,
                                           n, escontext))
                     return;
                 if (!from_char_set_int(&out->mm, value + 1, n, escontext))
                     return;
                 break;
             case DCH_MM:
                 if (from_char_parse_int(&out->mm, &s, n, escontext) < 0)
                     return;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_DAY:
             case DCH_Day:
             case DCH_day:
                 if (!from_char_seq_search(&value, &s, days,
                                           S_TM(n->suffix) ? localized_full_days : NULL,
                                           collid,
                                           n, escontext))
                     return;
                 if (!from_char_set_int(&out->d, value, n, escontext))
                     return;
                 out->d++;
                 break;
             case DCH_DY:
             case DCH_Dy:
             case DCH_dy:
                 if (!from_char_seq_search(&value, &s, days_short,
                                           S_TM(n->suffix) ? localized_abbrev_days : NULL,
                                           collid,
                                           n, escontext))
                     return;
                 if (!from_char_set_int(&out->d, value, n, escontext))
                     return;
                 out->d++;
                 break;
             case DCH_DDD:
                 if (from_char_parse_int(&out->ddd, &s, n, escontext) < 0)
                     return;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_IDDD:
                 if (from_char_parse_int_len(&out->ddd, &s, 3, n, escontext) < 0)
                     return;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_DD:
                 if (from_char_parse_int(&out->dd, &s, n, escontext) < 0)
                     return;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_D:
                 if (from_char_parse_int(&out->d, &s, n, escontext) < 0)
                     return;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_ID:
                 if (from_char_parse_int_len(&out->d, &s, 1, n, escontext) < 0)
                     return;
                 /* Shift numbering to match Gregorian where Sunday = 1 */
                 if (++out->d > 7)
                     out->d = 1;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_WW:
             case DCH_IW:
                 if (from_char_parse_int(&out->ww, &s, n, escontext) < 0)
                     return;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_Q:
  
                 /*
                  * We ignore 'Q' when converting to date because it is unclear
                  * which date in the quarter to use, and some people specify
                  * both quarter and month, so if it was honored it might
                  * conflict with the supplied month. That is also why we don't
                  * throw an error.
                  *
                  * We still parse the source string for an integer, but it
                  * isn't stored anywhere in 'out'.
                  */
                 if (from_char_parse_int((int *) NULL, &s, n, escontext) < 0)
                     return;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_CC:
                 if (from_char_parse_int(&out->cc, &s, n, escontext) < 0)
                     return;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_Y_YYY:
                 {
                     int         matched,
                                 years,
                                 millennia,
                                 nch;
  
                     matched = sscanf(s, "%d,%03d%n", &millennia, &years, &nch);
                     if (matched < 2)
                         ereturn(escontext,,
                                 (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                                  errmsg("invalid input string for \"Y,YYY\"")));
                     years += (millennia * 1000);
                     if (!from_char_set_int(&out->year, years, n, escontext))
                         return;
                     out->yysz = 4;
                     s += nch;
                     SKIP_THth(s, n->suffix);
                 }
                 break;
             case DCH_YYYY:
             case DCH_IYYY:
                 if (from_char_parse_int(&out->year, &s, n, escontext) < 0)
                     return;
                 out->yysz = 4;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_YYY:
             case DCH_IYY:
                 len = from_char_parse_int(&out->year, &s, n, escontext);
                 if (len < 0)
                     return;
                 if (len < 4)
                     out->year = adjust_partial_year_to_2020(out->year);
                 out->yysz = 3;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_YY:
             case DCH_IY:
                 len = from_char_parse_int(&out->year, &s, n, escontext);
                 if (len < 0)
                     return;
                 if (len < 4)
                     out->year = adjust_partial_year_to_2020(out->year);
                 out->yysz = 2;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_Y:
             case DCH_I:
                 len = from_char_parse_int(&out->year, &s, n, escontext);
                 if (len < 0)
                     return;
                 if (len < 4)
                     out->year = adjust_partial_year_to_2020(out->year);
                 out->yysz = 1;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_RM:
             case DCH_rm:
                 if (!from_char_seq_search(&value, &s, rm_months_lower,
                                           NULL, InvalidOid,
                                           n, escontext))
                     return;
                 if (!from_char_set_int(&out->mm, MONTHS_PER_YEAR - value, n,
                                        escontext))
                     return;
                 break;
             case DCH_W:
                 if (from_char_parse_int(&out->w, &s, n, escontext) < 0)
                     return;
                 SKIP_THth(s, n->suffix);
                 break;
             case DCH_J:
                 if (from_char_parse_int(&out->j, &s, n, escontext) < 0)
                     return;
                 SKIP_THth(s, n->suffix);
                 break;
         }
  
         /* Ignore all spaces after fields */
         if (!fx_mode)
         {
             extra_skip = 0;
             while (*s != '\0' && isspace((unsigned char) *s))
             {
                 s++;
                 extra_skip++;
             }
         }
     }
  
     /*
      * Standard parsing mode doesn't allow unmatched format patterns or
      * trailing characters in the input string.
      */
     if (std)
     {
         if (n->type != NODE_TYPE_END)
             ereturn(escontext,,
                     (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                      errmsg("input string is too short for datetime format")));
  
         while (*s != '\0' && isspace((unsigned char) *s))
             s++;
  
         if (*s != '\0')
             ereturn(escontext,,
                     (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                      errmsg("trailing characters remain in input string after datetime format")));
     }
 }

References adbc_strings, adbc_strings_long, adjust_partial_year_to_2020(), ampm_strings, ampm_strings_long, Assert(), TmFromChar::bc, cache_locale_time(), TmFromChar::cc, FormatNode::character, TmFromChar::clock, CLOCK_12_HOUR, collid, TmFromChar::d, KeyWord::date_mode, days, days_short, DCH_A_D, DCH_a_d, DCH_A_M, DCH_a_m, DCH_AD, DCH_ad, DCH_AM, DCH_am, DCH_B_C, DCH_b_c, DCH_BC, DCH_bc, DCH_CC, DCH_D, DCH_DAY, DCH_Day, DCH_day, DCH_DD, DCH_DDD, DCH_DY, DCH_Dy, DCH_dy, DCH_FF1, DCH_FF2, DCH_FF3, DCH_FF4, DCH_FF5, DCH_FF6, DCH_FX, DCH_HH, DCH_HH12, DCH_HH24, DCH_I, DCH_ID, DCH_IDDD, DCH_IW, DCH_IY, DCH_IYY, DCH_IYYY, DCH_J, DCH_MI, DCH_MM, DCH_MON, DCH_Mon, DCH_mon, DCH_MONTH, DCH_Month, DCH_month, DCH_MS, DCH_OF, DCH_P_M, DCH_p_m, DCH_PM, DCH_pm, DCH_Q, DCH_RM, DCH_rm, DCH_SS, DCH_SSSS, DCH_TZ, DCH_tz, DCH_TZH, DCH_TZM, DCH_US, DCH_W, DCH_WW, DCH_Y, DCH_Y_YYY, DCH_YY, DCH_YYY, DCH_YYYY, TmFromChar::dd, TmFromChar::ddd, ereturn, errcode(), errmsg(), TmFromChar::ff, from_char_parse_int(), from_char_parse_int_len(), from_char_seq_search(), from_char_set_int(), from_char_set_mode(), TmFromChar::hh, KeyWord::id, InvalidOid, is_separator_char(), TmFromChar::j, FormatNode::key, len, localized_abbrev_days, localized_abbrev_months, localized_full_days, localized_full_months, TmFromChar::mi, TmFromChar::mm, months, months_full, MONTHS_PER_YEAR, TmFromChar::ms, KeyWord::name, NODE_TYPE_ACTION, NODE_TYPE_CHAR, NODE_TYPE_END, NODE_TYPE_SEPARATOR, NODE_TYPE_SPACE, pg_mblen(), TmFromChar::pm, rm_months_lower, S_TM, SKIP_THth, TmFromChar::ss, TmFromChar::ssss, FormatNode::suffix, FormatNode::type, TmFromChar::tzh, TmFromChar::tzm, TmFromChar::tzsign, TmFromChar::us, value, TmFromChar::w, TmFromChar::ww, TmFromChar::year, and TmFromChar::yysz.

Referenced by do_to_timestamp().

◆ DCH_prevent_counter_overflow()

static void DCH_prevent_counter_overflow ( void )

inlinestatic

Definition at line 3774 of file formatting.c.

 {
     if (DCHCounter >= (INT_MAX - 1))
     {
         for (int i = 0; i < n_DCHCache; i++)
             DCHCache[i]->age >>= 1;
         DCHCounter >>= 1;
     }
 }

References DCHCache, DCHCounter, i, and n_DCHCache.

Referenced by DCH_cache_getnew(), and DCH_cache_search().

◆ DCH_to_char()

static void DCH_to_char	(	FormatNode *	node,
		bool	is_interval,
		TmToChar *	in,
		char *	out,
		Oid	collid
	)

static

Definition at line 2629 of file formatting.c.

 {
     FormatNode *n;
     char       *s;
     struct fmt_tm *tm = &in->tm;
     int         i;
  
     /* cache localized days and months */
     cache_locale_time();
  
     s = out;
     for (n = node; n->type != NODE_TYPE_END; n++)
     {
         if (n->type != NODE_TYPE_ACTION)
         {
             strcpy(s, n->character);
             s += strlen(s);
             continue;
         }
  
         switch (n->key->id)
         {
             case DCH_A_M:
             case DCH_P_M:
                 strcpy(s, (tm->tm_hour % HOURS_PER_DAY >= HOURS_PER_DAY / 2)
                        ? P_M_STR : A_M_STR);
                 s += strlen(s);
                 break;
             case DCH_AM:
             case DCH_PM:
                 strcpy(s, (tm->tm_hour % HOURS_PER_DAY >= HOURS_PER_DAY / 2)
                        ? PM_STR : AM_STR);
                 s += strlen(s);
                 break;
             case DCH_a_m:
             case DCH_p_m:
                 strcpy(s, (tm->tm_hour % HOURS_PER_DAY >= HOURS_PER_DAY / 2)
                        ? p_m_STR : a_m_STR);
                 s += strlen(s);
                 break;
             case DCH_am:
             case DCH_pm:
                 strcpy(s, (tm->tm_hour % HOURS_PER_DAY >= HOURS_PER_DAY / 2)
                        ? pm_STR : am_STR);
                 s += strlen(s);
                 break;
             case DCH_HH:
             case DCH_HH12:
  
                 /*
                  * display time as shown on a 12-hour clock, even for
                  * intervals
                  */
                 sprintf(s, "%0*lld", S_FM(n->suffix) ? 0 : (tm->tm_hour >= 0) ? 2 : 3,
                         tm->tm_hour % (HOURS_PER_DAY / 2) == 0 ?
                         (long long) (HOURS_PER_DAY / 2) :
                         (long long) (tm->tm_hour % (HOURS_PER_DAY / 2)));
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_HH24:
                 sprintf(s, "%0*lld", S_FM(n->suffix) ? 0 : (tm->tm_hour >= 0) ? 2 : 3,
                         (long long) tm->tm_hour);
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_MI:
                 sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : (tm->tm_min >= 0) ? 2 : 3,
                         tm->tm_min);
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_SS:
                 sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : (tm->tm_sec >= 0) ? 2 : 3,
                         tm->tm_sec);
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
  
 #define DCH_to_char_fsec(frac_fmt, frac_val) \
                 sprintf(s, frac_fmt, (int) (frac_val)); \
                 if (S_THth(n->suffix)) \
                     str_numth(s, s, S_TH_TYPE(n->suffix)); \
                 s += strlen(s)
  
             case DCH_FF1:       /* tenth of second */
                 DCH_to_char_fsec("%01d", in->fsec / 100000);
                 break;
             case DCH_FF2:       /* hundredth of second */
                 DCH_to_char_fsec("%02d", in->fsec / 10000);
                 break;
             case DCH_FF3:
             case DCH_MS:        /* millisecond */
                 DCH_to_char_fsec("%03d", in->fsec / 1000);
                 break;
             case DCH_FF4:       /* tenth of a millisecond */
                 DCH_to_char_fsec("%04d", in->fsec / 100);
                 break;
             case DCH_FF5:       /* hundredth of a millisecond */
                 DCH_to_char_fsec("%05d", in->fsec / 10);
                 break;
             case DCH_FF6:
             case DCH_US:        /* microsecond */
                 DCH_to_char_fsec("%06d", in->fsec);
                 break;
 #undef DCH_to_char_fsec
             case DCH_SSSS:
                 sprintf(s, "%lld",
                         (long long) (tm->tm_hour * SECS_PER_HOUR +
                                      tm->tm_min * SECS_PER_MINUTE +
                                      tm->tm_sec));
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_tz:
                 INVALID_FOR_INTERVAL;
                 if (tmtcTzn(in))
                 {
                     /* We assume here that timezone names aren't localized */
                     char       *p = asc_tolower_z(tmtcTzn(in));
  
                     strcpy(s, p);
                     pfree(p);
                     s += strlen(s);
                 }
                 break;
             case DCH_TZ:
                 INVALID_FOR_INTERVAL;
                 if (tmtcTzn(in))
                 {
                     strcpy(s, tmtcTzn(in));
                     s += strlen(s);
                 }
                 break;
             case DCH_TZH:
                 INVALID_FOR_INTERVAL;
                 sprintf(s, "%c%02d",
                         (tm->tm_gmtoff >= 0) ? '+' : '-',
                         abs((int) tm->tm_gmtoff) / SECS_PER_HOUR);
                 s += strlen(s);
                 break;
             case DCH_TZM:
                 INVALID_FOR_INTERVAL;
                 sprintf(s, "%02d",
                         (abs((int) tm->tm_gmtoff) % SECS_PER_HOUR) / SECS_PER_MINUTE);
                 s += strlen(s);
                 break;
             case DCH_OF:
                 INVALID_FOR_INTERVAL;
                 sprintf(s, "%c%0*d",
                         (tm->tm_gmtoff >= 0) ? '+' : '-',
                         S_FM(n->suffix) ? 0 : 2,
                         abs((int) tm->tm_gmtoff) / SECS_PER_HOUR);
                 s += strlen(s);
                 if (abs((int) tm->tm_gmtoff) % SECS_PER_HOUR != 0)
                 {
                     sprintf(s, ":%02d",
                             (abs((int) tm->tm_gmtoff) % SECS_PER_HOUR) / SECS_PER_MINUTE);
                     s += strlen(s);
                 }
                 break;
             case DCH_A_D:
             case DCH_B_C:
                 INVALID_FOR_INTERVAL;
                 strcpy(s, (tm->tm_year <= 0 ? B_C_STR : A_D_STR));
                 s += strlen(s);
                 break;
             case DCH_AD:
             case DCH_BC:
                 INVALID_FOR_INTERVAL;
                 strcpy(s, (tm->tm_year <= 0 ? BC_STR : AD_STR));
                 s += strlen(s);
                 break;
             case DCH_a_d:
             case DCH_b_c:
                 INVALID_FOR_INTERVAL;
                 strcpy(s, (tm->tm_year <= 0 ? b_c_STR : a_d_STR));
                 s += strlen(s);
                 break;
             case DCH_ad:
             case DCH_bc:
                 INVALID_FOR_INTERVAL;
                 strcpy(s, (tm->tm_year <= 0 ? bc_STR : ad_STR));
                 s += strlen(s);
                 break;
             case DCH_MONTH:
                 INVALID_FOR_INTERVAL;
                 if (!tm->tm_mon)
                     break;
                 if (S_TM(n->suffix))
                 {
                     char       *str = str_toupper_z(localized_full_months[tm->tm_mon - 1], collid);
  
                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                         strcpy(s, str);
                     else
                         ereport(ERROR,
                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                  errmsg("localized string format value too long")));
                 }
                 else
                     sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -9,
                             asc_toupper_z(months_full[tm->tm_mon - 1]));
                 s += strlen(s);
                 break;
             case DCH_Month:
                 INVALID_FOR_INTERVAL;
                 if (!tm->tm_mon)
                     break;
                 if (S_TM(n->suffix))
                 {
                     char       *str = str_initcap_z(localized_full_months[tm->tm_mon - 1], collid);
  
                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                         strcpy(s, str);
                     else
                         ereport(ERROR,
                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                  errmsg("localized string format value too long")));
                 }
                 else
                     sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -9,
                             months_full[tm->tm_mon - 1]);
                 s += strlen(s);
                 break;
             case DCH_month:
                 INVALID_FOR_INTERVAL;
                 if (!tm->tm_mon)
                     break;
                 if (S_TM(n->suffix))
                 {
                     char       *str = str_tolower_z(localized_full_months[tm->tm_mon - 1], collid);
  
                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                         strcpy(s, str);
                     else
                         ereport(ERROR,
                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                  errmsg("localized string format value too long")));
                 }
                 else
                     sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -9,
                             asc_tolower_z(months_full[tm->tm_mon - 1]));
                 s += strlen(s);
                 break;
             case DCH_MON:
                 INVALID_FOR_INTERVAL;
                 if (!tm->tm_mon)
                     break;
                 if (S_TM(n->suffix))
                 {
                     char       *str = str_toupper_z(localized_abbrev_months[tm->tm_mon - 1], collid);
  
                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                         strcpy(s, str);
                     else
                         ereport(ERROR,
                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                  errmsg("localized string format value too long")));
                 }
                 else
                     strcpy(s, asc_toupper_z(months[tm->tm_mon - 1]));
                 s += strlen(s);
                 break;
             case DCH_Mon:
                 INVALID_FOR_INTERVAL;
                 if (!tm->tm_mon)
                     break;
                 if (S_TM(n->suffix))
                 {
                     char       *str = str_initcap_z(localized_abbrev_months[tm->tm_mon - 1], collid);
  
                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                         strcpy(s, str);
                     else
                         ereport(ERROR,
                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                  errmsg("localized string format value too long")));
                 }
                 else
                     strcpy(s, months[tm->tm_mon - 1]);
                 s += strlen(s);
                 break;
             case DCH_mon:
                 INVALID_FOR_INTERVAL;
                 if (!tm->tm_mon)
                     break;
                 if (S_TM(n->suffix))
                 {
                     char       *str = str_tolower_z(localized_abbrev_months[tm->tm_mon - 1], collid);
  
                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                         strcpy(s, str);
                     else
                         ereport(ERROR,
                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                  errmsg("localized string format value too long")));
                 }
                 else
                     strcpy(s, asc_tolower_z(months[tm->tm_mon - 1]));
                 s += strlen(s);
                 break;
             case DCH_MM:
                 sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : (tm->tm_mon >= 0) ? 2 : 3,
                         tm->tm_mon);
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_DAY:
                 INVALID_FOR_INTERVAL;
                 if (S_TM(n->suffix))
                 {
                     char       *str = str_toupper_z(localized_full_days[tm->tm_wday], collid);
  
                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                         strcpy(s, str);
                     else
                         ereport(ERROR,
                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                  errmsg("localized string format value too long")));
                 }
                 else
                     sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -9,
                             asc_toupper_z(days[tm->tm_wday]));
                 s += strlen(s);
                 break;
             case DCH_Day:
                 INVALID_FOR_INTERVAL;
                 if (S_TM(n->suffix))
                 {
                     char       *str = str_initcap_z(localized_full_days[tm->tm_wday], collid);
  
                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                         strcpy(s, str);
                     else
                         ereport(ERROR,
                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                  errmsg("localized string format value too long")));
                 }
                 else
                     sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -9,
                             days[tm->tm_wday]);
                 s += strlen(s);
                 break;
             case DCH_day:
                 INVALID_FOR_INTERVAL;
                 if (S_TM(n->suffix))
                 {
                     char       *str = str_tolower_z(localized_full_days[tm->tm_wday], collid);
  
                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                         strcpy(s, str);
                     else
                         ereport(ERROR,
                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                  errmsg("localized string format value too long")));
                 }
                 else
                     sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -9,
                             asc_tolower_z(days[tm->tm_wday]));
                 s += strlen(s);
                 break;
             case DCH_DY:
                 INVALID_FOR_INTERVAL;
                 if (S_TM(n->suffix))
                 {
                     char       *str = str_toupper_z(localized_abbrev_days[tm->tm_wday], collid);
  
                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                         strcpy(s, str);
                     else
                         ereport(ERROR,
                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                  errmsg("localized string format value too long")));
                 }
                 else
                     strcpy(s, asc_toupper_z(days_short[tm->tm_wday]));
                 s += strlen(s);
                 break;
             case DCH_Dy:
                 INVALID_FOR_INTERVAL;
                 if (S_TM(n->suffix))
                 {
                     char       *str = str_initcap_z(localized_abbrev_days[tm->tm_wday], collid);
  
                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                         strcpy(s, str);
                     else
                         ereport(ERROR,
                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                  errmsg("localized string format value too long")));
                 }
                 else
                     strcpy(s, days_short[tm->tm_wday]);
                 s += strlen(s);
                 break;
             case DCH_dy:
                 INVALID_FOR_INTERVAL;
                 if (S_TM(n->suffix))
                 {
                     char       *str = str_tolower_z(localized_abbrev_days[tm->tm_wday], collid);
  
                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
                         strcpy(s, str);
                     else
                         ereport(ERROR,
                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                                  errmsg("localized string format value too long")));
                 }
                 else
                     strcpy(s, asc_tolower_z(days_short[tm->tm_wday]));
                 s += strlen(s);
                 break;
             case DCH_DDD:
             case DCH_IDDD:
                 sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : 3,
                         (n->key->id == DCH_DDD) ?
                         tm->tm_yday :
                         date2isoyearday(tm->tm_year, tm->tm_mon, tm->tm_mday));
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_DD:
                 sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : 2, tm->tm_mday);
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_D:
                 INVALID_FOR_INTERVAL;
                 sprintf(s, "%d", tm->tm_wday + 1);
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_ID:
                 INVALID_FOR_INTERVAL;
                 sprintf(s, "%d", (tm->tm_wday == 0) ? 7 : tm->tm_wday);
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_WW:
                 sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : 2,
                         (tm->tm_yday - 1) / 7 + 1);
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_IW:
                 sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : 2,
                         date2isoweek(tm->tm_year, tm->tm_mon, tm->tm_mday));
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_Q:
                 if (!tm->tm_mon)
                     break;
                 sprintf(s, "%d", (tm->tm_mon - 1) / 3 + 1);
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_CC:
                 if (is_interval)    /* straight calculation */
                     i = tm->tm_year / 100;
                 else
                 {
                     if (tm->tm_year > 0)
                         /* Century 20 == 1901 - 2000 */
                         i = (tm->tm_year - 1) / 100 + 1;
                     else
                         /* Century 6BC == 600BC - 501BC */
                         i = tm->tm_year / 100 - 1;
                 }
                 if (i <= 99 && i >= -99)
                     sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : (i >= 0) ? 2 : 3, i);
                 else
                     sprintf(s, "%d", i);
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_Y_YYY:
                 i = ADJUST_YEAR(tm->tm_year, is_interval) / 1000;
                 sprintf(s, "%d,%03d", i,
                         ADJUST_YEAR(tm->tm_year, is_interval) - (i * 1000));
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_YYYY:
             case DCH_IYYY:
                 sprintf(s, "%0*d",
                         S_FM(n->suffix) ? 0 :
                         (ADJUST_YEAR(tm->tm_year, is_interval) >= 0) ? 4 : 5,
                         (n->key->id == DCH_YYYY ?
                          ADJUST_YEAR(tm->tm_year, is_interval) :
                          ADJUST_YEAR(date2isoyear(tm->tm_year,
                                                   tm->tm_mon,
                                                   tm->tm_mday),
                                      is_interval)));
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_YYY:
             case DCH_IYY:
                 sprintf(s, "%0*d",
                         S_FM(n->suffix) ? 0 :
                         (ADJUST_YEAR(tm->tm_year, is_interval) >= 0) ? 3 : 4,
                         (n->key->id == DCH_YYY ?
                          ADJUST_YEAR(tm->tm_year, is_interval) :
                          ADJUST_YEAR(date2isoyear(tm->tm_year,
                                                   tm->tm_mon,
                                                   tm->tm_mday),
                                      is_interval)) % 1000);
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_YY:
             case DCH_IY:
                 sprintf(s, "%0*d",
                         S_FM(n->suffix) ? 0 :
                         (ADJUST_YEAR(tm->tm_year, is_interval) >= 0) ? 2 : 3,
                         (n->key->id == DCH_YY ?
                          ADJUST_YEAR(tm->tm_year, is_interval) :
                          ADJUST_YEAR(date2isoyear(tm->tm_year,
                                                   tm->tm_mon,
                                                   tm->tm_mday),
                                      is_interval)) % 100);
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_Y:
             case DCH_I:
                 sprintf(s, "%1d",
                         (n->key->id == DCH_Y ?
                          ADJUST_YEAR(tm->tm_year, is_interval) :
                          ADJUST_YEAR(date2isoyear(tm->tm_year,
                                                   tm->tm_mon,
                                                   tm->tm_mday),
                                      is_interval)) % 10);
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_RM:
                 /* FALLTHROUGH */
             case DCH_rm:
  
                 /*
                  * For intervals, values like '12 month' will be reduced to 0
                  * month and some years.  These should be processed.
                  */
                 if (!tm->tm_mon && !tm->tm_year)
                     break;
                 else
                 {
                     int         mon = 0;
                     const char *const *months;
  
                     if (n->key->id == DCH_RM)
                         months = rm_months_upper;
                     else
                         months = rm_months_lower;
  
                     /*
                      * Compute the position in the roman-numeral array.  Note
                      * that the contents of the array are reversed, December
                      * being first and January last.
                      */
                     if (tm->tm_mon == 0)
                     {
                         /*
                          * This case is special, and tracks the case of full
                          * interval years.
                          */
                         mon = tm->tm_year >= 0 ? 0 : MONTHS_PER_YEAR - 1;
                     }
                     else if (tm->tm_mon < 0)
                     {
                         /*
                          * Negative case.  In this case, the calculation is
                          * reversed, where -1 means December, -2 November,
                          * etc.
                          */
                         mon = -1 * (tm->tm_mon + 1);
                     }
                     else
                     {
                         /*
                          * Common case, with a strictly positive value.  The
                          * position in the array matches with the value of
                          * tm_mon.
                          */
                         mon = MONTHS_PER_YEAR - tm->tm_mon;
                     }
  
                     sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -4,
                             months[mon]);
                     s += strlen(s);
                 }
                 break;
             case DCH_W:
                 sprintf(s, "%d", (tm->tm_mday - 1) / 7 + 1);
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
             case DCH_J:
                 sprintf(s, "%d", date2j(tm->tm_year, tm->tm_mon, tm->tm_mday));
                 if (S_THth(n->suffix))
                     str_numth(s, s, S_TH_TYPE(n->suffix));
                 s += strlen(s);
                 break;
         }
     }
  
     *s = '\0';
 }

References A_D_STR, a_d_STR, A_M_STR, a_m_STR, AD_STR, ad_STR, ADJUST_YEAR, AM_STR, am_STR, asc_tolower_z(), asc_toupper_z(), B_C_STR, b_c_STR, BC_STR, bc_STR, cache_locale_time(), FormatNode::character, collid, date2isoweek(), date2isoyear(), date2isoyearday(), date2j(), days, days_short, DCH_A_D, DCH_a_d, DCH_A_M, DCH_a_m, DCH_AD, DCH_ad, DCH_AM, DCH_am, DCH_B_C, DCH_b_c, DCH_BC, DCH_bc, DCH_CC, DCH_D, DCH_DAY, DCH_Day, DCH_day, DCH_DD, DCH_DDD, DCH_DY, DCH_Dy, DCH_dy, DCH_FF1, DCH_FF2, DCH_FF3, DCH_FF4, DCH_FF5, DCH_FF6, DCH_HH, DCH_HH12, DCH_HH24, DCH_I, DCH_ID, DCH_IDDD, DCH_IW, DCH_IY, DCH_IYY, DCH_IYYY, DCH_J, DCH_MAX_ITEM_SIZ, DCH_MI, DCH_MM, DCH_MON, DCH_Mon, DCH_mon, DCH_MONTH, DCH_Month, DCH_month, DCH_MS, DCH_OF, DCH_P_M, DCH_p_m, DCH_PM, DCH_pm, DCH_Q, DCH_RM, DCH_rm, DCH_SS, DCH_SSSS, DCH_to_char_fsec, DCH_TZ, DCH_tz, DCH_TZH, DCH_TZM, DCH_US, DCH_W, DCH_WW, DCH_Y, DCH_Y_YYY, DCH_YY, DCH_YYY, DCH_YYYY, ereport, errcode(), errmsg(), ERROR, TmToChar::fsec, HOURS_PER_DAY, i, KeyWord::id, INVALID_FOR_INTERVAL, FormatNode::key, KeyWord::len, localized_abbrev_days, localized_abbrev_months, localized_full_days, localized_full_months, months, months_full, MONTHS_PER_YEAR, NODE_TYPE_ACTION, NODE_TYPE_END, P_M_STR, p_m_STR, pfree(), PM_STR, pm_STR, rm_months_lower, rm_months_upper, S_FM, S_TH_TYPE, S_THth, S_TM, SECS_PER_HOUR, SECS_PER_MINUTE, sprintf, generate_unaccent_rules::str, str_initcap_z(), str_numth(), str_tolower_z(), str_toupper_z(), FormatNode::suffix, TmToChar::tm, tm, pg_tm::tm_gmtoff, pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, TM_SUFFIX_LEN, pg_tm::tm_wday, pg_tm::tm_yday, pg_tm::tm_year, tmtcTzn, and FormatNode::type.

Referenced by datetime_to_char_body().

◆ do_to_timestamp()

static bool do_to_timestamp	(	text *	date_txt,
		text *	fmt,
		Oid	collid,
		bool	std,
		struct pg_tm *	tm,
		fsec_t *	fsec,
		int *	fprec,
		uint32 *	flags,
		Node *	escontext
	)

static

Definition at line 4471 of file formatting.c.

 {
     FormatNode *format = NULL;
     TmFromChar  tmfc;
     int         fmt_len;
     char       *date_str;
     int         fmask;
     bool        incache = false;
  
     Assert(tm != NULL);
     Assert(fsec != NULL);
  
     date_str = text_to_cstring(date_txt);
  
     ZERO_tmfc(&tmfc);
     ZERO_tm(tm);
     *fsec = 0;
     if (fprec)
         *fprec = 0;
     if (flags)
         *flags = 0;
     fmask = 0;                  /* bit mask for ValidateDate() */
  
     fmt_len = VARSIZE_ANY_EXHDR(fmt);
  
     if (fmt_len)
     {
         char       *fmt_str;
  
         fmt_str = text_to_cstring(fmt);
  
         if (fmt_len > DCH_CACHE_SIZE)
         {
             /*
              * Allocate new memory if format picture is bigger than static
              * cache and do not use cache (call parser always)
              */
             format = (FormatNode *) palloc((fmt_len + 1) * sizeof(FormatNode));
  
             parse_format(format, fmt_str, DCH_keywords, DCH_suff, DCH_index,
                          DCH_FLAG | (std ? STD_FLAG : 0), NULL);
         }
         else
         {
             /*
              * Use cache buffers
              */
             DCHCacheEntry *ent = DCH_cache_fetch(fmt_str, std);
  
             incache = true;
             format = ent->format;
         }
  
 #ifdef DEBUG_TO_FROM_CHAR
         /* dump_node(format, fmt_len); */
         /* dump_index(DCH_keywords, DCH_index); */
 #endif
  
         DCH_from_char(format, date_str, &tmfc, collid, std, escontext);
         pfree(fmt_str);
         if (SOFT_ERROR_OCCURRED(escontext))
             goto fail;
  
         if (flags)
             *flags = DCH_datetime_type(format);
  
         if (!incache)
         {
             pfree(format);
             format = NULL;
         }
     }
  
     DEBUG_TMFC(&tmfc);
  
     /*
      * Convert to_date/to_timestamp input fields to standard 'tm'
      */
     if (tmfc.ssss)
     {
         int         x = tmfc.ssss;
  
         tm->tm_hour = x / SECS_PER_HOUR;
         x %= SECS_PER_HOUR;
         tm->tm_min = x / SECS_PER_MINUTE;
         x %= SECS_PER_MINUTE;
         tm->tm_sec = x;
     }
  
     if (tmfc.ss)
         tm->tm_sec = tmfc.ss;
     if (tmfc.mi)
         tm->tm_min = tmfc.mi;
     if (tmfc.hh)
         tm->tm_hour = tmfc.hh;
  
     if (tmfc.clock == CLOCK_12_HOUR)
     {
         if (tm->tm_hour < 1 || tm->tm_hour > HOURS_PER_DAY / 2)
         {
             errsave(escontext,
                     (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                      errmsg("hour \"%d\" is invalid for the 12-hour clock",
                             tm->tm_hour),
                      errhint("Use the 24-hour clock, or give an hour between 1 and 12.")));
             goto fail;
         }
  
         if (tmfc.pm && tm->tm_hour < HOURS_PER_DAY / 2)
             tm->tm_hour += HOURS_PER_DAY / 2;
         else if (!tmfc.pm && tm->tm_hour == HOURS_PER_DAY / 2)
             tm->tm_hour = 0;
     }
  
     if (tmfc.year)
     {
         /*
          * If CC and YY (or Y) are provided, use YY as 2 low-order digits for
          * the year in the given century.  Keep in mind that the 21st century
          * AD runs from 2001-2100, not 2000-2099; 6th century BC runs from
          * 600BC to 501BC.
          */
         if (tmfc.cc && tmfc.yysz <= 2)
         {
             if (tmfc.bc)
                 tmfc.cc = -tmfc.cc;
             tm->tm_year = tmfc.year % 100;
             if (tm->tm_year)
             {
                 if (tmfc.cc >= 0)
                     tm->tm_year += (tmfc.cc - 1) * 100;
                 else
                     tm->tm_year = (tmfc.cc + 1) * 100 - tm->tm_year + 1;
             }
             else
             {
                 /* find century year for dates ending in "00" */
                 tm->tm_year = tmfc.cc * 100 + ((tmfc.cc >= 0) ? 0 : 1);
             }
         }
         else
         {
             /* If a 4-digit year is provided, we use that and ignore CC. */
             tm->tm_year = tmfc.year;
             if (tmfc.bc)
                 tm->tm_year = -tm->tm_year;
             /* correct for our representation of BC years */
             if (tm->tm_year < 0)
                 tm->tm_year++;
         }
         fmask |= DTK_M(YEAR);
     }
     else if (tmfc.cc)
     {
         /* use first year of century */
         if (tmfc.bc)
             tmfc.cc = -tmfc.cc;
         if (tmfc.cc >= 0)
             /* +1 because 21st century started in 2001 */
             tm->tm_year = (tmfc.cc - 1) * 100 + 1;
         else
             /* +1 because year == 599 is 600 BC */
             tm->tm_year = tmfc.cc * 100 + 1;
         fmask |= DTK_M(YEAR);
     }
  
     if (tmfc.j)
     {
         j2date(tmfc.j, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
         fmask |= DTK_DATE_M;
     }
  
     if (tmfc.ww)
     {
         if (tmfc.mode == FROM_CHAR_DATE_ISOWEEK)
         {
             /*
              * If tmfc.d is not set, then the date is left at the beginning of
              * the ISO week (Monday).
              */
             if (tmfc.d)
                 isoweekdate2date(tmfc.ww, tmfc.d, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
             else
                 isoweek2date(tmfc.ww, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
             fmask |= DTK_DATE_M;
         }
         else
             tmfc.ddd = (tmfc.ww - 1) * 7 + 1;
     }
  
     if (tmfc.w)
         tmfc.dd = (tmfc.w - 1) * 7 + 1;
     if (tmfc.dd)
     {
         tm->tm_mday = tmfc.dd;
         fmask |= DTK_M(DAY);
     }
     if (tmfc.mm)
     {
         tm->tm_mon = tmfc.mm;
         fmask |= DTK_M(MONTH);
     }
  
     if (tmfc.ddd && (tm->tm_mon <= 1 || tm->tm_mday <= 1))
     {
         /*
          * The month and day field have not been set, so we use the
          * day-of-year field to populate them.  Depending on the date mode,
          * this field may be interpreted as a Gregorian day-of-year, or an ISO
          * week date day-of-year.
          */
  
         if (!tm->tm_year && !tmfc.bc)
         {
             errsave(escontext,
                     (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                      errmsg("cannot calculate day of year without year information")));
             goto fail;
         }
  
         if (tmfc.mode == FROM_CHAR_DATE_ISOWEEK)
         {
             int         j0;     /* zeroth day of the ISO year, in Julian */
  
             j0 = isoweek2j(tm->tm_year, 1) - 1;
  
             j2date(j0 + tmfc.ddd, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
             fmask |= DTK_DATE_M;
         }
         else
         {
             const int  *y;
             int         i;
  
             static const int ysum[2][13] = {
                 {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
             {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}};
  
             y = ysum[isleap(tm->tm_year)];
  
             for (i = 1; i <= MONTHS_PER_YEAR; i++)
             {
                 if (tmfc.ddd <= y[i])
                     break;
             }
             if (tm->tm_mon <= 1)
                 tm->tm_mon = i;
  
             if (tm->tm_mday <= 1)
                 tm->tm_mday = tmfc.ddd - y[i - 1];
  
             fmask |= DTK_M(MONTH) | DTK_M(DAY);
         }
     }
  
     if (tmfc.ms)
         *fsec += tmfc.ms * 1000;
     if (tmfc.us)
         *fsec += tmfc.us;
     if (fprec)
         *fprec = tmfc.ff;       /* fractional precision, if specified */
  
     /* Range-check date fields according to bit mask computed above */
     if (fmask != 0)
     {
         /* We already dealt with AD/BC, so pass isjulian = true */
         int         dterr = ValidateDate(fmask, true, false, false, tm);
  
         if (dterr != 0)
         {
             /*
              * Force the error to be DTERR_FIELD_OVERFLOW even if ValidateDate
              * said DTERR_MD_FIELD_OVERFLOW, because we don't want to print an
              * irrelevant hint about datestyle.
              */
             DateTimeParseError(DTERR_FIELD_OVERFLOW, NULL,
                                date_str, "timestamp", escontext);
             goto fail;
         }
     }
  
     /* Range-check time fields too */
     if (tm->tm_hour < 0 || tm->tm_hour >= HOURS_PER_DAY ||
         tm->tm_min < 0 || tm->tm_min >= MINS_PER_HOUR ||
         tm->tm_sec < 0 || tm->tm_sec >= SECS_PER_MINUTE ||
         *fsec < INT64CONST(0) || *fsec >= USECS_PER_SEC)
     {
         DateTimeParseError(DTERR_FIELD_OVERFLOW, NULL,
                            date_str, "timestamp", escontext);
         goto fail;
     }
  
     /* Save parsed time-zone into tm->tm_zone if it was specified */
     if (tmfc.tzsign)
     {
         char       *tz;
  
         if (tmfc.tzh < 0 || tmfc.tzh > MAX_TZDISP_HOUR ||
             tmfc.tzm < 0 || tmfc.tzm >= MINS_PER_HOUR)
         {
             DateTimeParseError(DTERR_TZDISP_OVERFLOW, NULL,
                                date_str, "timestamp", escontext);
             goto fail;
         }
  
         tz = psprintf("%c%02d:%02d",
                       tmfc.tzsign > 0 ? '+' : '-', tmfc.tzh, tmfc.tzm);
  
         tm->tm_zone = tz;
     }
  
     DEBUG_TM(tm);
  
     if (format && !incache)
         pfree(format);
     pfree(date_str);
  
     return true;
  
 fail:
     if (format && !incache)
         pfree(format);
     pfree(date_str);
  
     return false;
 }

References Assert(), TmFromChar::bc, TmFromChar::cc, TmFromChar::clock, CLOCK_12_HOUR, collid, TmFromChar::d, DateTimeParseError(), DAY, DCH_cache_fetch(), DCH_CACHE_SIZE, DCH_datetime_type(), DCH_FLAG, DCH_from_char(), DCH_index, DCH_keywords, DCH_suff, TmFromChar::dd, TmFromChar::ddd, DEBUG_TM, DEBUG_TMFC, DTERR_FIELD_OVERFLOW, DTERR_TZDISP_OVERFLOW, DTK_DATE_M, DTK_M, errcode(), errhint(), errmsg(), errsave, TmFromChar::ff, fmt, DCHCacheEntry::format, format, FROM_CHAR_DATE_ISOWEEK, TmFromChar::hh, HOURS_PER_DAY, i, isleap, isoweek2date(), isoweek2j(), isoweekdate2date(), TmFromChar::j, j2date(), MAX_TZDISP_HOUR, TmFromChar::mi, MINS_PER_HOUR, TmFromChar::mm, TmFromChar::mode, MONTH, MONTHS_PER_YEAR, TmFromChar::ms, palloc(), parse_format(), pfree(), TmFromChar::pm, psprintf(), SECS_PER_HOUR, SECS_PER_MINUTE, SOFT_ERROR_OCCURRED, TmFromChar::ss, TmFromChar::ssss, STD_FLAG, text_to_cstring(), tm, pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, pg_tm::tm_zone, TmFromChar::tzh, TmFromChar::tzm, TmFromChar::tzsign, TmFromChar::us, USECS_PER_SEC, ValidateDate(), VARSIZE_ANY_EXHDR, TmFromChar::w, TmFromChar::ww, x, y, TmFromChar::year, YEAR, TmFromChar::yysz, ZERO_tm, and ZERO_tmfc.

Referenced by parse_datetime(), to_date(), and to_timestamp().

◆ fill_str()

static char * fill_str	(	char *	str,
		int	c,
		int	max
	)

static

Definition at line 4807 of file formatting.c.

 {
     memset(str, c, max);
     *(str + max) = '\0';
     return str;
 }

References generate_unaccent_rules::str.

Referenced by float4_to_char(), float8_to_char(), int4_to_char(), int8_to_char(), int_to_roman(), and numeric_to_char().

◆ float4_to_char()

Datum float4_to_char ( PG_FUNCTION_ARGS )

Definition at line 6492 of file formatting.c.

 {
     float4      value = PG_GETARG_FLOAT4(0);
     text       *fmt = PG_GETARG_TEXT_PP(1);
     NUMDesc     Num;
     FormatNode *format;
     text       *result;
     bool        shouldFree;
     int         out_pre_spaces = 0,
                 sign = 0;
     char       *numstr,
                *p;
  
     NUM_TOCHAR_prepare;
  
     if (IS_ROMAN(&Num))
         numstr = int_to_roman((int) rint(value));
     else if (IS_EEEE(&Num))
     {
         if (isnan(value) || isinf(value))
         {
             /*
              * 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 = ' ';
             *(numstr + Num.pre + 1) = '.';
         }
         else
         {
             numstr = psprintf("%+.*e", Num.post, value);
  
             /*
              * Swap a leading positive sign for a space.
              */
             if (*numstr == '+')
                 *numstr = ' ';
         }
     }
     else
     {
         float4      val = value;
         char       *orgnum;
         int         numstr_pre_len;
  
         if (IS_MULTI(&Num))
         {
             float       multi = pow((double) 10, (double) Num.multi);
  
             val = value * multi;
             Num.pre += Num.multi;
         }
  
         orgnum = psprintf("%.0f", fabs(val));
         numstr_pre_len = strlen(orgnum);
  
         /* 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;
         orgnum = psprintf("%.*f", Num.post, val);
  
         if (*orgnum == '-')
         {                       /* < 0 */
             sign = '-';
             numstr = orgnum + 1;
         }
         else
         {
             sign = '+';
             numstr = orgnum;
         }
  
         if ((p = strchr(numstr, '.')))
             numstr_pre_len = p - numstr;
         else
             numstr_pre_len = strlen(numstr);
  
         /* needs padding? */
         if (numstr_pre_len < Num.pre)
             out_pre_spaces = Num.pre - numstr_pre_len;
         /* overflowed prefix digit format? */
         else if (numstr_pre_len > Num.pre)
         {
             numstr = (char *) palloc(Num.pre + Num.post + 2);
             fill_str(numstr, '#', Num.pre + Num.post + 1);
             *(numstr + Num.pre) = '.';
         }
     }

References fill_str(), fmt, format, int_to_roman(), IS_EEEE, IS_MULTI, IS_ROMAN, NUMDesc::multi, NUM_TOCHAR_finish, NUM_TOCHAR_prepare, palloc(), PG_GETARG_FLOAT4, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, NUMDesc::post, NUMDesc::pre, psprintf(), sign, val, and value.

◆ float8_to_char()

Datum float8_to_char ( PG_FUNCTION_ARGS )

Definition at line 6594 of file formatting.c.

 {
     float8      value = PG_GETARG_FLOAT8(0);
     text       *fmt = PG_GETARG_TEXT_PP(1);
     NUMDesc     Num;
     FormatNode *format;
     text       *result;
     bool        shouldFree;
     int         out_pre_spaces = 0,
                 sign = 0;
     char       *numstr,
                *p;
  
     NUM_TOCHAR_prepare;
  
     if (IS_ROMAN(&Num))
         numstr = int_to_roman((int) rint(value));
     else if (IS_EEEE(&Num))
     {
         if (isnan(value) || isinf(value))
         {
             /*
              * 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 = ' ';
             *(numstr + Num.pre + 1) = '.';
         }
         else
         {
             numstr = psprintf("%+.*e", Num.post, value);
  
             /*
              * Swap a leading positive sign for a space.
              */
             if (*numstr == '+')
                 *numstr = ' ';
         }
     }
     else
     {
         float8      val = value;
         char       *orgnum;
         int         numstr_pre_len;
  
         if (IS_MULTI(&Num))
         {
             double      multi = pow((double) 10, (double) Num.multi);
  
             val = value * multi;
             Num.pre += Num.multi;
         }
  
         orgnum = psprintf("%.0f", fabs(val));
         numstr_pre_len = strlen(orgnum);
  
         /* 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;
         orgnum = psprintf("%.*f", Num.post, val);
  
         if (*orgnum == '-')
         {                       /* < 0 */
             sign = '-';
             numstr = orgnum + 1;
         }
         else
         {
             sign = '+';
             numstr = orgnum;
         }
  
         if ((p = strchr(numstr, '.')))
             numstr_pre_len = p - numstr;
         else
             numstr_pre_len = strlen(numstr);
  
         /* needs padding? */
         if (numstr_pre_len < Num.pre)
             out_pre_spaces = Num.pre - numstr_pre_len;
         /* overflowed prefix digit format? */
         else if (numstr_pre_len > Num.pre)
         {
             numstr = (char *) palloc(Num.pre + Num.post + 2);
             fill_str(numstr, '#', Num.pre + Num.post + 1);
             *(numstr + Num.pre) = '.';
         }
     }

References fill_str(), fmt, format, int_to_roman(), IS_EEEE, IS_MULTI, IS_ROMAN, NUMDesc::multi, NUM_TOCHAR_finish, NUM_TOCHAR_prepare, palloc(), PG_GETARG_FLOAT8, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, NUMDesc::post, NUMDesc::pre, psprintf(), sign, val, and value.

◆ from_char_parse_int()

static int from_char_parse_int	(	int *	dest,
		const char **	src,
		FormatNode *	node,
		Node *	escontext
	)

static

Definition at line 2424 of file formatting.c.

 {
     return from_char_parse_int_len(dest, src, node->key->len, node, escontext);
 }

References generate_unaccent_rules::dest, from_char_parse_int_len(), FormatNode::key, and KeyWord::len.

Referenced by DCH_from_char().

◆ from_char_parse_int_len()

static int from_char_parse_int_len	(	int *	dest,
		const char **	src,
		const int	len,
		FormatNode *	node,
		Node *	escontext
	)

static

Definition at line 2327 of file formatting.c.

 {
     long        result;
     char        copy[DCH_MAX_ITEM_SIZ + 1];
     const char *init = *src;
     int         used;
  
     /*
      * Skip any whitespace before parsing the integer.
      */
     *src += strspace_len(*src);
  
     Assert(len <= DCH_MAX_ITEM_SIZ);
     used = (int) strlcpy(copy, *src, len + 1);
  
     if (S_FM(node->suffix) || is_next_separator(node))
     {
         /*
          * This node is in Fill Mode, or the next node is known to be a
          * non-digit value, so we just slurp as many characters as we can get.
          */
         char       *endptr;
  
         errno = 0;
         result = strtol(init, &endptr, 10);
         *src = endptr;
     }
     else
     {
         /*
          * We need to pull exactly the number of characters given in 'len' out
          * of the string, and convert those.
          */
         char       *last;
  
         if (used < len)
             ereturn(escontext, -1,
                     (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                      errmsg("source string too short for \"%s\" formatting field",
                             node->key->name),
                      errdetail("Field requires %d characters, but only %d remain.",
                                len, used),
                      errhint("If your source string is not fixed-width, "
                              "try using the \"FM\" modifier.")));
  
         errno = 0;
         result = strtol(copy, &last, 10);
         used = last - copy;
  
         if (used > 0 && used < len)
             ereturn(escontext, -1,
                     (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                      errmsg("invalid value \"%s\" for \"%s\"",
                             copy, node->key->name),
                      errdetail("Field requires %d characters, but only %d could be parsed.",
                                len, used),
                      errhint("If your source string is not fixed-width, "
                              "try using the \"FM\" modifier.")));
  
         *src += used;
     }
  
     if (*src == init)
         ereturn(escontext, -1,
                 (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                  errmsg("invalid value \"%s\" for \"%s\"",
                         copy, node->key->name),
                  errdetail("Value must be an integer.")));
  
     if (errno == ERANGE || result < INT_MIN || result > INT_MAX)
         ereturn(escontext, -1,
                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
                  errmsg("value for \"%s\" in source string is out of range",
                         node->key->name),
                  errdetail("Value must be in the range %d to %d.",
                            INT_MIN, INT_MAX)));
  
     if (dest != NULL)
     {
         if (!from_char_set_int(dest, (int) result, node, escontext))
             return -1;
     }
  
     return *src - init;
 }

References Assert(), DCH_MAX_ITEM_SIZ, generate_unaccent_rules::dest, ereturn, errcode(), errdetail(), errhint(), errmsg(), from_char_set_int(), init, is_next_separator(), FormatNode::key, len, KeyWord::name, S_FM, strlcpy(), strspace_len(), and FormatNode::suffix.

Referenced by DCH_from_char(), and from_char_parse_int().

◆ from_char_seq_search()

static bool from_char_seq_search	(	int *	dest,
		const char **	src,
		const char const	array,
		char **	localized_array,
		Oid	collid,
		FormatNode *	node,
		Node *	escontext
	)

static

Definition at line 2583 of file formatting.c.

 {
     int         len;
  
     if (localized_array == NULL)
         *dest = seq_search_ascii(*src, array, &len);
     else
         *dest = seq_search_localized(*src, localized_array, &len, collid);
  
     if (len <= 0)
     {
         /*
          * In the error report, truncate the string at the next whitespace (if
          * any) to avoid including irrelevant data.
          */
         char       *copy = pstrdup(*src);
         char       *c;
  
         for (c = copy; *c; c++)
         {
             if (scanner_isspace(*c))
             {
                 *c = '\0';
                 break;
             }
         }
  
         ereturn(escontext, false,
                 (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                  errmsg("invalid value \"%s\" for \"%s\"",
                         copy, node->key->name),
                  errdetail("The given value did not match any of "
                            "the allowed values for this field.")));
     }
     *src += len;
     return true;
 }

References collid, generate_unaccent_rules::dest, ereturn, errcode(), errdetail(), errmsg(), FormatNode::key, len, KeyWord::name, pstrdup(), scanner_isspace(), seq_search_ascii(), and seq_search_localized().

Referenced by DCH_from_char().

◆ from_char_set_int()

static bool from_char_set_int	(	int *	dest,
		const int	value,
		const FormatNode *	node,
		Node *	escontext
	)

static

Definition at line 2291 of file formatting.c.

 {
     if (*dest != 0 && *dest != value)
         ereturn(escontext, false,
                 (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                  errmsg("conflicting values for \"%s\" field in formatting string",
                         node->key->name),
                  errdetail("This value contradicts a previous setting "
                            "for the same field type.")));
     *dest = value;
     return true;
 }

References generate_unaccent_rules::dest, ereturn, errcode(), errdetail(), errmsg(), FormatNode::key, KeyWord::name, and value.

Referenced by DCH_from_char(), and from_char_parse_int_len().

◆ from_char_set_mode()

static bool from_char_set_mode	(	TmFromChar *	tmfc,
		const FromCharDateMode	mode,
		Node *	escontext
	)

static

Definition at line 2264 of file formatting.c.

 {
     if (mode != FROM_CHAR_DATE_NONE)
     {
         if (tmfc->mode == FROM_CHAR_DATE_NONE)
             tmfc->mode = mode;
         else if (tmfc->mode != mode)
             ereturn(escontext, false,
                     (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
                      errmsg("invalid combination of date conventions"),
                      errhint("Do not mix Gregorian and ISO week date "
                              "conventions in a formatting template.")));
     }
     return true;
 }

References ereturn, errcode(), errhint(), errmsg(), FROM_CHAR_DATE_NONE, TmFromChar::mode, and mode.

Referenced by DCH_from_char().

◆ get_last_relevant_decnum()

static char * get_last_relevant_decnum ( char * num )

static

Definition at line 5138 of file formatting.c.

 {
     char       *result,
                *p = strchr(num, '.');
  
 #ifdef DEBUG_TO_FROM_CHAR
     elog(DEBUG_elog_output, "get_last_relevant_decnum()");
 #endif
  
     if (!p)
         return NULL;
  
     result = p;
  
     while (*(++p))
     {
         if (*p != '0')
             result = p;
     }
  
     return result;
 }

References elog().

Referenced by NUM_processor().

◆ get_th()

static const char * get_th	(	char *	num,
		int	type
	)

static

Definition at line 1505 of file formatting.c.

 {
     int         len = strlen(num),
                 last;
  
     last = *(num + (len - 1));
     if (!isdigit((unsigned char) last))
         ereport(ERROR,
                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                  errmsg("\"%s\" is not a number", num)));
  
     /*
      * All "teens" (<x>1[0-9]) get 'TH/th', while <x>[02-9][123] still get
      * 'ST/st', 'ND/nd', 'RD/rd', respectively
      */
     if ((len > 1) && (num[len - 2] == '1'))
         last = 0;
  
     switch (last)
     {
         case '1':
             if (type == TH_UPPER)
                 return numTH[0];
             return numth[0];
         case '2':
             if (type == TH_UPPER)
                 return numTH[1];
             return numth[1];
         case '3':
             if (type == TH_UPPER)
                 return numTH[2];
             return numth[2];
         default:
             if (type == TH_UPPER)
                 return numTH[3];
             return numth[3];
     }
 }

References ereport, errcode(), errmsg(), ERROR, len, numTH, numth, TH_UPPER, and generate_unaccent_rules::type.

Referenced by NUM_processor(), and str_numth().

◆ index_seq_search()

static const KeyWord * index_seq_search	(	const char *	str,
		const KeyWord *	kw,
		const int *	index
	)

static

Definition at line 1088 of file formatting.c.

 {
     int         poz;
  
     if (!KeyWord_INDEX_FILTER(*str))
         return NULL;
  
     if ((poz = *(index + (*str - ' '))) > -1)
     {
         const KeyWord *k = kw + poz;
  
         do
         {
             if (strncmp(str, k->name, k->len) == 0)
                 return k;
             k++;
             if (!k->name)
                 return NULL;
         } while (*str == *k->name);
     }
     return NULL;
 }

References KeyWord_INDEX_FILTER, KeyWord::len, KeyWord::name, and generate_unaccent_rules::str.

Referenced by parse_format().

◆ int4_to_char()

Datum int4_to_char ( PG_FUNCTION_ARGS )

Definition at line 6292 of file formatting.c.

 {
     int32       value = PG_GETARG_INT32(0);
     text       *fmt = PG_GETARG_TEXT_PP(1);
     NUMDesc     Num;
     FormatNode *format;
     text       *result;
     bool        shouldFree;
     int         out_pre_spaces = 0,
                 sign = 0;
     char       *numstr,
                *orgnum;
  
     NUM_TOCHAR_prepare;
  
     /*
      * On DateType depend part (int32)
      */
     if (IS_ROMAN(&Num))
         numstr = int_to_roman(value);
     else if (IS_EEEE(&Num))
     {
         /* we can do it easily because float8 won't lose any precision */
         float8      val = (float8) value;
  
         orgnum = (char *) psprintf("%+.*e", Num.post, val);
  
         /*
          * Swap a leading positive sign for a space.
          */
         if (*orgnum == '+')
             *orgnum = ' ';
  
         numstr = orgnum;
     }
     else
     {
         int         numstr_pre_len;
  
         if (IS_MULTI(&Num))
         {
             orgnum = DatumGetCString(DirectFunctionCall1(int4out,
                                                          Int32GetDatum(value * ((int32) pow((double) 10, (double) Num.multi)))));
             Num.pre += Num.multi;
         }
         else
         {
             orgnum = DatumGetCString(DirectFunctionCall1(int4out,
                                                          Int32GetDatum(value)));
         }
  
         if (*orgnum == '-')
         {
             sign = '-';
             orgnum++;
         }
         else
             sign = '+';
  
         numstr_pre_len = strlen(orgnum);
  
         /* post-decimal digits?  Pad out with zeros. */
         if (Num.post)
         {
             numstr = (char *) palloc(numstr_pre_len + Num.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';
         }
         else
             numstr = orgnum;
  
         /* needs padding? */
         if (numstr_pre_len < Num.pre)
             out_pre_spaces = Num.pre - numstr_pre_len;
         /* overflowed prefix digit format? */
         else if (numstr_pre_len > Num.pre)
         {
             numstr = (char *) palloc(Num.pre + Num.post + 2);
             fill_str(numstr, '#', Num.pre + Num.post + 1);
             *(numstr + Num.pre) = '.';
         }
     }

References DatumGetCString(), DirectFunctionCall1, fill_str(), fmt, format, Int32GetDatum(), int4out(), int_to_roman(), IS_EEEE, IS_MULTI, IS_ROMAN, NUMDesc::multi, NUM_TOCHAR_finish, NUM_TOCHAR_prepare, palloc(), PG_GETARG_INT32, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, NUMDesc::post, NUMDesc::pre, psprintf(), sign, val, and value.

◆ int8_to_char()

Datum int8_to_char ( PG_FUNCTION_ARGS )

Definition at line 6386 of file formatting.c.

 {
     int64       value = PG_GETARG_INT64(0);
     text       *fmt = PG_GETARG_TEXT_PP(1);
     NUMDesc     Num;
     FormatNode *format;
     text       *result;
     bool        shouldFree;
     int         out_pre_spaces = 0,
                 sign = 0;
     char       *numstr,
                *orgnum;
  
     NUM_TOCHAR_prepare;
  
     /*
      * On DateType depend part (int32)
      */
     if (IS_ROMAN(&Num))
     {
         /* Currently don't support int8 conversion to roman... */
         numstr = int_to_roman(DatumGetInt32(DirectFunctionCall1(int84, Int64GetDatum(value))));
     }
     else if (IS_EEEE(&Num))
     {
         /* to avoid loss of precision, must go via numeric not float8 */
         orgnum = numeric_out_sci(int64_to_numeric(value),
                                  Num.post);
  
         /*
          * numeric_out_sci() does not emit a sign for positive numbers.  We
          * need to add a space in this case so that positive and negative
          * numbers are aligned.  We don't have to worry about NaN/inf here.
          */
         if (*orgnum != '-')
         {
             numstr = (char *) palloc(strlen(orgnum) + 2);
             *numstr = ' ';
             strcpy(numstr + 1, orgnum);
         }
         else
         {
             numstr = orgnum;
         }
     }
     else
     {
         int         numstr_pre_len;
  
         if (IS_MULTI(&Num))
         {
             double      multi = pow((double) 10, (double) Num.multi);
  
             value = DatumGetInt64(DirectFunctionCall2(int8mul,
                                                       Int64GetDatum(value),
                                                       DirectFunctionCall1(dtoi8,
                                                                           Float8GetDatum(multi))));
             Num.pre += Num.multi;
         }
  
         orgnum = DatumGetCString(DirectFunctionCall1(int8out,
                                                      Int64GetDatum(value)));
  
         if (*orgnum == '-')
         {
             sign = '-';
             orgnum++;
         }
         else
             sign = '+';
  
         numstr_pre_len = strlen(orgnum);
  
         /* post-decimal digits?  Pad out with zeros. */
         if (Num.post)
         {
             numstr = (char *) palloc(numstr_pre_len + Num.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';
         }
         else
             numstr = orgnum;
  
         /* needs padding? */
         if (numstr_pre_len < Num.pre)
             out_pre_spaces = Num.pre - numstr_pre_len;
         /* overflowed prefix digit format? */
         else if (numstr_pre_len > Num.pre)
         {
             numstr = (char *) palloc(Num.pre + Num.post + 2);
             fill_str(numstr, '#', Num.pre + Num.post + 1);
             *(numstr + Num.pre) = '.';
         }
     }

References DatumGetCString(), DatumGetInt32(), DatumGetInt64(), DirectFunctionCall1, DirectFunctionCall2, dtoi8(), fill_str(), Float8GetDatum(), fmt, format, int64_to_numeric(), Int64GetDatum(), int84(), int8mul(), int8out(), int_to_roman(), IS_EEEE, IS_MULTI, IS_ROMAN, NUMDesc::multi, NUM_TOCHAR_finish, NUM_TOCHAR_prepare, numeric_out_sci(), palloc(), PG_GETARG_INT64, PG_GETARG_TEXT_PP, PG_RETURN_TEXT_P, NUMDesc::post, NUMDesc::pre, sign, and value.

◆ int_to_roman()

static char * int_to_roman ( int number )

static

Definition at line 5007 of file formatting.c.

 {
     int         len,
                 num;
     char       *p,
                *result,
                 numstr[12];
  
     result = (char *) palloc(16);
     *result = '\0';
  
     if (number > 3999 || number < 1)
     {
         fill_str(result, '#', 15);
         return result;
     }
     len = snprintf(numstr, sizeof(numstr), "%d", number);
  
     for (p = numstr; *p != '\0'; p++, --len)
     {
         num = *p - ('0' + 1);
         if (num < 0)
             continue;
  
         if (len > 3)
         {
             while (num-- != -1)
                 strcat(result, "M");
         }
         else
         {
             if (len == 3)
                 strcat(result, rm100[num]);
             else if (len == 2)
                 strcat(result, rm10[num]);
             else if (len == 1)
                 strcat(result, rm1[num]);
         }
     }
     return result;
 }

References fill_str(), len, palloc(), rm1, rm10, rm100, and snprintf.

Referenced by float4_to_char(), float8_to_char(), int4_to_char(), int8_to_char(), and numeric_to_char().

◆ interval_to_char()

Datum interval_to_char ( PG_FUNCTION_ARGS )

Definition at line 4138 of file formatting.c.

 {
     Interval   *it = PG_GETARG_INTERVAL_P(0);
     text       *fmt = PG_GETARG_TEXT_PP(1),
                *res;
     TmToChar    tmtc;
     struct fmt_tm *tm;
     struct pg_itm tt,
                *itm = &tt;
  
     if (VARSIZE_ANY_EXHDR(fmt) <= 0)
         PG_RETURN_NULL();
  
     ZERO_tmtc(&tmtc);
     tm = tmtcTm(&tmtc);
  
     interval2itm(*it, itm);
     tmtc.fsec = itm->tm_usec;
     tm->tm_sec = itm->tm_sec;
     tm->tm_min = itm->tm_min;
     tm->tm_hour = itm->tm_hour;
     tm->tm_mday = itm->tm_mday;
     tm->tm_mon = itm->tm_mon;
     tm->tm_year = itm->tm_year;
  
     /* wday is meaningless, yday approximates the total span in days */
     tm->tm_yday = (tm->tm_year * MONTHS_PER_YEAR + tm->tm_mon) * DAYS_PER_MONTH + tm->tm_mday;
  
     if (!(res = datetime_to_char_body(&tmtc, fmt, true, PG_GET_COLLATION())))
         PG_RETURN_NULL();
  
     PG_RETURN_TEXT_P(res);
 }

References datetime_to_char_body(), DAYS_PER_MONTH, fmt, TmToChar::fsec, if(), interval2itm(), MONTHS_PER_YEAR, PG_GET_COLLATION, PG_GETARG_INTERVAL_P, PG_GETARG_TEXT_PP, PG_RETURN_NULL, PG_RETURN_TEXT_P, res, tm, pg_itm::tm_hour, pg_tm::tm_hour, pg_itm::tm_mday, pg_tm::tm_mday, pg_itm::tm_min, pg_tm::tm_min, pg_itm::tm_mon, pg_tm::tm_mon, pg_itm::tm_sec, pg_tm::tm_sec, pg_itm::tm_usec, pg_tm::tm_yday, pg_itm::tm_year, pg_tm::tm_year, tmtcTm, VARSIZE_ANY_EXHDR, and ZERO_tmtc.

◆ is_next_separator()

static bool is_next_separator ( FormatNode * n )

static

Definition at line 2185 of file formatting.c.

 {
     if (n->type == NODE_TYPE_END)
         return false;
  
     if (n->type == NODE_TYPE_ACTION && S_THth(n->suffix))
         return true;
  
     /*
      * Next node
      */
     n++;
  
     /* end of format string is treated like a non-digit separator */
     if (n->type == 

Data Structures

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ A_D_STR

◆ a_d_STR

◆ A_M_STR

◆ a_m_STR

◆ AD_STR

◆ ad_STR

◆ ADJUST_YEAR

◆ AM_STR

◆ am_STR

◆ AMOUNT_TEST

◆ B_C_STR

◆ b_c_STR

◆ BC_STR

◆ bc_STR

◆ CLOCK_12_HOUR

◆ CLOCK_24_HOUR

◆ COPY_tm

◆ DCH_CACHE_ENTRIES

◆ DCH_CACHE_OVERHEAD

◆ DCH_CACHE_SIZE

◆ DCH_DATED

◆ DCH_FLAG

◆ DCH_MAX_ITEM_SIZ

◆ DCH_S_FM

◆ DCH_S_SP

◆ DCH_S_TH

◆ DCH_S_th

◆ DCH_S_TM

◆ DCH_TIMED

◆ DCH_to_char_fsec

◆ DCH_ZONED

◆ DEBUG_TM

◆ DEBUG_TMFC

◆ INVALID_FOR_INTERVAL

◆ IS_BLANK

◆ IS_BRACKET

◆ IS_DECIMAL

◆ IS_EEEE

◆ IS_FILLMODE

◆ IS_LDECIMAL

◆ IS_LSIGN

◆ IS_MINUS

◆ IS_MULTI

◆ IS_PLUS

◆ IS_PREDEC_SPACE

◆ IS_ROMAN

◆ IS_ZERO

◆ KeyWord_INDEX_FILTER

◆ KeyWord_INDEX_SIZE

◆ NODE_TYPE_ACTION

◆ NODE_TYPE_CHAR

◆ NODE_TYPE_END

◆ NODE_TYPE_SEPARATOR

◆ NODE_TYPE_SPACE

◆ NUM_CACHE_ENTRIES

◆ NUM_CACHE_OVERHEAD

◆ NUM_CACHE_SIZE

◆ NUM_F_BLANK

◆ NUM_F_BRACKET

◆ NUM_F_DECIMAL

◆ NUM_F_EEEE

◆ NUM_F_FILLMODE

◆ NUM_F_LDECIMAL

◆ NUM_F_LSIGN

◆ NUM_F_MINUS

◆ NUM_F_MINUS_POST

◆ NUM_F_MULTI

◆ NUM_F_PLUS

◆ NUM_F_PLUS_POST

◆ NUM_F_ROMAN

◆ NUM_F_ZERO

◆ NUM_FLAG

◆ NUM_LSIGN_NONE