LCOV - code coverage report
Current view: top level - src/backend/utils/adt - formatting.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17beta1 Lines: 1921 2392 80.3 %
Date: 2024-06-18 00:11:41 Functions: 61 66 92.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -----------------------------------------------------------------------
       2             :  * formatting.c
       3             :  *
       4             :  * src/backend/utils/adt/formatting.c
       5             :  *
       6             :  *
       7             :  *   Portions Copyright (c) 1999-2024, PostgreSQL Global Development Group
       8             :  *
       9             :  *
      10             :  *   TO_CHAR(); TO_TIMESTAMP(); TO_DATE(); TO_NUMBER();
      11             :  *
      12             :  *   The PostgreSQL routines for a timestamp/int/float/numeric formatting,
      13             :  *   inspired by the Oracle TO_CHAR() / TO_DATE() / TO_NUMBER() routines.
      14             :  *
      15             :  *
      16             :  *   Cache & Memory:
      17             :  *  Routines use (itself) internal cache for format pictures.
      18             :  *
      19             :  *  The cache uses a static buffer and is persistent across transactions.  If
      20             :  *  the format-picture is bigger than the cache buffer, the parser is called
      21             :  *  always.
      22             :  *
      23             :  *   NOTE for Number version:
      24             :  *  All in this version is implemented as keywords ( => not used
      25             :  *  suffixes), because a format picture is for *one* item (number)
      26             :  *  only. It not is as a timestamp version, where each keyword (can)
      27             :  *  has suffix.
      28             :  *
      29             :  *   NOTE for Timestamp routines:
      30             :  *  In this module the POSIX 'struct tm' type is *not* used, but rather
      31             :  *  PgSQL type, which has tm_mon based on one (*non* zero) and
      32             :  *  year *not* based on 1900, but is used full year number.
      33             :  *  Module supports AD / BC / AM / PM.
      34             :  *
      35             :  *  Supported types for to_char():
      36             :  *
      37             :  *      Timestamp, Numeric, int4, int8, float4, float8
      38             :  *
      39             :  *  Supported types for reverse conversion:
      40             :  *
      41             :  *      Timestamp   - to_timestamp()
      42             :  *      Date        - to_date()
      43             :  *      Numeric     - to_number()
      44             :  *
      45             :  *
      46             :  *  Karel Zak
      47             :  *
      48             :  * TODO
      49             :  *  - better number building (formatting) / parsing, now it isn't
      50             :  *        ideal code
      51             :  *  - use Assert()
      52             :  *  - add support for roman number to standard number conversion
      53             :  *  - add support for number spelling
      54             :  *  - add support for string to string formatting (we must be better
      55             :  *    than Oracle :-),
      56             :  *      to_char('Hello', 'X X X X X') -> 'H e l l o'
      57             :  *
      58             :  * -----------------------------------------------------------------------
      59             :  */
      60             : 
      61             : #ifdef DEBUG_TO_FROM_CHAR
      62             : #define DEBUG_elog_output   DEBUG3
      63             : #endif
      64             : 
      65             : #include "postgres.h"
      66             : 
      67             : #include <ctype.h>
      68             : #include <unistd.h>
      69             : #include <math.h>
      70             : #include <float.h>
      71             : #include <limits.h>
      72             : #include <wctype.h>
      73             : 
      74             : #ifdef USE_ICU
      75             : #include <unicode/ustring.h>
      76             : #endif
      77             : 
      78             : #include "catalog/pg_collation.h"
      79             : #include "catalog/pg_type.h"
      80             : #include "common/unicode_case.h"
      81             : #include "common/unicode_category.h"
      82             : #include "mb/pg_wchar.h"
      83             : #include "nodes/miscnodes.h"
      84             : #include "parser/scansup.h"
      85             : #include "utils/builtins.h"
      86             : #include "utils/date.h"
      87             : #include "utils/datetime.h"
      88             : #include "utils/formatting.h"
      89             : #include "utils/memutils.h"
      90             : #include "utils/numeric.h"
      91             : #include "utils/pg_locale.h"
      92             : #include "varatt.h"
      93             : 
      94             : 
      95             : /* ----------
      96             :  * Routines flags
      97             :  * ----------
      98             :  */
      99             : #define DCH_FLAG        0x1     /* DATE-TIME flag   */
     100             : #define NUM_FLAG        0x2     /* NUMBER flag  */
     101             : #define STD_FLAG        0x4     /* STANDARD flag    */
     102             : 
     103             : /* ----------
     104             :  * KeyWord Index (ascii from position 32 (' ') to 126 (~))
     105             :  * ----------
     106             :  */
     107             : #define KeyWord_INDEX_SIZE      ('~' - ' ')
     108             : #define KeyWord_INDEX_FILTER(_c)    ((_c) <= ' ' || (_c) >= '~' ? 0 : 1)
     109             : 
     110             : /* ----------
     111             :  * Maximal length of one node
     112             :  * ----------
     113             :  */
     114             : #define DCH_MAX_ITEM_SIZ       12   /* max localized day name       */
     115             : #define NUM_MAX_ITEM_SIZ        8   /* roman number (RN has 15 chars)   */
     116             : 
     117             : 
     118             : /* ----------
     119             :  * Format parser structs
     120             :  * ----------
     121             :  */
     122             : typedef struct
     123             : {
     124             :     const char *name;           /* suffix string        */
     125             :     int         len,            /* suffix length        */
     126             :                 id,             /* used in node->suffix */
     127             :                 type;           /* prefix / postfix     */
     128             : } KeySuffix;
     129             : 
     130             : /* ----------
     131             :  * FromCharDateMode
     132             :  * ----------
     133             :  *
     134             :  * This value is used to nominate one of several distinct (and mutually
     135             :  * exclusive) date conventions that a keyword can belong to.
     136             :  */
     137             : typedef enum
     138             : {
     139             :     FROM_CHAR_DATE_NONE = 0,    /* Value does not affect date mode. */
     140             :     FROM_CHAR_DATE_GREGORIAN,   /* Gregorian (day, month, year) style date */
     141             :     FROM_CHAR_DATE_ISOWEEK,     /* ISO 8601 week date */
     142             : } FromCharDateMode;
     143             : 
     144             : typedef struct
     145             : {
     146             :     const char *name;
     147             :     int         len;
     148             :     int         id;
     149             :     bool        is_digit;
     150             :     FromCharDateMode date_mode;
     151             : } KeyWord;
     152             : 
     153             : typedef struct
     154             : {
     155             :     uint8       type;           /* NODE_TYPE_XXX, see below */
     156             :     char        character[MAX_MULTIBYTE_CHAR_LEN + 1];  /* if type is CHAR */
     157             :     uint8       suffix;         /* keyword prefix/suffix code, if any */
     158             :     const KeyWord *key;         /* if type is ACTION */
     159             : } FormatNode;
     160             : 
     161             : #define NODE_TYPE_END       1
     162             : #define NODE_TYPE_ACTION    2
     163             : #define NODE_TYPE_CHAR      3
     164             : #define NODE_TYPE_SEPARATOR 4
     165             : #define NODE_TYPE_SPACE     5
     166             : 
     167             : #define SUFFTYPE_PREFIX     1
     168             : #define SUFFTYPE_POSTFIX    2
     169             : 
     170             : #define CLOCK_24_HOUR       0
     171             : #define CLOCK_12_HOUR       1
     172             : 
     173             : 
     174             : /* ----------
     175             :  * Full months
     176             :  * ----------
     177             :  */
     178             : static const char *const months_full[] = {
     179             :     "January", "February", "March", "April", "May", "June", "July",
     180             :     "August", "September", "October", "November", "December", NULL
     181             : };
     182             : 
     183             : static const char *const days_short[] = {
     184             :     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", NULL
     185             : };
     186             : 
     187             : /* ----------
     188             :  * AD / BC
     189             :  * ----------
     190             :  *  There is no 0 AD.  Years go from 1 BC to 1 AD, so we make it
     191             :  *  positive and map year == -1 to year zero, and shift all negative
     192             :  *  years up one.  For interval years, we just return the year.
     193             :  */
     194             : #define ADJUST_YEAR(year, is_interval)  ((is_interval) ? (year) : ((year) <= 0 ? -((year) - 1) : (year)))
     195             : 
     196             : #define A_D_STR     "A.D."
     197             : #define a_d_STR     "a.d."
     198             : #define AD_STR      "AD"
     199             : #define ad_STR      "ad"
     200             : 
     201             : #define B_C_STR     "B.C."
     202             : #define b_c_STR     "b.c."
     203             : #define BC_STR      "BC"
     204             : #define bc_STR      "bc"
     205             : 
     206             : /*
     207             :  * AD / BC strings for seq_search.
     208             :  *
     209             :  * These are given in two variants, a long form with periods and a standard
     210             :  * form without.
     211             :  *
     212             :  * The array is laid out such that matches for AD have an even index, and
     213             :  * matches for BC have an odd index.  So the boolean value for BC is given by
     214             :  * taking the array index of the match, modulo 2.
     215             :  */
     216             : static const char *const adbc_strings[] = {ad_STR, bc_STR, AD_STR, BC_STR, NULL};
     217             : static const char *const adbc_strings_long[] = {a_d_STR, b_c_STR, A_D_STR, B_C_STR, NULL};
     218             : 
     219             : /* ----------
     220             :  * AM / PM
     221             :  * ----------
     222             :  */
     223             : #define A_M_STR     "A.M."
     224             : #define a_m_STR     "a.m."
     225             : #define AM_STR      "AM"
     226             : #define am_STR      "am"
     227             : 
     228             : #define P_M_STR     "P.M."
     229             : #define p_m_STR     "p.m."
     230             : #define PM_STR      "PM"
     231             : #define pm_STR      "pm"
     232             : 
     233             : /*
     234             :  * AM / PM strings for seq_search.
     235             :  *
     236             :  * These are given in two variants, a long form with periods and a standard
     237             :  * form without.
     238             :  *
     239             :  * The array is laid out such that matches for AM have an even index, and
     240             :  * matches for PM have an odd index.  So the boolean value for PM is given by
     241             :  * taking the array index of the match, modulo 2.
     242             :  */
     243             : static const char *const ampm_strings[] = {am_STR, pm_STR, AM_STR, PM_STR, NULL};
     244             : static const char *const ampm_strings_long[] = {a_m_STR, p_m_STR, A_M_STR, P_M_STR, NULL};
     245             : 
     246             : /* ----------
     247             :  * Months in roman-numeral
     248             :  * (Must be in reverse order for seq_search (in FROM_CHAR), because
     249             :  *  'VIII' must have higher precedence than 'V')
     250             :  * ----------
     251             :  */
     252             : static const char *const rm_months_upper[] =
     253             : {"XII", "XI", "X", "IX", "VIII", "VII", "VI", "V", "IV", "III", "II", "I", NULL};
     254             : 
     255             : static const char *const rm_months_lower[] =
     256             : {"xii", "xi", "x", "ix", "viii", "vii", "vi", "v", "iv", "iii", "ii", "i", NULL};
     257             : 
     258             : /* ----------
     259             :  * Roman numbers
     260             :  * ----------
     261             :  */
     262             : static const char *const rm1[] = {"I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", NULL};
     263             : static const char *const rm10[] = {"X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC", NULL};
     264             : static const char *const rm100[] = {"C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM", NULL};
     265             : 
     266             : /* ----------
     267             :  * Ordinal postfixes
     268             :  * ----------
     269             :  */
     270             : static const char *const numTH[] = {"ST", "ND", "RD", "TH", NULL};
     271             : static const char *const numth[] = {"st", "nd", "rd", "th", NULL};
     272             : 
     273             : /* ----------
     274             :  * Flags & Options:
     275             :  * ----------
     276             :  */
     277             : #define TH_UPPER        1
     278             : #define TH_LOWER        2
     279             : 
     280             : /* ----------
     281             :  * Number description struct
     282             :  * ----------
     283             :  */
     284             : typedef struct
     285             : {
     286             :     int         pre,            /* (count) numbers before decimal */
     287             :                 post,           /* (count) numbers after decimal  */
     288             :                 lsign,          /* want locales sign          */
     289             :                 flag,           /* number parameters          */
     290             :                 pre_lsign_num,  /* tmp value for lsign        */
     291             :                 multi,          /* multiplier for 'V'         */
     292             :                 zero_start,     /* position of first zero     */
     293             :                 zero_end,       /* position of last zero      */
     294             :                 need_locale;    /* needs it locale        */
     295             : } NUMDesc;
     296             : 
     297             : /* ----------
     298             :  * Flags for NUMBER version
     299             :  * ----------
     300             :  */
     301             : #define NUM_F_DECIMAL       (1 << 1)
     302             : #define NUM_F_LDECIMAL      (1 << 2)
     303             : #define NUM_F_ZERO          (1 << 3)
     304             : #define NUM_F_BLANK         (1 << 4)
     305             : #define NUM_F_FILLMODE      (1 << 5)
     306             : #define NUM_F_LSIGN         (1 << 6)
     307             : #define NUM_F_BRACKET       (1 << 7)
     308             : #define NUM_F_MINUS         (1 << 8)
     309             : #define NUM_F_PLUS          (1 << 9)
     310             : #define NUM_F_ROMAN         (1 << 10)
     311             : #define NUM_F_MULTI         (1 << 11)
     312             : #define NUM_F_PLUS_POST     (1 << 12)
     313             : #define NUM_F_MINUS_POST    (1 << 13)
     314             : #define NUM_F_EEEE          (1 << 14)
     315             : 
     316             : #define NUM_LSIGN_PRE   (-1)
     317             : #define NUM_LSIGN_POST  1
     318             : #define NUM_LSIGN_NONE  0
     319             : 
     320             : /* ----------
     321             :  * Tests
     322             :  * ----------
     323             :  */
     324             : #define IS_DECIMAL(_f)  ((_f)->flag & NUM_F_DECIMAL)
     325             : #define IS_LDECIMAL(_f) ((_f)->flag & NUM_F_LDECIMAL)
     326             : #define IS_ZERO(_f) ((_f)->flag & NUM_F_ZERO)
     327             : #define IS_BLANK(_f)    ((_f)->flag & NUM_F_BLANK)
     328             : #define IS_FILLMODE(_f) ((_f)->flag & NUM_F_FILLMODE)
     329             : #define IS_BRACKET(_f)  ((_f)->flag & NUM_F_BRACKET)
     330             : #define IS_MINUS(_f)    ((_f)->flag & NUM_F_MINUS)
     331             : #define IS_LSIGN(_f)    ((_f)->flag & NUM_F_LSIGN)
     332             : #define IS_PLUS(_f) ((_f)->flag & NUM_F_PLUS)
     333             : #define IS_ROMAN(_f)    ((_f)->flag & NUM_F_ROMAN)
     334             : #define IS_MULTI(_f)    ((_f)->flag & NUM_F_MULTI)
     335             : #define IS_EEEE(_f)     ((_f)->flag & NUM_F_EEEE)
     336             : 
     337             : /* ----------
     338             :  * Format picture cache
     339             :  *
     340             :  * We will cache datetime format pictures up to DCH_CACHE_SIZE bytes long;
     341             :  * likewise number format pictures up to NUM_CACHE_SIZE bytes long.
     342             :  *
     343             :  * For simplicity, the cache entries are fixed-size, so they allow for the
     344             :  * worst case of a FormatNode for each byte in the picture string.
     345             :  *
     346             :  * The CACHE_SIZE constants are computed to make sizeof(DCHCacheEntry) and
     347             :  * sizeof(NUMCacheEntry) be powers of 2, or just less than that, so that
     348             :  * we don't waste too much space by palloc'ing them individually.  Be sure
     349             :  * to adjust those macros if you add fields to those structs.
     350             :  *
     351             :  * The max number of entries in each cache is DCH_CACHE_ENTRIES
     352             :  * resp. NUM_CACHE_ENTRIES.
     353             :  * ----------
     354             :  */
     355             : #define DCH_CACHE_OVERHEAD \
     356             :     MAXALIGN(sizeof(bool) + sizeof(int))
     357             : #define NUM_CACHE_OVERHEAD \
     358             :     MAXALIGN(sizeof(bool) + sizeof(int) + sizeof(NUMDesc))
     359             : 
     360             : #define DCH_CACHE_SIZE \
     361             :     ((2048 - DCH_CACHE_OVERHEAD) / (sizeof(FormatNode) + sizeof(char)) - 1)
     362             : #define NUM_CACHE_SIZE \
     363             :     ((1024 - NUM_CACHE_OVERHEAD) / (sizeof(FormatNode) + sizeof(char)) - 1)
     364             : 
     365             : #define DCH_CACHE_ENTRIES   20
     366             : #define NUM_CACHE_ENTRIES   20
     367             : 
     368             : typedef struct
     369             : {
     370             :     FormatNode  format[DCH_CACHE_SIZE + 1];
     371             :     char        str[DCH_CACHE_SIZE + 1];
     372             :     bool        std;
     373             :     bool        valid;
     374             :     int         age;
     375             : } DCHCacheEntry;
     376             : 
     377             : typedef struct
     378             : {
     379             :     FormatNode  format[NUM_CACHE_SIZE + 1];
     380             :     char        str[NUM_CACHE_SIZE + 1];
     381             :     bool        valid;
     382             :     int         age;
     383             :     NUMDesc     Num;
     384             : } NUMCacheEntry;
     385             : 
     386             : /* global cache for date/time format pictures */
     387             : static DCHCacheEntry *DCHCache[DCH_CACHE_ENTRIES];
     388             : static int  n_DCHCache = 0;     /* current number of entries */
     389             : static int  DCHCounter = 0;     /* aging-event counter */
     390             : 
     391             : /* global cache for number format pictures */
     392             : static NUMCacheEntry *NUMCache[NUM_CACHE_ENTRIES];
     393             : static int  n_NUMCache = 0;     /* current number of entries */
     394             : static int  NUMCounter = 0;     /* aging-event counter */
     395             : 
     396             : /* ----------
     397             :  * For char->date/time conversion
     398             :  * ----------
     399             :  */
     400             : typedef struct
     401             : {
     402             :     FromCharDateMode mode;
     403             :     int         hh,
     404             :                 pm,
     405             :                 mi,
     406             :                 ss,
     407             :                 ssss,
     408             :                 d,              /* stored as 1-7, Sunday = 1, 0 means missing */
     409             :                 dd,
     410             :                 ddd,
     411             :                 mm,
     412             :                 ms,
     413             :                 year,
     414             :                 bc,
     415             :                 ww,
     416             :                 w,
     417             :                 cc,
     418             :                 j,
     419             :                 us,
     420             :                 yysz,           /* is it YY or YYYY ? */
     421             :                 clock,          /* 12 or 24 hour clock? */
     422             :                 tzsign,         /* +1, -1, or 0 if no TZH/TZM fields */
     423             :                 tzh,
     424             :                 tzm,
     425             :                 ff;             /* fractional precision */
     426             :     bool        has_tz;         /* was there a TZ field? */
     427             :     int         gmtoffset;      /* GMT offset of fixed-offset zone abbrev */
     428             :     pg_tz      *tzp;            /* pg_tz for dynamic abbrev */
     429             :     char       *abbrev;         /* dynamic abbrev */
     430             : } TmFromChar;
     431             : 
     432             : #define ZERO_tmfc(_X) memset(_X, 0, sizeof(TmFromChar))
     433             : 
     434             : struct fmt_tz                   /* do_to_timestamp's timezone info output */
     435             : {
     436             :     bool        has_tz;         /* was there any TZ/TZH/TZM field? */
     437             :     int         gmtoffset;      /* GMT offset in seconds */
     438             : };
     439             : 
     440             : /* ----------
     441             :  * Debug
     442             :  * ----------
     443             :  */
     444             : #ifdef DEBUG_TO_FROM_CHAR
     445             : #define DEBUG_TMFC(_X) \
     446             :         elog(DEBUG_elog_output, "TMFC:\nmode %d\nhh %d\npm %d\nmi %d\nss %d\nssss %d\nd %d\ndd %d\nddd %d\nmm %d\nms: %d\nyear %d\nbc %d\nww %d\nw %d\ncc %d\nj %d\nus: %d\nyysz: %d\nclock: %d", \
     447             :             (_X)->mode, (_X)->hh, (_X)->pm, (_X)->mi, (_X)->ss, (_X)->ssss, \
     448             :             (_X)->d, (_X)->dd, (_X)->ddd, (_X)->mm, (_X)->ms, (_X)->year, \
     449             :             (_X)->bc, (_X)->ww, (_X)->w, (_X)->cc, (_X)->j, (_X)->us, \
     450             :             (_X)->yysz, (_X)->clock)
     451             : #define DEBUG_TM(_X) \
     452             :         elog(DEBUG_elog_output, "TM:\nsec %d\nyear %d\nmin %d\nwday %d\nhour %d\nyday %d\nmday %d\nnisdst %d\nmon %d\n",\
     453             :             (_X)->tm_sec, (_X)->tm_year,\
     454             :             (_X)->tm_min, (_X)->tm_wday, (_X)->tm_hour, (_X)->tm_yday,\
     455             :             (_X)->tm_mday, (_X)->tm_isdst, (_X)->tm_mon)
     456             : #else
     457             : #define DEBUG_TMFC(_X)
     458             : #define DEBUG_TM(_X)
     459             : #endif
     460             : 
     461             : /* ----------
     462             :  * Datetime to char conversion
     463             :  *
     464             :  * To support intervals as well as timestamps, we use a custom "tm" struct
     465             :  * that is almost like struct pg_tm, but has a 64-bit tm_hour field.
     466             :  * We omit the tm_isdst and tm_zone fields, which are not used here.
     467             :  * ----------
     468             :  */
     469             : struct fmt_tm
     470             : {
     471             :     int         tm_sec;
     472             :     int         tm_min;
     473             :     int64       tm_hour;
     474             :     int         tm_mday;
     475             :     int         tm_mon;
     476             :     int         tm_year;
     477             :     int         tm_wday;
     478             :     int         tm_yday;
     479             :     long int    tm_gmtoff;
     480             : };
     481             : 
     482             : typedef struct TmToChar
     483             : {
     484             :     struct fmt_tm tm;           /* almost the classic 'tm' struct */
     485             :     fsec_t      fsec;           /* fractional seconds */
     486             :     const char *tzn;            /* timezone */
     487             : } TmToChar;
     488             : 
     489             : #define tmtcTm(_X)  (&(_X)->tm)
     490             : #define tmtcTzn(_X) ((_X)->tzn)
     491             : #define tmtcFsec(_X)    ((_X)->fsec)
     492             : 
     493             : /* Note: this is used to copy pg_tm to fmt_tm, so not quite a bitwise copy */
     494             : #define COPY_tm(_DST, _SRC) \
     495             : do {    \
     496             :     (_DST)->tm_sec = (_SRC)->tm_sec; \
     497             :     (_DST)->tm_min = (_SRC)->tm_min; \
     498             :     (_DST)->tm_hour = (_SRC)->tm_hour; \
     499             :     (_DST)->tm_mday = (_SRC)->tm_mday; \
     500             :     (_DST)->tm_mon = (_SRC)->tm_mon; \
     501             :     (_DST)->tm_year = (_SRC)->tm_year; \
     502             :     (_DST)->tm_wday = (_SRC)->tm_wday; \
     503             :     (_DST)->tm_yday = (_SRC)->tm_yday; \
     504             :     (_DST)->tm_gmtoff = (_SRC)->tm_gmtoff; \
     505             : } while(0)
     506             : 
     507             : /* Caution: this is used to zero both pg_tm and fmt_tm structs */
     508             : #define ZERO_tm(_X) \
     509             : do {    \
     510             :     memset(_X, 0, sizeof(*(_X))); \
     511             :     (_X)->tm_mday = (_X)->tm_mon = 1; \
     512             : } while(0)
     513             : 
     514             : #define ZERO_tmtc(_X) \
     515             : do { \
     516             :     ZERO_tm( tmtcTm(_X) ); \
     517             :     tmtcFsec(_X) = 0; \
     518             :     tmtcTzn(_X) = NULL; \
     519             : } while(0)
     520             : 
     521             : /*
     522             :  *  to_char(time) appears to to_char() as an interval, so this check
     523             :  *  is really for interval and time data types.
     524             :  */
     525             : #define INVALID_FOR_INTERVAL  \
     526             : do { \
     527             :     if (is_interval) \
     528             :         ereport(ERROR, \
     529             :                 (errcode(ERRCODE_INVALID_DATETIME_FORMAT), \
     530             :                  errmsg("invalid format specification for an interval value"), \
     531             :                  errhint("Intervals are not tied to specific calendar dates."))); \
     532             : } while(0)
     533             : 
     534             : /*****************************************************************************
     535             :  *          KeyWord definitions
     536             :  *****************************************************************************/
     537             : 
     538             : /* ----------
     539             :  * Suffixes (FormatNode.suffix is an OR of these codes)
     540             :  * ----------
     541             :  */
     542             : #define DCH_S_FM    0x01
     543             : #define DCH_S_TH    0x02
     544             : #define DCH_S_th    0x04
     545             : #define DCH_S_SP    0x08
     546             : #define DCH_S_TM    0x10
     547             : 
     548             : /* ----------
     549             :  * Suffix tests
     550             :  * ----------
     551             :  */
     552             : #define S_THth(_s)  ((((_s) & DCH_S_TH) || ((_s) & DCH_S_th)) ? 1 : 0)
     553             : #define S_TH(_s)    (((_s) & DCH_S_TH) ? 1 : 0)
     554             : #define S_th(_s)    (((_s) & DCH_S_th) ? 1 : 0)
     555             : #define S_TH_TYPE(_s)   (((_s) & DCH_S_TH) ? TH_UPPER : TH_LOWER)
     556             : 
     557             : /* Oracle toggles FM behavior, we don't; see docs. */
     558             : #define S_FM(_s)    (((_s) & DCH_S_FM) ? 1 : 0)
     559             : #define S_SP(_s)    (((_s) & DCH_S_SP) ? 1 : 0)
     560             : #define S_TM(_s)    (((_s) & DCH_S_TM) ? 1 : 0)
     561             : 
     562             : /* ----------
     563             :  * Suffixes definition for DATE-TIME TO/FROM CHAR
     564             :  * ----------
     565             :  */
     566             : #define TM_SUFFIX_LEN   2
     567             : 
     568             : static const KeySuffix DCH_suff[] = {
     569             :     {"FM", 2, DCH_S_FM, SUFFTYPE_PREFIX},
     570             :     {"fm", 2, DCH_S_FM, SUFFTYPE_PREFIX},
     571             :     {"TM", TM_SUFFIX_LEN, DCH_S_TM, SUFFTYPE_PREFIX},
     572             :     {"tm", 2, DCH_S_TM, SUFFTYPE_PREFIX},
     573             :     {"TH", 2, DCH_S_TH, SUFFTYPE_POSTFIX},
     574             :     {"th", 2, DCH_S_th, SUFFTYPE_POSTFIX},
     575             :     {"SP", 2, DCH_S_SP, SUFFTYPE_POSTFIX},
     576             :     /* last */
     577             :     {NULL, 0, 0, 0}
     578             : };
     579             : 
     580             : 
     581             : /* ----------
     582             :  * Format-pictures (KeyWord).
     583             :  *
     584             :  * The KeyWord field; alphabetic sorted, *BUT* strings alike is sorted
     585             :  *        complicated -to-> easy:
     586             :  *
     587             :  *  (example: "DDD","DD","Day","D" )
     588             :  *
     589             :  * (this specific sort needs the algorithm for sequential search for strings,
     590             :  * which not has exact end; -> How keyword is in "HH12blabla" ? - "HH"
     591             :  * or "HH12"? You must first try "HH12", because "HH" is in string, but
     592             :  * it is not good.
     593             :  *
     594             :  * (!)
     595             :  *   - Position for the keyword is similar as position in the enum DCH/NUM_poz.
     596             :  * (!)
     597             :  *
     598             :  * For fast search is used the 'int index[]', index is ascii table from position
     599             :  * 32 (' ') to 126 (~), in this index is DCH_ / NUM_ enums for each ASCII
     600             :  * position or -1 if char is not used in the KeyWord. Search example for
     601             :  * string "MM":
     602             :  *  1)  see in index to index['M' - 32],
     603             :  *  2)  take keywords position (enum DCH_MI) from index
     604             :  *  3)  run sequential search in keywords[] from this position
     605             :  *
     606             :  * ----------
     607             :  */
     608             : 
     609             : typedef enum
     610             : {
     611             :     DCH_A_D,
     612             :     DCH_A_M,
     613             :     DCH_AD,
     614             :     DCH_AM,
     615             :     DCH_B_C,
     616             :     DCH_BC,
     617             :     DCH_CC,
     618             :     DCH_DAY,
     619             :     DCH_DDD,
     620             :     DCH_DD,
     621             :     DCH_DY,
     622             :     DCH_Day,
     623             :     DCH_Dy,
     624             :     DCH_D,
     625             :     DCH_FF1,
     626             :     DCH_FF2,
     627             :     DCH_FF3,
     628             :     DCH_FF4,
     629             :     DCH_FF5,
     630             :     DCH_FF6,
     631             :     DCH_FX,                     /* global suffix */
     632             :     DCH_HH24,
     633             :     DCH_HH12,
     634             :     DCH_HH,
     635             :     DCH_IDDD,
     636             :     DCH_ID,
     637             :     DCH_IW,
     638             :     DCH_IYYY,
     639             :     DCH_IYY,
     640             :     DCH_IY,
     641             :     DCH_I,
     642             :     DCH_J,
     643             :     DCH_MI,
     644             :     DCH_MM,
     645             :     DCH_MONTH,
     646             :     DCH_MON,
     647             :     DCH_MS,
     648             :     DCH_Month,
     649             :     DCH_Mon,
     650             :     DCH_OF,
     651             :     DCH_P_M,
     652             :     DCH_PM,
     653             :     DCH_Q,
     654             :     DCH_RM,
     655             :     DCH_SSSSS,
     656             :     DCH_SSSS,
     657             :     DCH_SS,
     658             :     DCH_TZH,
     659             :     DCH_TZM,
     660             :     DCH_TZ,
     661             :     DCH_US,
     662             :     DCH_WW,
     663             :     DCH_W,
     664             :     DCH_Y_YYY,
     665             :     DCH_YYYY,
     666             :     DCH_YYY,
     667             :     DCH_YY,
     668             :     DCH_Y,
     669             :     DCH_a_d,
     670             :     DCH_a_m,
     671             :     DCH_ad,
     672             :     DCH_am,
     673             :     DCH_b_c,
     674             :     DCH_bc,
     675             :     DCH_cc,
     676             :     DCH_day,
     677             :     DCH_ddd,
     678             :     DCH_dd,
     679             :     DCH_dy,
     680             :     DCH_d,
     681             :     DCH_ff1,
     682             :     DCH_ff2,
     683             :     DCH_ff3,
     684             :     DCH_ff4,
     685             :     DCH_ff5,
     686             :     DCH_ff6,
     687             :     DCH_fx,
     688             :     DCH_hh24,
     689             :     DCH_hh12,
     690             :     DCH_hh,
     691             :     DCH_iddd,
     692             :     DCH_id,
     693             :     DCH_iw,
     694             :     DCH_iyyy,
     695             :     DCH_iyy,
     696             :     DCH_iy,
     697             :     DCH_i,
     698             :     DCH_j,
     699             :     DCH_mi,
     700             :     DCH_mm,
     701             :     DCH_month,
     702             :     DCH_mon,
     703             :     DCH_ms,
     704             :     DCH_of,
     705             :     DCH_p_m,
     706             :     DCH_pm,
     707             :     DCH_q,
     708             :     DCH_rm,
     709             :     DCH_sssss,
     710             :     DCH_ssss,
     711             :     DCH_ss,
     712             :     DCH_tzh,
     713             :     DCH_tzm,
     714             :     DCH_tz,
     715             :     DCH_us,
     716             :     DCH_ww,
     717             :     DCH_w,
     718             :     DCH_y_yyy,
     719             :     DCH_yyyy,
     720             :     DCH_yyy,
     721             :     DCH_yy,
     722             :     DCH_y,
     723             : 
     724             :     /* last */
     725             :     _DCH_last_
     726             : }           DCH_poz;
     727             : 
     728             : typedef enum
     729             : {
     730             :     NUM_COMMA,
     731             :     NUM_DEC,
     732             :     NUM_0,
     733             :     NUM_9,
     734             :     NUM_B,
     735             :     NUM_C,
     736             :     NUM_D,
     737             :     NUM_E,
     738             :     NUM_FM,
     739             :     NUM_G,
     740             :     NUM_L,
     741             :     NUM_MI,
     742             :     NUM_PL,
     743             :     NUM_PR,
     744             :     NUM_RN,
     745             :     NUM_SG,
     746             :     NUM_SP,
     747             :     NUM_S,
     748             :     NUM_TH,
     749             :     NUM_V,
     750             :     NUM_b,
     751             :     NUM_c,
     752             :     NUM_d,
     753             :     NUM_e,
     754             :     NUM_fm,
     755             :     NUM_g,
     756             :     NUM_l,
     757             :     NUM_mi,
     758             :     NUM_pl,
     759             :     NUM_pr,
     760             :     NUM_rn,
     761             :     NUM_sg,
     762             :     NUM_sp,
     763             :     NUM_s,
     764             :     NUM_th,
     765             :     NUM_v,
     766             : 
     767             :     /* last */
     768             :     _NUM_last_
     769             : }           NUM_poz;
     770             : 
     771             : /* ----------
     772             :  * KeyWords for DATE-TIME version
     773             :  * ----------
     774             :  */
     775             : static const KeyWord DCH_keywords[] = {
     776             : /*  name, len, id, is_digit, date_mode */
     777             :     {"A.D.", 4, DCH_A_D, false, FROM_CHAR_DATE_NONE}, /* A */
     778             :     {"A.M.", 4, DCH_A_M, false, FROM_CHAR_DATE_NONE},
     779             :     {"AD", 2, DCH_AD, false, FROM_CHAR_DATE_NONE},
     780             :     {"AM", 2, DCH_AM, false, FROM_CHAR_DATE_NONE},
     781             :     {"B.C.", 4, DCH_B_C, false, FROM_CHAR_DATE_NONE}, /* B */
     782             :     {"BC", 2, DCH_BC, false, FROM_CHAR_DATE_NONE},
     783             :     {"CC", 2, DCH_CC, true, FROM_CHAR_DATE_NONE}, /* C */
     784             :     {"DAY", 3, DCH_DAY, false, FROM_CHAR_DATE_NONE},  /* D */
     785             :     {"DDD", 3, DCH_DDD, true, FROM_CHAR_DATE_GREGORIAN},
     786             :     {"DD", 2, DCH_DD, true, FROM_CHAR_DATE_GREGORIAN},
     787             :     {"DY", 2, DCH_DY, false, FROM_CHAR_DATE_NONE},
     788             :     {"Day", 3, DCH_Day, false, FROM_CHAR_DATE_NONE},
     789             :     {"Dy", 2, DCH_Dy, false, FROM_CHAR_DATE_NONE},
     790             :     {"D", 1, DCH_D, true, FROM_CHAR_DATE_GREGORIAN},
     791             :     {"FF1", 3, DCH_FF1, false, FROM_CHAR_DATE_NONE},  /* F */
     792             :     {"FF2", 3, DCH_FF2, false, FROM_CHAR_DATE_NONE},
     793             :     {"FF3", 3, DCH_FF3, false, FROM_CHAR_DATE_NONE},
     794             :     {"FF4", 3, DCH_FF4, false, FROM_CHAR_DATE_NONE},
     795             :     {"FF5", 3, DCH_FF5, false, FROM_CHAR_DATE_NONE},
     796             :     {"FF6", 3, DCH_FF6, false, FROM_CHAR_DATE_NONE},
     797             :     {"FX", 2, DCH_FX, false, FROM_CHAR_DATE_NONE},
     798             :     {"HH24", 4, DCH_HH24, true, FROM_CHAR_DATE_NONE}, /* H */
     799             :     {"HH12", 4, DCH_HH12, true, FROM_CHAR_DATE_NONE},
     800             :     {"HH", 2, DCH_HH, true, FROM_CHAR_DATE_NONE},
     801             :     {"IDDD", 4, DCH_IDDD, true, FROM_CHAR_DATE_ISOWEEK},  /* I */
     802             :     {"ID", 2, DCH_ID, true, FROM_CHAR_DATE_ISOWEEK},
     803             :     {"IW", 2, DCH_IW, true, FROM_CHAR_DATE_ISOWEEK},
     804             :     {"IYYY", 4, DCH_IYYY, true, FROM_CHAR_DATE_ISOWEEK},
     805             :     {"IYY", 3, DCH_IYY, true, FROM_CHAR_DATE_ISOWEEK},
     806             :     {"IY", 2, DCH_IY, true, FROM_CHAR_DATE_ISOWEEK},
     807             :     {"I", 1, DCH_I, true, FROM_CHAR_DATE_ISOWEEK},
     808             :     {"J", 1, DCH_J, true, FROM_CHAR_DATE_NONE}, /* J */
     809             :     {"MI", 2, DCH_MI, true, FROM_CHAR_DATE_NONE}, /* M */
     810             :     {"MM", 2, DCH_MM, true, FROM_CHAR_DATE_GREGORIAN},
     811             :     {"MONTH", 5, DCH_MONTH, false, FROM_CHAR_DATE_GREGORIAN},
     812             :     {"MON", 3, DCH_MON, false, FROM_CHAR_DATE_GREGORIAN},
     813             :     {"MS", 2, DCH_MS, true, FROM_CHAR_DATE_NONE},
     814             :     {"Month", 5, DCH_Month, false, FROM_CHAR_DATE_GREGORIAN},
     815             :     {"Mon", 3, DCH_Mon, false, FROM_CHAR_DATE_GREGORIAN},
     816             :     {"OF", 2, DCH_OF, false, FROM_CHAR_DATE_NONE},    /* O */
     817             :     {"P.M.", 4, DCH_P_M, false, FROM_CHAR_DATE_NONE}, /* P */
     818             :     {"PM", 2, DCH_PM, false, FROM_CHAR_DATE_NONE},
     819             :     {"Q", 1, DCH_Q, true, FROM_CHAR_DATE_NONE}, /* Q */
     820             :     {"RM", 2, DCH_RM, false, FROM_CHAR_DATE_GREGORIAN}, /* R */
     821             :     {"SSSSS", 5, DCH_SSSS, true, FROM_CHAR_DATE_NONE},    /* S */
     822             :     {"SSSS", 4, DCH_SSSS, true, FROM_CHAR_DATE_NONE},
     823             :     {"SS", 2, DCH_SS, true, FROM_CHAR_DATE_NONE},
     824             :     {"TZH", 3, DCH_TZH, false, FROM_CHAR_DATE_NONE},  /* T */
     825             :     {"TZM", 3, DCH_TZM, true, FROM_CHAR_DATE_NONE},
     826             :     {"TZ", 2, DCH_TZ, false, FROM_CHAR_DATE_NONE},
     827             :     {"US", 2, DCH_US, true, FROM_CHAR_DATE_NONE}, /* U */
     828             :     {"WW", 2, DCH_WW, true, FROM_CHAR_DATE_GREGORIAN},    /* W */
     829             :     {"W", 1, DCH_W, true, FROM_CHAR_DATE_GREGORIAN},
     830             :     {"Y,YYY", 5, DCH_Y_YYY, true, FROM_CHAR_DATE_GREGORIAN},  /* Y */
     831             :     {"YYYY", 4, DCH_YYYY, true, FROM_CHAR_DATE_GREGORIAN},
     832             :     {"YYY", 3, DCH_YYY, true, FROM_CHAR_DATE_GREGORIAN},
     833             :     {"YY", 2, DCH_YY, true, FROM_CHAR_DATE_GREGORIAN},
     834             :     {"Y", 1, DCH_Y, true, FROM_CHAR_DATE_GREGORIAN},
     835             :     {"a.d.", 4, DCH_a_d, false, FROM_CHAR_DATE_NONE}, /* a */
     836             :     {"a.m.", 4, DCH_a_m, false, FROM_CHAR_DATE_NONE},
     837             :     {"ad", 2, DCH_ad, false, FROM_CHAR_DATE_NONE},
     838             :     {"am", 2, DCH_am, false, FROM_CHAR_DATE_NONE},
     839             :     {"b.c.", 4, DCH_b_c, false, FROM_CHAR_DATE_NONE}, /* b */
     840             :     {"bc", 2, DCH_bc, false, FROM_CHAR_DATE_NONE},
     841             :     {"cc", 2, DCH_CC, true, FROM_CHAR_DATE_NONE}, /* c */
     842             :     {"day", 3, DCH_day, false, FROM_CHAR_DATE_NONE},  /* d */
     843             :     {"ddd", 3, DCH_DDD, true, FROM_CHAR_DATE_GREGORIAN},
     844             :     {"dd", 2, DCH_DD, true, FROM_CHAR_DATE_GREGORIAN},
     845             :     {"dy", 2, DCH_dy, false, FROM_CHAR_DATE_NONE},
     846             :     {"d", 1, DCH_D, true, FROM_CHAR_DATE_GREGORIAN},
     847             :     {"ff1", 3, DCH_FF1, false, FROM_CHAR_DATE_NONE},  /* f */
     848             :     {"ff2", 3, DCH_FF2, false, FROM_CHAR_DATE_NONE},
     849             :     {"ff3", 3, DCH_FF3, false, FROM_CHAR_DATE_NONE},
     850             :     {"ff4", 3, DCH_FF4, false, FROM_CHAR_DATE_NONE},
     851             :     {"ff5", 3, DCH_FF5, false, FROM_CHAR_DATE_NONE},
     852             :     {"ff6", 3, DCH_FF6, false, FROM_CHAR_DATE_NONE},
     853             :     {"fx", 2, DCH_FX, false, FROM_CHAR_DATE_NONE},
     854             :     {"hh24", 4, DCH_HH24, true, FROM_CHAR_DATE_NONE}, /* h */
     855             :     {"hh12", 4, DCH_HH12, true, FROM_CHAR_DATE_NONE},
     856             :     {"hh", 2, DCH_HH, true, FROM_CHAR_DATE_NONE},
     857             :     {"iddd", 4, DCH_IDDD, true, FROM_CHAR_DATE_ISOWEEK},  /* i */
     858             :     {"id", 2, DCH_ID, true, FROM_CHAR_DATE_ISOWEEK},
     859             :     {"iw", 2, DCH_IW, true, FROM_CHAR_DATE_ISOWEEK},
     860             :     {"iyyy", 4, DCH_IYYY, true, FROM_CHAR_DATE_ISOWEEK},
     861             :     {"iyy", 3, DCH_IYY, true, FROM_CHAR_DATE_ISOWEEK},
     862             :     {"iy", 2, DCH_IY, true, FROM_CHAR_DATE_ISOWEEK},
     863             :     {"i", 1, DCH_I, true, FROM_CHAR_DATE_ISOWEEK},
     864             :     {"j", 1, DCH_J, true, FROM_CHAR_DATE_NONE}, /* j */
     865             :     {"mi", 2, DCH_MI, true, FROM_CHAR_DATE_NONE}, /* m */
     866             :     {"mm", 2, DCH_MM, true, FROM_CHAR_DATE_GREGORIAN},
     867             :     {"month", 5, DCH_month, false, FROM_CHAR_DATE_GREGORIAN},
     868             :     {"mon", 3, DCH_mon, false, FROM_CHAR_DATE_GREGORIAN},
     869             :     {"ms", 2, DCH_MS, true, FROM_CHAR_DATE_NONE},
     870             :     {"of", 2, DCH_OF, false, FROM_CHAR_DATE_NONE},    /* o */
     871             :     {"p.m.", 4, DCH_p_m, false, FROM_CHAR_DATE_NONE}, /* p */
     872             :     {"pm", 2, DCH_pm, false, FROM_CHAR_DATE_NONE},
     873             :     {"q", 1, DCH_Q, true, FROM_CHAR_DATE_NONE}, /* q */
     874             :     {"rm", 2, DCH_rm, false, FROM_CHAR_DATE_GREGORIAN}, /* r */
     875             :     {"sssss", 5, DCH_SSSS, true, FROM_CHAR_DATE_NONE},    /* s */
     876             :     {"ssss", 4, DCH_SSSS, true, FROM_CHAR_DATE_NONE},
     877             :     {"ss", 2, DCH_SS, true, FROM_CHAR_DATE_NONE},
     878             :     {"tzh", 3, DCH_TZH, false, FROM_CHAR_DATE_NONE},  /* t */
     879             :     {"tzm", 3, DCH_TZM, true, FROM_CHAR_DATE_NONE},
     880             :     {"tz", 2, DCH_tz, false, FROM_CHAR_DATE_NONE},
     881             :     {"us", 2, DCH_US, true, FROM_CHAR_DATE_NONE}, /* u */
     882             :     {"ww", 2, DCH_WW, true, FROM_CHAR_DATE_GREGORIAN},    /* w */
     883             :     {"w", 1, DCH_W, true, FROM_CHAR_DATE_GREGORIAN},
     884             :     {"y,yyy", 5, DCH_Y_YYY, true, FROM_CHAR_DATE_GREGORIAN},  /* y */
     885             :     {"yyyy", 4, DCH_YYYY, true, FROM_CHAR_DATE_GREGORIAN},
     886             :     {"yyy", 3, DCH_YYY, true, FROM_CHAR_DATE_GREGORIAN},
     887             :     {"yy", 2, DCH_YY, true, FROM_CHAR_DATE_GREGORIAN},
     888             :     {"y", 1, DCH_Y, true, FROM_CHAR_DATE_GREGORIAN},
     889             : 
     890             :     /* last */
     891             :     {NULL, 0, 0, 0, 0}
     892             : };
     893             : 
     894             : /* ----------
     895             :  * KeyWords for NUMBER version
     896             :  *
     897             :  * The is_digit and date_mode fields are not relevant here.
     898             :  * ----------
     899             :  */
     900             : static const KeyWord NUM_keywords[] = {
     901             : /*  name, len, id           is in Index */
     902             :     {",", 1, NUM_COMMA},      /* , */
     903             :     {".", 1, NUM_DEC},            /* . */
     904             :     {"0", 1, NUM_0},          /* 0 */
     905             :     {"9", 1, NUM_9},          /* 9 */
     906             :     {"B", 1, NUM_B},          /* B */
     907             :     {"C", 1, NUM_C},          /* C */
     908             :     {"D", 1, NUM_D},          /* D */
     909             :     {"EEEE", 4, NUM_E},           /* E */
     910             :     {"FM", 2, NUM_FM},            /* F */
     911             :     {"G", 1, NUM_G},          /* G */
     912             :     {"L", 1, NUM_L},          /* L */
     913             :     {"MI", 2, NUM_MI},            /* M */
     914             :     {"PL", 2, NUM_PL},            /* P */
     915             :     {"PR", 2, NUM_PR},
     916             :     {"RN", 2, NUM_RN},            /* R */
     917             :     {"SG", 2, NUM_SG},            /* S */
     918             :     {"SP", 2, NUM_SP},
     919             :     {"S", 1, NUM_S},
     920             :     {"TH", 2, NUM_TH},            /* T */
     921             :     {"V", 1, NUM_V},          /* V */
     922             :     {"b", 1, NUM_B},          /* b */
     923             :     {"c", 1, NUM_C},          /* c */
     924             :     {"d", 1, NUM_D},          /* d */
     925             :     {"eeee", 4, NUM_E},           /* e */
     926             :     {"fm", 2, NUM_FM},            /* f */
     927             :     {"g", 1, NUM_G},          /* g */
     928             :     {"l", 1, NUM_L},          /* l */
     929             :     {"mi", 2, NUM_MI},            /* m */
     930             :     {"pl", 2, NUM_PL},            /* p */
     931             :     {"pr", 2, NUM_PR},
     932             :     {"rn", 2, NUM_rn},            /* r */
     933             :     {"sg", 2, NUM_SG},            /* s */
     934             :     {"sp", 2, NUM_SP},
     935             :     {"s", 1, NUM_S},
     936             :     {"th", 2, NUM_th},            /* t */
     937             :     {"v", 1, NUM_V},          /* v */
     938             : 
     939             :     /* last */
     940             :     {NULL, 0, 0}
     941             : };
     942             : 
     943             : 
     944             : /* ----------
     945             :  * KeyWords index for DATE-TIME version
     946             :  * ----------
     947             :  */
     948             : static const int DCH_index[KeyWord_INDEX_SIZE] = {
     949             : /*
     950             : 0   1   2   3   4   5   6   7   8   9
     951             : */
     952             :     /*---- first 0..31 chars are skipped ----*/
     953             : 
     954             :     -1, -1, -1, -1, -1, -1, -1, -1,
     955             :     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     956             :     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
     957             :     -1, -1, -1, -1, -1, DCH_A_D, DCH_B_C, DCH_CC, DCH_DAY, -1,
     958             :     DCH_FF1, -1, DCH_HH24, DCH_IDDD, DCH_J, -1, -1, DCH_MI, -1, DCH_OF,
     959             :     DCH_P_M, DCH_Q, DCH_RM, DCH_SSSSS, DCH_TZH, DCH_US, -1, DCH_WW, -1, DCH_Y_YYY,
     960             :     -1, -1, -1, -1, -1, -1, -1, DCH_a_d, DCH_b_c, DCH_cc,
     961             :     DCH_day, -1, DCH_ff1, -1, DCH_hh24, DCH_iddd, DCH_j, -1, -1, DCH_mi,
     962             :     -1, DCH_of, DCH_p_m, DCH_q, DCH_rm, DCH_sssss, DCH_tzh, DCH_us, -1, DCH_ww,
     963             :     -1, DCH_y_yyy, -1, -1, -1, -1
     964             : 
     965             :     /*---- chars over 126 are skipped ----*/
     966             : };
     967             : 
     968             : /* ----------
     969             :  * KeyWords index for NUMBER version
     970             :  * ----------
     971             :  */
     972             : static const int NUM_index[KeyWord_INDEX_SIZE] = {
     973             : /*
     974             : 0   1   2   3   4   5   6   7   8   9
     975             : */
     976             :     /*---- first 0..31 chars are skipped ----*/
     977             : 
     978             :     -1, -1, -1, -1, -1, -1, -1, -1,
     979             :     -1, -1, -1, -1, NUM_COMMA, -1, NUM_DEC, -1, NUM_0, -1,
     980             :     -1, -1, -1, -1, -1, -1, -1, NUM_9, -1, -1,
     981             :     -1, -1, -1, -1, -1, -1, NUM_B, NUM_C, NUM_D, NUM_E,
     982             :     NUM_FM, NUM_G, -1, -1, -1, -1, NUM_L, NUM_MI, -1, -1,
     983             :     NUM_PL, -1, NUM_RN, NUM_SG, NUM_TH, -1, NUM_V, -1, -1, -1,
     984             :     -1, -1, -1, -1, -1, -1, -1, -1, NUM_b, NUM_c,
     985             :     NUM_d, NUM_e, NUM_fm, NUM_g, -1, -1, -1, -1, NUM_l, NUM_mi,
     986             :     -1, -1, NUM_pl, -1, NUM_rn, NUM_sg, NUM_th, -1, NUM_v, -1,
     987             :     -1, -1, -1, -1, -1, -1
     988             : 
     989             :     /*---- chars over 126 are skipped ----*/
     990             : };
     991             : 
     992             : /* ----------
     993             :  * Number processor struct
     994             :  * ----------
     995             :  */
     996             : typedef struct NUMProc
     997             : {
     998             :     bool        is_to_char;
     999             :     NUMDesc    *Num;            /* number description       */
    1000             : 
    1001             :     int         sign,           /* '-' or '+'           */
    1002             :                 sign_wrote,     /* was sign write       */
    1003             :                 num_count,      /* number of write digits   */
    1004             :                 num_in,         /* is inside number     */
    1005             :                 num_curr,       /* current position in number   */
    1006             :                 out_pre_spaces, /* spaces before first digit    */
    1007             : 
    1008             :                 read_dec,       /* to_number - was read dec. point  */
    1009             :                 read_post,      /* to_number - number of dec. digit */
    1010             :                 read_pre;       /* to_number - number non-dec. digit */
    1011             : 
    1012             :     char       *number,         /* string with number   */
    1013             :                *number_p,       /* pointer to current number position */
    1014             :                *inout,          /* in / out buffer  */
    1015             :                *inout_p,        /* pointer to current inout position */
    1016             :                *last_relevant,  /* last relevant number after decimal point */
    1017             : 
    1018             :                *L_negative_sign,    /* Locale */
    1019             :                *L_positive_sign,
    1020             :                *decimal,
    1021             :                *L_thousands_sep,
    1022             :                *L_currency_symbol;
    1023             : } NUMProc;
    1024             : 
    1025             : /* Return flags for DCH_from_char() */
    1026             : #define DCH_DATED   0x01
    1027             : #define DCH_TIMED   0x02
    1028             : #define DCH_ZONED   0x04
    1029             : 
    1030             : /* ----------
    1031             :  * Functions
    1032             :  * ----------
    1033             :  */
    1034             : static const KeyWord *index_seq_search(const char *str, const KeyWord *kw,
    1035             :                                        const int *index);
    1036             : static const KeySuffix *suff_search(const char *str, const KeySuffix *suf, int type);
    1037             : static bool is_separator_char(const char *str);
    1038             : static void NUMDesc_prepare(NUMDesc *num, FormatNode *n);
    1039             : static void parse_format(FormatNode *node, const char *str, const KeyWord *kw,
    1040             :                          const KeySuffix *suf, const int *index, uint32 flags, NUMDesc *Num);
    1041             : 
    1042             : static void DCH_to_char(FormatNode *node, bool is_interval,
    1043             :                         TmToChar *in, char *out, Oid collid);
    1044             : static void DCH_from_char(FormatNode *node, const char *in, TmFromChar *out,
    1045             :                           Oid collid, bool std, Node *escontext);
    1046             : 
    1047             : #ifdef DEBUG_TO_FROM_CHAR
    1048             : static void dump_index(const KeyWord *k, const int *index);
    1049             : static void dump_node(FormatNode *node, int max);
    1050             : #endif
    1051             : 
    1052             : static const char *get_th(char *num, int type);
    1053             : static char *str_numth(char *dest, char *num, int type);
    1054             : static int  adjust_partial_year_to_2020(int year);
    1055             : static int  strspace_len(const char *str);
    1056             : static bool from_char_set_mode(TmFromChar *tmfc, const FromCharDateMode mode,
    1057             :                                Node *escontext);
    1058             : static bool from_char_set_int(int *dest, const int value, const FormatNode *node,
    1059             :                               Node *escontext);
    1060             : static int  from_char_parse_int_len(int *dest, const char **src, const int len,
    1061             :                                     FormatNode *node, Node *escontext);
    1062             : static int  from_char_parse_int(int *dest, const char **src, FormatNode *node,
    1063             :                                 Node *escontext);
    1064             : static int  seq_search_ascii(const char *name, const char *const *array, int *len);
    1065             : static int  seq_search_localized(const char *name, char **array, int *len,
    1066             :                                  Oid collid);
    1067             : static bool from_char_seq_search(int *dest, const char **src,
    1068             :                                  const char *const *array,
    1069             :                                  char **localized_array, Oid collid,
    1070             :                                  FormatNode *node, Node *escontext);
    1071             : static bool do_to_timestamp(text *date_txt, text *fmt, Oid collid, bool std,
    1072             :                             struct pg_tm *tm, fsec_t *fsec, struct fmt_tz *tz,
    1073             :                             int *fprec, uint32 *flags, Node *escontext);
    1074             : static char *fill_str(char *str, int c, int max);
    1075             : static FormatNode *NUM_cache(int len, NUMDesc *Num, text *pars_str, bool *shouldFree);
    1076             : static char *int_to_roman(int number);
    1077             : static void NUM_prepare_locale(NUMProc *Np);
    1078             : static char *get_last_relevant_decnum(char *num);
    1079             : static void NUM_numpart_from_char(NUMProc *Np, int id, int input_len);
    1080             : static void NUM_numpart_to_char(NUMProc *Np, int id);
    1081             : static char *NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
    1082             :                            char *number, int input_len, int to_char_out_pre_spaces,
    1083             :                            int sign, bool is_to_char, Oid collid);
    1084             : static DCHCacheEntry *DCH_cache_getnew(const char *str, bool std);
    1085             : static DCHCacheEntry *DCH_cache_search(const char *str, bool std);
    1086             : static DCHCacheEntry *DCH_cache_fetch(const char *str, bool std);
    1087             : static NUMCacheEntry *NUM_cache_getnew(const char *str);
    1088             : static NUMCacheEntry *NUM_cache_search(const char *str);
    1089             : static NUMCacheEntry *NUM_cache_fetch(const char *str);
    1090             : 
    1091             : 
    1092             : /* ----------
    1093             :  * Fast sequential search, use index for data selection which
    1094             :  * go to seq. cycle (it is very fast for unwanted strings)
    1095             :  * (can't be used binary search in format parsing)
    1096             :  * ----------
    1097             :  */
    1098             : static const KeyWord *
    1099       26822 : index_seq_search(const char *str, const KeyWord *kw, const int *index)
    1100             : {
    1101             :     int         poz;
    1102             : 
    1103       26822 :     if (!KeyWord_INDEX_FILTER(*str))
    1104        6568 :         return NULL;
    1105             : 
    1106       20254 :     if ((poz = *(index + (*str - ' '))) > -1)
    1107             :     {
    1108       18182 :         const KeyWord *k = kw + poz;
    1109             : 
    1110             :         do
    1111             :         {
    1112       24852 :             if (strncmp(str, k->name, k->len) == 0)
    1113       18050 :                 return k;
    1114        6802 :             k++;
    1115        6802 :             if (!k->name)
    1116           0 :                 return NULL;
    1117        6802 :         } while (*str == *k->name);
    1118             :     }
    1119        2204 :     return NULL;
    1120             : }
    1121             : 
    1122             : static const KeySuffix *
    1123       10988 : suff_search(const char *str, const KeySuffix *suf, int type)
    1124             : {
    1125             :     const KeySuffix *s;
    1126             : 
    1127       85036 :     for (s = suf; s->name != NULL; s++)
    1128             :     {
    1129       74486 :         if (s->type != type)
    1130       35112 :             continue;
    1131             : 
    1132       39374 :         if (strncmp(str, s->name, s->len) == 0)
    1133         438 :             return s;
    1134             :     }
    1135       10550 :     return NULL;
    1136             : }
    1137             : 
    1138             : static bool
    1139        6438 : is_separator_char(const char *str)
    1140             : {
    1141             :     /* ASCII printable character, but not letter or digit */
    1142        4784 :     return (*str > 0x20 && *str < 0x7F &&
    1143        4784 :             !(*str >= 'A' && *str <= 'Z') &&
    1144       15724 :             !(*str >= 'a' && *str <= 'z') &&
    1145        4502 :             !(*str >= '0' && *str <= '9'));
    1146             : }
    1147             : 
    1148             : /* ----------
    1149             :  * Prepare NUMDesc (number description struct) via FormatNode struct
    1150             :  * ----------
    1151             :  */
    1152             : static void
    1153       13890 : NUMDesc_prepare(NUMDesc *num, FormatNode *n)
    1154             : {
    1155       13890 :     if (n->type != NODE_TYPE_ACTION)
    1156           0 :         return;
    1157             : 
    1158       13890 :     if (IS_EEEE(num) && n->key->id != NUM_E)
    1159           0 :         ereport(ERROR,
    1160             :                 (errcode(ERRCODE_SYNTAX_ERROR),
    1161             :                  errmsg("\"EEEE\" must be the last pattern used")));
    1162             : 
    1163       13890 :     switch (n->key->id)
    1164             :     {
    1165       12102 :         case NUM_9:
    1166       12102 :             if (IS_BRACKET(num))
    1167           0 :                 ereport(ERROR,
    1168             :                         (errcode(ERRCODE_SYNTAX_ERROR),
    1169             :                          errmsg("\"9\" must be ahead of \"PR\"")));
    1170       12102 :             if (IS_MULTI(num))
    1171             :             {
    1172           0 :                 ++num->multi;
    1173           0 :                 break;
    1174             :             }
    1175       12102 :             if (IS_DECIMAL(num))
    1176        4076 :                 ++num->post;
    1177             :             else
    1178        8026 :                 ++num->pre;
    1179       12102 :             break;
    1180             : 
    1181         520 :         case NUM_0:
    1182         520 :             if (IS_BRACKET(num))
    1183           0 :                 ereport(ERROR,
    1184             :                         (errcode(ERRCODE_SYNTAX_ERROR),
    1185             :                          errmsg("\"0\" must be ahead of \"PR\"")));
    1186         520 :             if (!IS_ZERO(num) && !IS_DECIMAL(num))
    1187             :             {
    1188         110 :                 num->flag |= NUM_F_ZERO;
    1189         110 :                 num->zero_start = num->pre + 1;
    1190             :             }
    1191         520 :             if (!IS_DECIMAL(num))
    1192         352 :                 ++num->pre;
    1193             :             else
    1194         168 :                 ++num->post;
    1195             : 
    1196         520 :             num->zero_end = num->pre + num->post;
    1197         520 :             break;
    1198             : 
    1199           0 :         case NUM_B:
    1200           0 :             if (num->pre == 0 && num->post == 0 && (!IS_ZERO(num)))
    1201           0 :                 num->flag |= NUM_F_BLANK;
    1202           0 :             break;
    1203             : 
    1204          36 :         case NUM_D:
    1205          36 :             num->flag |= NUM_F_LDECIMAL;
    1206          36 :             num->need_locale = true;
    1207             :             /* FALLTHROUGH */
    1208         396 :         case NUM_DEC:
    1209         396 :             if (IS_DECIMAL(num))
    1210           0 :                 ereport(ERROR,
    1211             :                         (errcode(ERRCODE_SYNTAX_ERROR),
    1212             :                          errmsg("multiple decimal points")));
    1213         396 :             if (IS_MULTI(num))
    1214           0 :                 ereport(ERROR,
    1215             :                         (errcode(ERRCODE_SYNTAX_ERROR),
    1216             :                          errmsg("cannot use \"V\" and decimal point together")));
    1217         396 :             num->flag |= NUM_F_DECIMAL;
    1218         396 :             break;
    1219             : 
    1220         242 :         case NUM_FM:
    1221         242 :             num->flag |= NUM_F_FILLMODE;
    1222         242 :             break;
    1223             : 
    1224         202 :         case NUM_S:
    1225         202 :             if (IS_LSIGN(num))
    1226           0 :                 ereport(ERROR,
    1227             :                         (errcode(ERRCODE_SYNTAX_ERROR),
    1228             :                          errmsg("cannot use \"S\" twice")));
    1229         202 :             if (IS_PLUS(num) || IS_MINUS(num) || IS_BRACKET(num))
    1230           0 :                 ereport(ERROR,
    1231             :                         (errcode(ERRCODE_SYNTAX_ERROR),
    1232             :                          errmsg("cannot use \"S\" and \"PL\"/\"MI\"/\"SG\"/\"PR\" together")));
    1233         202 :             if (!IS_DECIMAL(num))
    1234             :             {
    1235         168 :                 num->lsign = NUM_LSIGN_PRE;
    1236         168 :                 num->pre_lsign_num = num->pre;
    1237         168 :                 num->need_locale = true;
    1238         168 :                 num->flag |= NUM_F_LSIGN;
    1239             :             }
    1240          34 :             else if (num->lsign == NUM_LSIGN_NONE)
    1241             :             {
    1242          34 :                 num->lsign = NUM_LSIGN_POST;
    1243          34 :                 num->need_locale = true;
    1244          34 :                 num->flag |= NUM_F_LSIGN;
    1245             :             }
    1246         202 :             break;
    1247             : 
    1248          30 :         case NUM_MI:
    1249          30 :             if (IS_LSIGN(num))
    1250           0 :                 ereport(ERROR,
    1251             :                         (errcode(ERRCODE_SYNTAX_ERROR),
    1252             :                          errmsg("cannot use \"S\" and \"MI\" together")));
    1253          30 :             num->flag |= NUM_F_MINUS;
    1254          30 :             if (IS_DECIMAL(num))
    1255           6 :                 num->flag |= NUM_F_MINUS_POST;
    1256          30 :             break;
    1257             : 
    1258           0 :         case NUM_PL:
    1259           0 :             if (IS_LSIGN(num))
    1260           0 :                 ereport(ERROR,
    1261             :                         (errcode(ERRCODE_SYNTAX_ERROR),
    1262             :                          errmsg("cannot use \"S\" and \"PL\" together")));
    1263           0 :             num->flag |= NUM_F_PLUS;
    1264           0 :             if (IS_DECIMAL(num))
    1265           0 :                 num->flag |= NUM_F_PLUS_POST;
    1266           0 :             break;
    1267             : 
    1268          24 :         case NUM_SG:
    1269          24 :             if (IS_LSIGN(num))
    1270           0 :                 ereport(ERROR,
    1271             :                         (errcode(ERRCODE_SYNTAX_ERROR),
    1272             :                          errmsg("cannot use \"S\" and \"SG\" together")));
    1273          24 :             num->flag |= NUM_F_MINUS;
    1274          24 :             num->flag |= NUM_F_PLUS;
    1275          24 :             break;
    1276             : 
    1277          36 :         case NUM_PR:
    1278          36 :             if (IS_LSIGN(num) || IS_PLUS(num) || IS_MINUS(num))
    1279           0 :                 ereport(ERROR,
    1280             :                         (errcode(ERRCODE_SYNTAX_ERROR),
    1281             :                          errmsg("cannot use \"PR\" and \"S\"/\"PL\"/\"MI\"/\"SG\" together")));
    1282          36 :             num->flag |= NUM_F_BRACKET;
    1283          36 :             break;
    1284             : 
    1285           0 :         case NUM_rn:
    1286             :         case NUM_RN:
    1287           0 :             num->flag |= NUM_F_ROMAN;
    1288           0 :             break;
    1289             : 
    1290         218 :         case NUM_L:
    1291             :         case NUM_G:
    1292         218 :             num->need_locale = true;
    1293         218 :             break;
    1294             : 
    1295           0 :         case NUM_V:
    1296           0 :             if (IS_DECIMAL(num))
    1297           0 :                 ereport(ERROR,
    1298             :                         (errcode(ERRCODE_SYNTAX_ERROR),
    1299             :                          errmsg("cannot use \"V\" and decimal point together")));
    1300           0 :             num->flag |= NUM_F_MULTI;
    1301           0 :             break;
    1302             : 
    1303           6 :         case NUM_E:
    1304           6 :             if (IS_EEEE(num))
    1305           0 :                 ereport(ERROR,
    1306             :                         (errcode(ERRCODE_SYNTAX_ERROR),
    1307             :                          errmsg("cannot use \"EEEE\" twice")));
    1308           6 :             if (IS_BLANK(num) || IS_FILLMODE(num) || IS_LSIGN(num) ||
    1309           6 :                 IS_BRACKET(num) || IS_MINUS(num) || IS_PLUS(num) ||
    1310           6 :                 IS_ROMAN(num) || IS_MULTI(num))
    1311           0 :                 ereport(ERROR,
    1312             :                         (errcode(ERRCODE_SYNTAX_ERROR),
    1313             :                          errmsg("\"EEEE\" is incompatible with other formats"),
    1314             :                          errdetail("\"EEEE\" may only be used together with digit and decimal point patterns.")));
    1315           6 :             num->flag |= NUM_F_EEEE;
    1316           6 :             break;
    1317             :     }
    1318             : }
    1319             : 
    1320             : /* ----------
    1321             :  * Format parser, search small keywords and keyword's suffixes, and make
    1322             :  * format-node tree.
    1323             :  *
    1324             :  * for DATE-TIME & NUMBER version
    1325             :  * ----------
    1326             :  */
    1327             : static void
    1328        1598 : parse_format(FormatNode *node, const char *str, const KeyWord *kw,
    1329             :              const KeySuffix *suf, const int *index, uint32 flags, NUMDesc *Num)
    1330             : {
    1331             :     FormatNode *n;
    1332             : 
    1333             : #ifdef DEBUG_TO_FROM_CHAR
    1334             :     elog(DEBUG_elog_output, "to_char/number(): run parser");
    1335             : #endif
    1336             : 
    1337        1598 :     n = node;
    1338             : 
    1339       28414 :     while (*str)
    1340             :     {
    1341       26822 :         int         suffix = 0;
    1342             :         const KeySuffix *s;
    1343             : 
    1344             :         /*
    1345             :          * Prefix
    1346             :          */
    1347       34474 :         if ((flags & DCH_FLAG) &&
    1348        7652 :             (s = suff_search(str, suf, SUFFTYPE_PREFIX)) != NULL)
    1349             :         {
    1350         396 :             suffix |= s->id;
    1351         396 :             if (s->len)
    1352         396 :                 str += s->len;
    1353             :         }
    1354             : 
    1355             :         /*
    1356             :          * Keyword
    1357             :          */
    1358       26822 :         if (*str && (n->key = index_seq_search(str, kw, index)) != NULL)
    1359             :         {
    1360       18050 :             n->type = NODE_TYPE_ACTION;
    1361       18050 :             n->suffix = suffix;
    1362       18050 :             if (n->key->len)
    1363       18050 :                 str += n->key->len;
    1364             : 
    1365             :             /*
    1366             :              * NUM version: Prepare global NUMDesc struct
    1367             :              */
    1368       18050 :             if (flags & NUM_FLAG)
    1369       13890 :                 NUMDesc_prepare(Num, n);
    1370             : 
    1371             :             /*
    1372             :              * Postfix
    1373             :              */
    1374       21386 :             if ((flags & DCH_FLAG) && *str &&
    1375        3336 :                 (s = suff_search(str, suf, SUFFTYPE_POSTFIX)) != NULL)
    1376             :             {
    1377          42 :                 n->suffix |= s->id;
    1378          42 :                 if (s->len)
    1379          42 :                     str += s->len;
    1380             :             }
    1381             : 
    1382       18050 :             n++;
    1383             :         }
    1384        8772 :         else if (*str)
    1385             :         {
    1386             :             int         chlen;
    1387             : 
    1388        8772 :             if ((flags & STD_FLAG) && *str != '"')
    1389             :             {
    1390             :                 /*
    1391             :                  * Standard mode, allow only following separators: "-./,':; ".
    1392             :                  * However, we support double quotes even in standard mode
    1393             :                  * (see below).  This is our extension of standard mode.
    1394             :                  */
    1395         570 :                 if (strchr("-./,':; ", *str) == NULL)
    1396           6 :                     ereport(ERROR,
    1397             :                             (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    1398             :                              errmsg("invalid datetime format separator: \"%s\"",
    1399             :                                     pnstrdup(str, pg_mblen(str)))));
    1400             : 
    1401         564 :                 if (*str == ' ')
    1402          90 :                     n->type = NODE_TYPE_SPACE;
    1403             :                 else
    1404         474 :                     n->type = NODE_TYPE_SEPARATOR;
    1405             : 
    1406         564 :                 n->character[0] = *str;
    1407         564 :                 n->character[1] = '\0';
    1408         564 :                 n->key = NULL;
    1409         564 :                 n->suffix = 0;
    1410         564 :                 n++;
    1411         564 :                 str++;
    1412             :             }
    1413        8202 :             else if (*str == '"')
    1414             :             {
    1415             :                 /*
    1416             :                  * Process double-quoted literal string, if any
    1417             :                  */
    1418         384 :                 str++;
    1419        4416 :                 while (*str)
    1420             :                 {
    1421        4410 :                     if (*str == '"')
    1422             :                     {
    1423         378 :                         str++;
    1424         378 :                         break;
    1425             :                     }
    1426             :                     /* backslash quotes the next character, if any */
    1427        4032 :                     if (*str == '\\' && *(str + 1))
    1428         240 :                         str++;
    1429        4032 :                     chlen = pg_mblen(str);
    1430        4032 :                     n->type = NODE_TYPE_CHAR;
    1431        4032 :                     memcpy(n->character, str, chlen);
    1432        4032 :                     n->character[chlen] = '\0';
    1433        4032 :                     n->key = NULL;
    1434        4032 :                     n->suffix = 0;
    1435        4032 :                     n++;
    1436        4032 :                     str += chlen;
    1437             :                 }
    1438             :             }
    1439             :             else
    1440             :             {
    1441             :                 /*
    1442             :                  * Outside double-quoted strings, backslash is only special if
    1443             :                  * it immediately precedes a double quote.
    1444             :                  */
    1445        7818 :                 if (*str == '\\' && *(str + 1) == '"')
    1446          12 :                     str++;
    1447        7818 :                 chlen = pg_mblen(str);
    1448             : 
    1449        7818 :                 if ((flags & DCH_FLAG) && is_separator_char(str))
    1450        1052 :                     n->type = NODE_TYPE_SEPARATOR;
    1451        6766 :                 else if (isspace((unsigned char) *str))
    1452        6478 :                     n->type = NODE_TYPE_SPACE;
    1453             :                 else
    1454         288 :                     n->type = NODE_TYPE_CHAR;
    1455             : 
    1456        7818 :                 memcpy(n->character, str, chlen);
    1457        7818 :                 n->character[chlen] = '\0';
    1458        7818 :                 n->key = NULL;
    1459        7818 :                 n->suffix = 0;
    1460        7818 :                 n++;
    1461        7818 :                 str += chlen;
    1462             :             }
    1463             :         }
    1464             :     }
    1465             : 
    1466        1592 :     n->type = NODE_TYPE_END;
    1467        1592 :     n->suffix = 0;
    1468        1592 : }
    1469             : 
    1470             : /* ----------
    1471             :  * DEBUG: Dump the FormatNode Tree (debug)
    1472             :  * ----------
    1473             :  */
    1474             : #ifdef DEBUG_TO_FROM_CHAR
    1475             : 
    1476             : #define DUMP_THth(_suf) (S_TH(_suf) ? "TH" : (S_th(_suf) ? "th" : " "))
    1477             : #define DUMP_FM(_suf)   (S_FM(_suf) ? "FM" : " ")
    1478             : 
    1479             : static void
    1480             : dump_node(FormatNode *node, int max)
    1481             : {
    1482             :     FormatNode *n;
    1483             :     int         a;
    1484             : 
    1485             :     elog(DEBUG_elog_output, "to_from-char(): DUMP FORMAT");
    1486             : 
    1487             :     for (a = 0, n = node; a <= max; n++, a++)
    1488             :     {
    1489             :         if (n->type == NODE_TYPE_ACTION)
    1490             :             elog(DEBUG_elog_output, "%d:\t NODE_TYPE_ACTION '%s'\t(%s,%s)",
    1491             :                  a, n->key->name, DUMP_THth(n->suffix), DUMP_FM(n->suffix));
    1492             :         else if (n->type == NODE_TYPE_CHAR)
    1493             :             elog(DEBUG_elog_output, "%d:\t NODE_TYPE_CHAR '%s'",
    1494             :                  a, n->character);
    1495             :         else if (n->type == NODE_TYPE_END)
    1496             :         {
    1497             :             elog(DEBUG_elog_output, "%d:\t NODE_TYPE_END", a);
    1498             :             return;
    1499             :         }
    1500             :         else
    1501             :             elog(DEBUG_elog_output, "%d:\t unknown NODE!", a);
    1502             :     }
    1503             : }
    1504             : #endif                          /* DEBUG */
    1505             : 
    1506             : /*****************************************************************************
    1507             :  *          Private utils
    1508             :  *****************************************************************************/
    1509             : 
    1510             : /* ----------
    1511             :  * Return ST/ND/RD/TH for simple (1..9) numbers
    1512             :  * type --> 0 upper, 1 lower
    1513             :  * ----------
    1514             :  */
    1515             : static const char *
    1516        2334 : get_th(char *num, int type)
    1517             : {
    1518        2334 :     int         len = strlen(num),
    1519             :                 last;
    1520             : 
    1521        2334 :     last = *(num + (len - 1));
    1522        2334 :     if (!isdigit((unsigned char) last))
    1523           0 :         ereport(ERROR,
    1524             :                 (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
    1525             :                  errmsg("\"%s\" is not a number", num)));
    1526             : 
    1527             :     /*
    1528             :      * All "teens" (<x>1[0-9]) get 'TH/th', while <x>[02-9][123] still get
    1529             :      * 'ST/st', 'ND/nd', 'RD/rd', respectively
    1530             :      */
    1531        2334 :     if ((len > 1) && (num[len - 2] == '1'))
    1532         132 :         last = 0;
    1533             : 
    1534        2334 :     switch (last)
    1535             :     {
    1536          96 :         case '1':
    1537          96 :             if (type == TH_UPPER)
    1538          24 :                 return numTH[0];
    1539          72 :             return numth[0];
    1540          48 :         case '2':
    1541          48 :             if (type == TH_UPPER)
    1542           0 :                 return numTH[1];
    1543          48 :             return numth[1];
    1544          36 :         case '3':
    1545          36 :             if (type == TH_UPPER)
    1546           6 :                 return numTH[2];
    1547          30 :             return numth[2];
    1548        2154 :         default:
    1549        2154 :             if (type == TH_UPPER)
    1550         756 :                 return numTH[3];
    1551        1398 :             return numth[3];
    1552             :     }
    1553             : }
    1554             : 
    1555             : /* ----------
    1556             :  * Convert string-number to ordinal string-number
    1557             :  * type --> 0 upper, 1 lower
    1558             :  * ----------
    1559             :  */
    1560             : static char *
    1561        2286 : str_numth(char *dest, char *num, int type)
    1562             : {
    1563        2286 :     if (dest != num)
    1564           0 :         strcpy(dest, num);
    1565        2286 :     strcat(dest, get_th(num, type));
    1566        2286 :     return dest;
    1567             : }
    1568             : 
    1569             : /*****************************************************************************
    1570             :  *          upper/lower/initcap functions
    1571             :  *****************************************************************************/
    1572             : 
    1573             : #ifdef USE_ICU
    1574             : 
    1575             : typedef int32_t (*ICU_Convert_Func) (UChar *dest, int32_t destCapacity,
    1576             :                                      const UChar *src, int32_t srcLength,
    1577             :                                      const char *locale,
    1578             :                                      UErrorCode *pErrorCode);
    1579             : 
    1580             : static int32_t
    1581         516 : icu_convert_case(ICU_Convert_Func func, pg_locale_t mylocale,
    1582             :                  UChar **buff_dest, UChar *buff_source, int32_t len_source)
    1583             : {
    1584             :     UErrorCode  status;
    1585             :     int32_t     len_dest;
    1586             : 
    1587         516 :     len_dest = len_source;      /* try first with same length */
    1588         516 :     *buff_dest = palloc(len_dest * sizeof(**buff_dest));
    1589         516 :     status = U_ZERO_ERROR;
    1590         516 :     len_dest = func(*buff_dest, len_dest, buff_source, len_source,
    1591             :                     mylocale->info.icu.locale, &status);
    1592         516 :     if (status == U_BUFFER_OVERFLOW_ERROR)
    1593             :     {
    1594             :         /* try again with adjusted length */
    1595           0 :         pfree(*buff_dest);
    1596           0 :         *buff_dest = palloc(len_dest * sizeof(**buff_dest));
    1597           0 :         status = U_ZERO_ERROR;
    1598           0 :         len_dest = func(*buff_dest, len_dest, buff_source, len_source,
    1599             :                         mylocale->info.icu.locale, &status);
    1600             :     }
    1601         516 :     if (U_FAILURE(status))
    1602           0 :         ereport(ERROR,
    1603             :                 (errmsg("case conversion failed: %s", u_errorName(status))));
    1604         516 :     return len_dest;
    1605             : }
    1606             : 
    1607             : static int32_t
    1608          24 : u_strToTitle_default_BI(UChar *dest, int32_t destCapacity,
    1609             :                         const UChar *src, int32_t srcLength,
    1610             :                         const char *locale,
    1611             :                         UErrorCode *pErrorCode)
    1612             : {
    1613          24 :     return u_strToTitle(dest, destCapacity, src, srcLength,
    1614             :                         NULL, locale, pErrorCode);
    1615             : }
    1616             : 
    1617             : #endif                          /* USE_ICU */
    1618             : 
    1619             : /*
    1620             :  * If the system provides the needed functions for wide-character manipulation
    1621             :  * (which are all standardized by C99), then we implement upper/lower/initcap
    1622             :  * using wide-character functions, if necessary.  Otherwise we use the
    1623             :  * traditional <ctype.h> functions, which of course will not work as desired
    1624             :  * in multibyte character sets.  Note that in either case we are effectively
    1625             :  * assuming that the database character encoding matches the encoding implied
    1626             :  * by LC_CTYPE.
    1627             :  */
    1628             : 
    1629             : /*
    1630             :  * collation-aware, wide-character-aware lower function
    1631             :  *
    1632             :  * We pass the number of bytes so we can pass varlena and char*
    1633             :  * to this function.  The result is a palloc'd, null-terminated string.
    1634             :  */
    1635             : char *
    1636      183546 : str_tolower(const char *buff, size_t nbytes, Oid collid)
    1637             : {
    1638             :     char       *result;
    1639             : 
    1640      183546 :     if (!buff)
    1641           0 :         return NULL;
    1642             : 
    1643      183546 :     if (!OidIsValid(collid))
    1644             :     {
    1645             :         /*
    1646             :          * This typically means that the parser could not resolve a conflict
    1647             :          * of implicit collations, so report it that way.
    1648             :          */
    1649           0 :         ereport(ERROR,
    1650             :                 (errcode(ERRCODE_INDETERMINATE_COLLATION),
    1651             :                  errmsg("could not determine which collation to use for %s function",
    1652             :                         "lower()"),
    1653             :                  errhint("Use the COLLATE clause to set the collation explicitly.")));
    1654             :     }
    1655             : 
    1656             :     /* C/POSIX collations use this path regardless of database encoding */
    1657      183546 :     if (lc_ctype_is_c(collid))
    1658             :     {
    1659       32654 :         result = asc_tolower(buff, nbytes);
    1660             :     }
    1661             :     else
    1662             :     {
    1663             :         pg_locale_t mylocale;
    1664             : 
    1665      150892 :         mylocale = pg_newlocale_from_collation(collid);
    1666             : 
    1667             : #ifdef USE_ICU
    1668      150892 :         if (mylocale && mylocale->provider == COLLPROVIDER_ICU)
    1669         468 :         {
    1670             :             int32_t     len_uchar;
    1671             :             int32_t     len_conv;
    1672             :             UChar      *buff_uchar;
    1673             :             UChar      *buff_conv;
    1674             : 
    1675         468 :             len_uchar = icu_to_uchar(&buff_uchar, buff, nbytes);
    1676         468 :             len_conv = icu_convert_case(u_strToLower, mylocale,
    1677             :                                         &buff_conv, buff_uchar, len_uchar);
    1678         468 :             icu_from_uchar(&result, buff_conv, len_conv);
    1679         468 :             pfree(buff_uchar);
    1680         468 :             pfree(buff_conv);
    1681             :         }
    1682             :         else
    1683             : #endif
    1684      150424 :         if (mylocale && mylocale->provider == COLLPROVIDER_BUILTIN)
    1685        1998 :         {
    1686        1998 :             const char *src = buff;
    1687        1998 :             size_t      srclen = nbytes;
    1688             :             size_t      dstsize;
    1689             :             char       *dst;
    1690             :             size_t      needed;
    1691             : 
    1692             :             Assert(GetDatabaseEncoding() == PG_UTF8);
    1693             : 
    1694             :             /* first try buffer of equal size plus terminating NUL */
    1695        1998 :             dstsize = srclen + 1;
    1696        1998 :             dst = palloc(dstsize);
    1697             : 
    1698        1998 :             needed = unicode_strlower(dst, dstsize, src, srclen);
    1699        1998 :             if (needed + 1 > dstsize)
    1700             :             {
    1701             :                 /* grow buffer if needed and retry */
    1702          24 :                 dstsize = needed + 1;
    1703          24 :                 dst = repalloc(dst, dstsize);
    1704          24 :                 needed = unicode_strlower(dst, dstsize, src, srclen);
    1705             :                 Assert(needed + 1 == dstsize);
    1706             :             }
    1707             : 
    1708             :             Assert(dst[needed] == '\0');
    1709        1998 :             result = dst;
    1710             :         }
    1711             :         else
    1712             :         {
    1713             :             Assert(!mylocale || mylocale->provider == COLLPROVIDER_LIBC);
    1714             : 
    1715      148426 :             if (pg_database_encoding_max_length() > 1)
    1716             :             {
    1717             :                 wchar_t    *workspace;
    1718             :                 size_t      curr_char;
    1719             :                 size_t      result_size;
    1720             : 
    1721             :                 /* Overflow paranoia */
    1722      148426 :                 if ((nbytes + 1) > (INT_MAX / sizeof(wchar_t)))
    1723           0 :                     ereport(ERROR,
    1724             :                             (errcode(ERRCODE_OUT_OF_MEMORY),
    1725             :                              errmsg("out of memory")));
    1726             : 
    1727             :                 /* Output workspace cannot have more codes than input bytes */
    1728      148426 :                 workspace = (wchar_t *) palloc((nbytes + 1) * sizeof(wchar_t));
    1729             : 
    1730      148426 :                 char2wchar(workspace, nbytes + 1, buff, nbytes, mylocale);
    1731             : 
    1732     1326092 :                 for (curr_char = 0; workspace[curr_char] != 0; curr_char++)
    1733             :                 {
    1734     1177666 :                     if (mylocale)
    1735           0 :                         workspace[curr_char] = towlower_l(workspace[curr_char], mylocale->info.lt);
    1736             :                     else
    1737     1177666 :                         workspace[curr_char] = towlower(workspace[curr_char]);
    1738             :                 }
    1739             : 
    1740             :                 /*
    1741             :                  * Make result large enough; case change might change number
    1742             :                  * of bytes
    1743             :                  */
    1744      148426 :                 result_size = curr_char * pg_database_encoding_max_length() + 1;
    1745      148426 :                 result = palloc(result_size);
    1746             : 
    1747      148426 :                 wchar2char(result, workspace, result_size, mylocale);
    1748      148426 :                 pfree(workspace);
    1749             :             }
    1750             :             else
    1751             :             {
    1752             :                 char       *p;
    1753             : 
    1754           0 :                 result = pnstrdup(buff, nbytes);
    1755             : 
    1756             :                 /*
    1757             :                  * Note: we assume that tolower_l() will not be so broken as
    1758             :                  * to need an isupper_l() guard test.  When using the default
    1759             :                  * collation, we apply the traditional Postgres behavior that
    1760             :                  * forces ASCII-style treatment of I/i, but in non-default
    1761             :                  * collations you get exactly what the collation says.
    1762             :                  */
    1763           0 :                 for (p = result; *p; p++)
    1764             :                 {
    1765           0 :                     if (mylocale)
    1766           0 :                         *p = tolower_l((unsigned char) *p, mylocale->info.lt);
    1767             :                     else
    1768           0 :                         *p = pg_tolower((unsigned char) *p);
    1769             :                 }
    1770             :             }
    1771             :         }
    1772             :     }
    1773             : 
    1774      183546 :     return result;
    1775             : }
    1776             : 
    1777             : /*
    1778             :  * collation-aware, wide-character-aware upper function
    1779             :  *
    1780             :  * We pass the number of bytes so we can pass varlena and char*
    1781             :  * to this function.  The result is a palloc'd, null-terminated string.
    1782             :  */
    1783             : char *
    1784     1046866 : str_toupper(const char *buff, size_t nbytes, Oid collid)
    1785             : {
    1786             :     char       *result;
    1787             : 
    1788     1046866 :     if (!buff)
    1789           0 :         return NULL;
    1790             : 
    1791     1046866 :     if (!OidIsValid(collid))
    1792             :     {
    1793             :         /*
    1794             :          * This typically means that the parser could not resolve a conflict
    1795             :          * of implicit collations, so report it that way.
    1796             :          */
    1797           0 :         ereport(ERROR,
    1798             :                 (errcode(ERRCODE_INDETERMINATE_COLLATION),
    1799             :                  errmsg("could not determine which collation to use for %s function",
    1800             :                         "upper()"),
    1801             :                  errhint("Use the COLLATE clause to set the collation explicitly.")));
    1802             :     }
    1803             : 
    1804             :     /* C/POSIX collations use this path regardless of database encoding */
    1805     1046866 :     if (lc_ctype_is_c(collid))
    1806             :     {
    1807       15156 :         result = asc_toupper(buff, nbytes);
    1808             :     }
    1809             :     else
    1810             :     {
    1811             :         pg_locale_t mylocale;
    1812             : 
    1813     1031710 :         mylocale = pg_newlocale_from_collation(collid);
    1814             : 
    1815             : #ifdef USE_ICU
    1816     1031710 :         if (mylocale && mylocale->provider == COLLPROVIDER_ICU)
    1817          24 :         {
    1818             :             int32_t     len_uchar,
    1819             :                         len_conv;
    1820             :             UChar      *buff_uchar;
    1821             :             UChar      *buff_conv;
    1822             : 
    1823          24 :             len_uchar = icu_to_uchar(&buff_uchar, buff, nbytes);
    1824          24 :             len_conv = icu_convert_case(u_strToUpper, mylocale,
    1825             :                                         &buff_conv, buff_uchar, len_uchar);
    1826          24 :             icu_from_uchar(&result, buff_conv, len_conv);
    1827          24 :             pfree(buff_uchar);
    1828          24 :             pfree(buff_conv);
    1829             :         }
    1830             :         else
    1831             : #endif
    1832     1031686 :         if (mylocale && mylocale->provider == COLLPROVIDER_BUILTIN)
    1833      316786 :         {
    1834      316786 :             const char *src = buff;
    1835      316786 :             size_t      srclen = nbytes;
    1836             :             size_t      dstsize;
    1837             :             char       *dst;
    1838             :             size_t      needed;
    1839             : 
    1840             :             Assert(GetDatabaseEncoding() == PG_UTF8);
    1841             : 
    1842             :             /* first try buffer of equal size plus terminating NUL */
    1843      316786 :             dstsize = srclen + 1;
    1844      316786 :             dst = palloc(dstsize);
    1845             : 
    1846      316786 :             needed = unicode_strupper(dst, dstsize, src, srclen);
    1847      316786 :             if (needed + 1 > dstsize)
    1848             :             {
    1849             :                 /* grow buffer if needed and retry */
    1850           0 :                 dstsize = needed + 1;
    1851           0 :                 dst = repalloc(dst, dstsize);
    1852           0 :                 needed = unicode_strupper(dst, dstsize, src, srclen);
    1853             :                 Assert(needed + 1 == dstsize);
    1854             :             }
    1855             : 
    1856             :             Assert(dst[needed] == '\0');
    1857      316786 :             result = dst;
    1858             :         }
    1859             :         else
    1860             :         {
    1861             :             Assert(!mylocale || mylocale->provider == COLLPROVIDER_LIBC);
    1862             : 
    1863      714900 :             if (pg_database_encoding_max_length() > 1)
    1864             :             {
    1865             :                 wchar_t    *workspace;
    1866             :                 size_t      curr_char;
    1867             :                 size_t      result_size;
    1868             : 
    1869             :                 /* Overflow paranoia */
    1870      714900 :                 if ((nbytes + 1) > (INT_MAX / sizeof(wchar_t)))
    1871           0 :                     ereport(ERROR,
    1872             :                             (errcode(ERRCODE_OUT_OF_MEMORY),
    1873             :                              errmsg("out of memory")));
    1874             : 
    1875             :                 /* Output workspace cannot have more codes than input bytes */
    1876      714900 :                 workspace = (wchar_t *) palloc((nbytes + 1) * sizeof(wchar_t));
    1877             : 
    1878      714900 :                 char2wchar(workspace, nbytes + 1, buff, nbytes, mylocale);
    1879             : 
    1880     2336950 :                 for (curr_char = 0; workspace[curr_char] != 0; curr_char++)
    1881             :                 {
    1882     1622050 :                     if (mylocale)
    1883           0 :                         workspace[curr_char] = towupper_l(workspace[curr_char], mylocale->info.lt);
    1884             :                     else
    1885     1622050 :                         workspace[curr_char] = towupper(workspace[curr_char]);
    1886             :                 }
    1887             : 
    1888             :                 /*
    1889             :                  * Make result large enough; case change might change number
    1890             :                  * of bytes
    1891             :                  */
    1892      714900 :                 result_size = curr_char * pg_database_encoding_max_length() + 1;
    1893      714900 :                 result = palloc(result_size);
    1894             : 
    1895      714900 :                 wchar2char(result, workspace, result_size, mylocale);
    1896      714900 :                 pfree(workspace);
    1897             :             }
    1898             :             else
    1899             :             {
    1900             :                 char       *p;
    1901             : 
    1902           0 :                 result = pnstrdup(buff, nbytes);
    1903             : 
    1904             :                 /*
    1905             :                  * Note: we assume that toupper_l() will not be so broken as
    1906             :                  * to need an islower_l() guard test.  When using the default
    1907             :                  * collation, we apply the traditional Postgres behavior that
    1908             :                  * forces ASCII-style treatment of I/i, but in non-default
    1909             :                  * collations you get exactly what the collation says.
    1910             :                  */
    1911           0 :                 for (p = result; *p; p++)
    1912             :                 {
    1913           0 :                     if (mylocale)
    1914           0 :                         *p = toupper_l((unsigned char) *p, mylocale->info.lt);
    1915             :                     else
    1916           0 :                         *p = pg_toupper((unsigned char) *p);
    1917             :                 }
    1918             :             }
    1919             :         }
    1920             :     }
    1921             : 
    1922     1046866 :     return result;
    1923             : }
    1924             : 
    1925             : struct WordBoundaryState
    1926             : {
    1927             :     const char *str;
    1928             :     size_t      len;
    1929             :     size_t      offset;
    1930             :     bool        init;
    1931             :     bool        prev_alnum;
    1932             : };
    1933             : 
    1934             : /*
    1935             :  * Simple word boundary iterator that draws boundaries each time the result of
    1936             :  * pg_u_isalnum() changes.
    1937             :  */
    1938             : static size_t
    1939         344 : initcap_wbnext(void *state)
    1940             : {
    1941         344 :     struct WordBoundaryState *wbstate = (struct WordBoundaryState *) state;
    1942             : 
    1943         752 :     while (wbstate->offset < wbstate->len &&
    1944         666 :            wbstate->str[wbstate->offset] != '\0')
    1945             :     {
    1946         666 :         pg_wchar    u = utf8_to_unicode((unsigned char *) wbstate->str +
    1947         666 :                                         wbstate->offset);
    1948         666 :         bool        curr_alnum = pg_u_isalnum(u, true);
    1949             : 
    1950         666 :         if (!wbstate->init || curr_alnum != wbstate->prev_alnum)
    1951             :         {
    1952         258 :             size_t      prev_offset = wbstate->offset;
    1953             : 
    1954         258 :             wbstate->init = true;
    1955         258 :             wbstate->offset += unicode_utf8len(u);
    1956         258 :             wbstate->prev_alnum = curr_alnum;
    1957         258 :             return prev_offset;
    1958             :         }
    1959             : 
    1960         408 :         wbstate->offset += unicode_utf8len(u);
    1961             :     }
    1962             : 
    1963          86 :     return wbstate->len;
    1964             : }
    1965             : 
    1966             : /*
    1967             :  * collation-aware, wide-character-aware initcap function
    1968             :  *
    1969             :  * We pass the number of bytes so we can pass varlena and char*
    1970             :  * to this function.  The result is a palloc'd, null-terminated string.
    1971             :  */
    1972             : char *
    1973         130 : str_initcap(const char *buff, size_t nbytes, Oid collid)
    1974             : {
    1975             :     char       *result;
    1976         130 :     int         wasalnum = false;
    1977             : 
    1978         130 :     if (!buff)
    1979           0 :         return NULL;
    1980             : 
    1981         130 :     if (!OidIsValid(collid))
    1982             :     {
    1983             :         /*
    1984             :          * This typically means that the parser could not resolve a conflict
    1985             :          * of implicit collations, so report it that way.
    1986             :          */
    1987           0 :         ereport(ERROR,
    1988             :                 (errcode(ERRCODE_INDETERMINATE_COLLATION),
    1989             :                  errmsg("could not determine which collation to use for %s function",
    1990             :                         "initcap()"),
    1991             :                  errhint("Use the COLLATE clause to set the collation explicitly.")));
    1992             :     }
    1993             : 
    1994             :     /* C/POSIX collations use this path regardless of database encoding */
    1995         130 :     if (lc_ctype_is_c(collid))
    1996             :     {
    1997          24 :         result = asc_initcap(buff, nbytes);
    1998             :     }
    1999             :     else
    2000             :     {
    2001             :         pg_locale_t mylocale;
    2002             : 
    2003         106 :         mylocale = pg_newlocale_from_collation(collid);
    2004             : 
    2005             : #ifdef USE_ICU
    2006         106 :         if (mylocale && mylocale->provider == COLLPROVIDER_ICU)
    2007          24 :         {
    2008             :             int32_t     len_uchar,
    2009             :                         len_conv;
    2010             :             UChar      *buff_uchar;
    2011             :             UChar      *buff_conv;
    2012             : 
    2013          24 :             len_uchar = icu_to_uchar(&buff_uchar, buff, nbytes);
    2014          24 :             len_conv = icu_convert_case(u_strToTitle_default_BI, mylocale,
    2015             :                                         &buff_conv, buff_uchar, len_uchar);
    2016          24 :             icu_from_uchar(&result, buff_conv, len_conv);
    2017          24 :             pfree(buff_uchar);
    2018          24 :             pfree(buff_conv);
    2019             :         }
    2020             :         else
    2021             : #endif
    2022          82 :         if (mylocale && mylocale->provider == COLLPROVIDER_BUILTIN)
    2023          74 :         {
    2024          74 :             const char *src = buff;
    2025          74 :             size_t      srclen = nbytes;
    2026             :             size_t      dstsize;
    2027             :             char       *dst;
    2028             :             size_t      needed;
    2029          74 :             struct WordBoundaryState wbstate = {
    2030             :                 .str = src,
    2031             :                 .len = srclen,
    2032             :                 .offset = 0,
    2033             :                 .init = false,
    2034             :                 .prev_alnum = false,
    2035             :             };
    2036             : 
    2037             :             Assert(GetDatabaseEncoding() == PG_UTF8);
    2038             : 
    2039             :             /* first try buffer of equal size plus terminating NUL */
    2040          74 :             dstsize = srclen + 1;
    2041          74 :             dst = palloc(dstsize);
    2042             : 
    2043          74 :             needed = unicode_strtitle(dst, dstsize, src, srclen,
    2044             :                                       initcap_wbnext, &wbstate);
    2045          74 :             if (needed + 1 > dstsize)
    2046             :             {
    2047             :                 /* reset iterator */
    2048          12 :                 wbstate.offset = 0;
    2049          12 :                 wbstate.init = false;
    2050             : 
    2051             :                 /* grow buffer if needed and retry */
    2052          12 :                 dstsize = needed + 1;
    2053          12 :                 dst = repalloc(dst, dstsize);
    2054          12 :                 needed = unicode_strtitle(dst, dstsize, src, srclen,
    2055             :                                           initcap_wbnext, &wbstate);
    2056             :                 Assert(needed + 1 == dstsize);
    2057             :             }
    2058             : 
    2059          74 :             result = dst;
    2060             :         }
    2061             :         else
    2062             :         {
    2063             :             Assert(!mylocale || mylocale->provider == COLLPROVIDER_LIBC);
    2064             : 
    2065           8 :             if (pg_database_encoding_max_length() > 1)
    2066             :             {
    2067             :                 wchar_t    *workspace;
    2068             :                 size_t      curr_char;
    2069             :                 size_t      result_size;
    2070             : 
    2071             :                 /* Overflow paranoia */
    2072           8 :                 if ((nbytes + 1) > (INT_MAX / sizeof(wchar_t)))
    2073           0 :                     ereport(ERROR,
    2074             :                             (errcode(ERRCODE_OUT_OF_MEMORY),
    2075             :                              errmsg("out of memory")));
    2076             : 
    2077             :                 /* Output workspace cannot have more codes than input bytes */
    2078           8 :                 workspace = (wchar_t *) palloc((nbytes + 1) * sizeof(wchar_t));
    2079             : 
    2080           8 :                 char2wchar(workspace, nbytes + 1, buff, nbytes, mylocale);
    2081             : 
    2082          80 :                 for (curr_char = 0; workspace[curr_char] != 0; curr_char++)
    2083             :                 {
    2084          72 :                     if (mylocale)
    2085             :                     {
    2086           0 :                         if (wasalnum)
    2087           0 :                             workspace[curr_char] = towlower_l(workspace[curr_char], mylocale->info.lt);
    2088             :                         else
    2089           0 :                             workspace[curr_char] = towupper_l(workspace[curr_char], mylocale->info.lt);
    2090           0 :                         wasalnum = iswalnum_l(workspace[curr_char], mylocale->info.lt);
    2091             :                     }
    2092             :                     else
    2093             :                     {
    2094          72 :                         if (wasalnum)
    2095          56 :                             workspace[curr_char] = towlower(workspace[curr_char]);
    2096             :                         else
    2097          16 :                             workspace[curr_char] = towupper(workspace[curr_char]);
    2098          72 :                         wasalnum = iswalnum(workspace[curr_char]);
    2099             :                     }
    2100             :                 }
    2101             : 
    2102             :                 /*
    2103             :                  * Make result large enough; case change might change number
    2104             :                  * of bytes
    2105             :                  */
    2106           8 :                 result_size = curr_char * pg_database_encoding_max_length() + 1;
    2107           8 :                 result = palloc(result_size);
    2108             : 
    2109           8 :                 wchar2char(result, workspace, result_size, mylocale);
    2110           8 :                 pfree(workspace);
    2111             :             }
    2112             :             else
    2113             :             {
    2114             :                 char       *p;
    2115             : 
    2116           0 :                 result = pnstrdup(buff, nbytes);
    2117             : 
    2118             :                 /*
    2119             :                  * Note: we assume that toupper_l()/tolower_l() will not be so
    2120             :                  * broken as to need guard tests.  When using the default
    2121             :                  * collation, we apply the traditional Postgres behavior that
    2122             :                  * forces ASCII-style treatment of I/i, but in non-default
    2123             :                  * collations you get exactly what the collation says.
    2124             :                  */
    2125           0 :                 for (p = result; *p; p++)
    2126             :                 {
    2127           0 :                     if (mylocale)
    2128             :                     {
    2129           0 :                         if (wasalnum)
    2130           0 :                             *p = tolower_l((unsigned char) *p, mylocale->info.lt);
    2131             :                         else
    2132           0 :                             *p = toupper_l((unsigned char) *p, mylocale->info.lt);
    2133           0 :                         wasalnum = isalnum_l((unsigned char) *p, mylocale->info.lt);
    2134             :                     }
    2135             :                     else
    2136             :                     {
    2137           0 :                         if (wasalnum)
    2138           0 :                             *p = pg_tolower((unsigned char) *p);
    2139             :                         else
    2140           0 :                             *p = pg_toupper((unsigned char) *p);
    2141           0 :                         wasalnum = isalnum((unsigned char) *p);
    2142             :                     }
    2143             :                 }
    2144             :             }
    2145             :         }
    2146             :     }
    2147             : 
    2148         130 :     return result;
    2149             : }
    2150             : 
    2151             : /*
    2152             :  * ASCII-only lower function
    2153             :  *
    2154             :  * We pass the number of bytes so we can pass varlena and char*
    2155             :  * to this function.  The result is a palloc'd, null-terminated string.
    2156             :  */
    2157             : char *
    2158       37232 : asc_tolower(const char *buff, size_t nbytes)
    2159             : {
    2160             :     char       *result;
    2161             :     char       *p;
    2162             : 
    2163       37232 :     if (!buff)
    2164           0 :         return NULL;
    2165             : 
    2166       37232 :     result = pnstrdup(buff, nbytes);
    2167             : 
    2168      410998 :     for (p = result; *p; p++)
    2169      373766 :         *p = pg_ascii_tolower((unsigned char) *p);
    2170             : 
    2171       37232 :     return result;
    2172             : }
    2173             : 
    2174             : /*
    2175             :  * ASCII-only upper function
    2176             :  *
    2177             :  * We pass the number of bytes so we can pass varlena and char*
    2178             :  * to this function.  The result is a palloc'd, null-terminated string.
    2179             :  */
    2180             : char *
    2181       19728 : asc_toupper(const char *buff, size_t nbytes)
    2182             : {
    2183             :     char       *result;
    2184             :     char       *p;
    2185             : 
    2186       19728 :     if (!buff)
    2187           0 :         return NULL;
    2188             : 
    2189       19728 :     result = pnstrdup(buff, nbytes);
    2190             : 
    2191      170118 :     for (p = result; *p; p++)
    2192      150390 :         *p = pg_ascii_toupper((unsigned char) *p);
    2193             : 
    2194       19728 :     return result;
    2195             : }
    2196             : 
    2197             : /*
    2198             :  * ASCII-only initcap function
    2199             :  *
    2200             :  * We pass the number of bytes so we can pass varlena and char*
    2201             :  * to this function.  The result is a palloc'd, null-terminated string.
    2202             :  */
    2203             : char *
    2204          24 : asc_initcap(const char *buff, size_t nbytes)
    2205             : {
    2206             :     char       *result;
    2207             :     char       *p;
    2208          24 :     int         wasalnum = false;
    2209             : 
    2210          24 :     if (!buff)
    2211           0 :         return NULL;
    2212             : 
    2213          24 :     result = pnstrdup(buff, nbytes);
    2214             : 
    2215          96 :     for (p = result; *p; p++)
    2216             :     {
    2217             :         char        c;
    2218             : 
    2219          72 :         if (wasalnum)
    2220          48 :             *p = c = pg_ascii_tolower((unsigned char) *p);
    2221             :         else
    2222          24 :             *p = c = pg_ascii_toupper((unsigned char) *p);
    2223             :         /* we don't trust isalnum() here */
    2224         144 :         wasalnum = ((c >= 'A' && c <= 'Z') ||
    2225         144 :                     (c >= 'a' && c <= 'z') ||
    2226           0 :                     (c >= '0' && c <= '9'));
    2227             :     }
    2228             : 
    2229          24 :     return result;
    2230             : }
    2231             : 
    2232             : /* convenience routines for when the input is null-terminated */
    2233             : 
    2234             : static char *
    2235           0 : str_tolower_z(const char *buff, Oid collid)
    2236             : {
    2237           0 :     return str_tolower(buff, strlen(buff), collid);
    2238             : }
    2239             : 
    2240             : static char *
    2241           0 : str_toupper_z(const char *buff, Oid collid)
    2242             : {
    2243           0 :     return str_toupper(buff, strlen(buff), collid);
    2244             : }
    2245             : 
    2246             : static char *
    2247           0 : str_initcap_z(const char *buff, Oid collid)
    2248             : {
    2249           0 :     return str_initcap(buff, strlen(buff), collid);
    2250             : }
    2251             : 
    2252             : static char *
    2253        4578 : asc_tolower_z(const char *buff)
    2254             : {
    2255        4578 :     return asc_tolower(buff, strlen(buff));
    2256             : }
    2257             : 
    2258             : static char *
    2259        4572 : asc_toupper_z(const char *buff)
    2260             : {
    2261        4572 :     return asc_toupper(buff, strlen(buff));
    2262             : }
    2263             : 
    2264             : /* asc_initcap_z is not currently needed */
    2265             : 
    2266             : 
    2267             : /* ----------
    2268             :  * Skip TM / th in FROM_CHAR
    2269             :  *
    2270             :  * If S_THth is on, skip two chars, assuming there are two available
    2271             :  * ----------
    2272             :  */
    2273             : #define SKIP_THth(ptr, _suf) \
    2274             :     do { \
    2275             :         if (S_THth(_suf)) \
    2276             :         { \
    2277             :             if (*(ptr)) (ptr) += pg_mblen(ptr); \
    2278             :             if (*(ptr)) (ptr) += pg_mblen(ptr); \
    2279             :         } \
    2280             :     } while (0)
    2281             : 
    2282             : 
    2283             : #ifdef DEBUG_TO_FROM_CHAR
    2284             : /* -----------
    2285             :  * DEBUG: Call for debug and for index checking; (Show ASCII char
    2286             :  * and defined keyword for each used position
    2287             :  * ----------
    2288             :  */
    2289             : static void
    2290             : dump_index(const KeyWord *k, const int *index)
    2291             : {
    2292             :     int         i,
    2293             :                 count = 0,
    2294             :                 free_i = 0;
    2295             : 
    2296             :     elog(DEBUG_elog_output, "TO-FROM_CHAR: Dump KeyWord Index:");
    2297             : 
    2298             :     for (i = 0; i < KeyWord_INDEX_SIZE; i++)
    2299             :     {
    2300             :         if (index[i] != -1)
    2301             :         {
    2302             :             elog(DEBUG_elog_output, "\t%c: %s, ", i + 32, k[index[i]].name);
    2303             :             count++;
    2304             :         }
    2305             :         else
    2306             :         {
    2307             :             free_i++;
    2308             :             elog(DEBUG_elog_output, "\t(%d) %c %d", i, i + 32, index[i]);
    2309             :         }
    2310             :     }
    2311             :     elog(DEBUG_elog_output, "\n\t\tUsed positions: %d,\n\t\tFree positions: %d",
    2312             :          count, free_i);
    2313             : }
    2314             : #endif                          /* DEBUG */
    2315             : 
    2316             : /* ----------
    2317             :  * Return true if next format picture is not digit value
    2318             :  * ----------
    2319             :  */
    2320             : static bool
    2321      122012 : is_next_separator(FormatNode *n)
    2322             : {
    2323      122012 :     if (n->type == NODE_TYPE_END)
    2324           0 :         return false;
    2325             : 
    2326      122012 :     if (n->type == NODE_TYPE_ACTION && S_THth(n->suffix))
    2327           0 :         return true;
    2328             : 
    2329             :     /*
    2330             :      * Next node
    2331             :      */
    2332      122012 :     n++;
    2333             : 
    2334             :     /* end of format string is treated like a non-digit separator */
    2335      122012 :     if (n->type == NODE_TYPE_END)
    2336       12656 :         return true;
    2337             : 
    2338      109356 :     if (n->type == NODE_TYPE_ACTION)
    2339             :     {
    2340        6180 :         if (n->key->is_digit)
    2341         264 :             return false;
    2342             : 
    2343        5916 :         return true;
    2344             :     }
    2345      103176 :     else if (n->character[1] == '\0' &&
    2346      103176 :              isdigit((unsigned char) n->character[0]))
    2347           0 :         return false;
    2348             : 
    2349      103176 :     return true;                /* some non-digit input (separator) */
    2350             : }
    2351             : 
    2352             : 
    2353             : static int
    2354          72 : adjust_partial_year_to_2020(int year)
    2355             : {
    2356             :     /*
    2357             :      * Adjust all dates toward 2020; this is effectively what happens when we
    2358             :      * assume '70' is 1970 and '69' is 2069.
    2359             :      */
    2360             :     /* Force 0-69 into the 2000's */
    2361          72 :     if (year < 70)
    2362          30 :         return year + 2000;
    2363             :     /* Force 70-99 into the 1900's */
    2364          42 :     else if (year < 100)
    2365          36 :         return year + 1900;
    2366             :     /* Force 100-519 into the 2000's */
    2367           6 :     else if (year < 520)
    2368           0 :         return year + 2000;
    2369             :     /* Force 520-999 into the 1000's */
    2370           6 :     else if (year < 1000)
    2371           6 :         return year + 1000;
    2372             :     else
    2373           0 :         return year;
    2374             : }
    2375             : 
    2376             : 
    2377             : static int
    2378      122054 : strspace_len(const char *str)
    2379             : {
    2380      122054 :     int         len = 0;
    2381             : 
    2382      122054 :     while (*str && isspace((unsigned char) *str))
    2383             :     {
    2384           0 :         str++;
    2385           0 :         len++;
    2386             :     }
    2387      122054 :     return len;
    2388             : }
    2389             : 
    2390             : /*
    2391             :  * Set the date mode of a from-char conversion.
    2392             :  *
    2393             :  * Puke if the date mode has already been set, and the caller attempts to set
    2394             :  * it to a conflicting mode.
    2395             :  *
    2396             :  * Returns true on success, false on failure (if escontext points to an
    2397             :  * ErrorSaveContext; otherwise errors are thrown).
    2398             :  */
    2399             : static bool
    2400      122042 : from_char_set_mode(TmFromChar *tmfc, const FromCharDateMode mode,
    2401             :                    Node *escontext)
    2402             : {
    2403      122042 :     if (mode != FROM_CHAR_DATE_NONE)
    2404             :     {
    2405       54110 :         if (tmfc->mode == FROM_CHAR_DATE_NONE)
    2406       19988 :             tmfc->mode = mode;
    2407       34122 :         else if (tmfc->mode != mode)
    2408           6 :             ereturn(escontext, false,
    2409             :                     (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    2410             :                      errmsg("invalid combination of date conventions"),
    2411             :                      errhint("Do not mix Gregorian and ISO week date "
    2412             :                              "conventions in a formatting template.")));
    2413             :     }
    2414      122036 :     return true;
    2415             : }
    2416             : 
    2417             : /*
    2418             :  * Set the integer pointed to by 'dest' to the given value.
    2419             :  *
    2420             :  * Puke if the destination integer has previously been set to some other
    2421             :  * non-zero value.
    2422             :  *
    2423             :  * Returns true on success, false on failure (if escontext points to an
    2424             :  * ErrorSaveContext; otherwise errors are thrown).
    2425             :  */
    2426             : static bool
    2427      121428 : from_char_set_int(int *dest, const int value, const FormatNode *node,
    2428             :                   Node *escontext)
    2429             : {
    2430      121428 :     if (*dest != 0 && *dest != value)
    2431           6 :         ereturn(escontext, false,
    2432             :                 (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    2433             :                  errmsg("conflicting values for \"%s\" field in formatting string",
    2434             :                         node->key->name),
    2435             :                  errdetail("This value contradicts a previous setting "
    2436             :                            "for the same field type.")));
    2437      121422 :     *dest = value;
    2438      121422 :     return true;
    2439             : }
    2440             : 
    2441             : /*
    2442             :  * Read a single integer from the source string, into the int pointed to by
    2443             :  * 'dest'. If 'dest' is NULL, the result is discarded.
    2444             :  *
    2445             :  * In fixed-width mode (the node does not have the FM suffix), consume at most
    2446             :  * 'len' characters.  However, any leading whitespace isn't counted in 'len'.
    2447             :  *
    2448             :  * We use strtol() to recover the integer value from the source string, in
    2449             :  * accordance with the given FormatNode.
    2450             :  *
    2451             :  * If the conversion completes successfully, src will have been advanced to
    2452             :  * point at the character immediately following the last character used in the
    2453             :  * conversion.
    2454             :  *
    2455             :  * Returns the number of characters consumed, or -1 on error (if escontext
    2456             :  * points to an ErrorSaveContext; otherwise errors are thrown).
    2457             :  *
    2458             :  * Note that from_char_parse_int() provides a more convenient wrapper where
    2459             :  * the length of the field is the same as the length of the format keyword (as
    2460             :  * with DD and MI).
    2461             :  */
    2462             : static int
    2463      122054 : from_char_parse_int_len(int *dest, const char **src, const int len, FormatNode *node,
    2464             :                         Node *escontext)
    2465             : {
    2466             :     long        result;
    2467             :     char        copy[DCH_MAX_ITEM_SIZ + 1];
    2468      122054 :     const char *init = *src;
    2469             :     int         used;
    2470             : 
    2471             :     /*
    2472             :      * Skip any whitespace before parsing the integer.
    2473             :      */
    2474      122054 :     *src += strspace_len(*src);
    2475             : 
    2476             :     Assert(len <= DCH_MAX_ITEM_SIZ);
    2477      122054 :     used = (int) strlcpy(copy, *src, len + 1);
    2478             : 
    2479      122054 :     if (S_FM(node->suffix) || is_next_separator(node))
    2480      121790 :     {
    2481             :         /*
    2482             :          * This node is in Fill Mode, or the next node is known to be a
    2483             :          * non-digit value, so we just slurp as many characters as we can get.
    2484             :          */
    2485             :         char       *endptr;
    2486             : 
    2487      121790 :         errno = 0;
    2488      121790 :         result = strtol(init, &endptr, 10);
    2489      121790 :         *src = endptr;
    2490             :     }
    2491             :     else
    2492             :     {
    2493             :         /*
    2494             :          * We need to pull exactly the number of characters given in 'len' out
    2495             :          * of the string, and convert those.
    2496             :          */
    2497             :         char       *last;
    2498             : 
    2499         264 :         if (used < len)
    2500           6 :             ereturn(escontext, -1,
    2501             :                     (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    2502             :                      errmsg("source string too short for \"%s\" formatting field",
    2503             :                             node->key->name),
    2504             :                      errdetail("Field requires %d characters, but only %d remain.",
    2505             :                                len, used),
    2506             :                      errhint("If your source string is not fixed-width, "
    2507             :                              "try using the \"FM\" modifier.")));
    2508             : 
    2509         258 :         errno = 0;
    2510         258 :         result = strtol(copy, &last, 10);
    2511         258 :         used = last - copy;
    2512             : 
    2513         258 :         if (used > 0 && used < len)
    2514           6 :             ereturn(escontext, -1,
    2515             :                     (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    2516             :                      errmsg("invalid value \"%s\" for \"%s\"",
    2517             :                             copy, node->key->name),
    2518             :                      errdetail("Field requires %d characters, but only %d could be parsed.",
    2519             :                                len, used),
    2520             :                      errhint("If your source string is not fixed-width, "
    2521             :                              "try using the \"FM\" modifier.")));
    2522             : 
    2523         252 :         *src += used;
    2524             :     }
    2525             : 
    2526      122042 :     if (*src == init)
    2527         836 :         ereturn(escontext, -1,
    2528             :                 (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    2529             :                  errmsg("invalid value \"%s\" for \"%s\"",
    2530             :                         copy, node->key->name),
    2531             :                  errdetail("Value must be an integer.")));
    2532             : 
    2533      121206 :     if (errno == ERANGE || result < INT_MIN || result > INT_MAX)
    2534           6 :         ereturn(escontext, -1,
    2535             :                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    2536             :                  errmsg("value for \"%s\" in source string is out of range",
    2537             :                         node->key->name),
    2538             :                  errdetail("Value must be in the range %d to %d.",
    2539             :                            INT_MIN, INT_MAX)));
    2540             : 
    2541      121200 :     if (dest != NULL)
    2542             :     {
    2543      121194 :         if (!from_char_set_int(dest, (int) result, node, escontext))
    2544           0 :             return -1;
    2545             :     }
    2546             : 
    2547      121200 :     return *src - init;
    2548             : }
    2549             : 
    2550             : /*
    2551             :  * Call from_char_parse_int_len(), using the length of the format keyword as
    2552             :  * the expected length of the field.
    2553             :  *
    2554             :  * Don't call this function if the field differs in length from the format
    2555             :  * keyword (as with HH24; the keyword length is 4, but the field length is 2).
    2556             :  * In such cases, call from_char_parse_int_len() instead to specify the
    2557             :  * required length explicitly.
    2558             :  */
    2559             : static int
    2560       86576 : from_char_parse_int(int *dest, const char **src, FormatNode *node,
    2561             :                     Node *escontext)
    2562             : {
    2563       86576 :     return from_char_parse_int_len(dest, src, node->key->len, node, escontext);
    2564             : }
    2565             : 
    2566             : /*
    2567             :  * Sequentially search null-terminated "array" for a case-insensitive match
    2568             :  * to the initial character(s) of "name".
    2569             :  *
    2570             :  * Returns array index of match, or -1 for no match.
    2571             :  *
    2572             :  * *len is set to the length of the match, or 0 for no match.
    2573             :  *
    2574             :  * Case-insensitivity is defined per pg_ascii_tolower, so this is only
    2575             :  * suitable for comparisons to ASCII strings.
    2576             :  */
    2577             : static int
    2578         240 : seq_search_ascii(const char *name, const char *const *array, int *len)
    2579             : {
    2580             :     unsigned char firstc;
    2581             :     const char *const *a;
    2582             : 
    2583         240 :     *len = 0;
    2584             : 
    2585             :     /* empty string can't match anything */
    2586         240 :     if (!*name)
    2587           0 :         return -1;
    2588             : 
    2589             :     /* we handle first char specially to gain some speed */
    2590         240 :     firstc = pg_ascii_tolower((unsigned char) *name);
    2591             : 
    2592        1068 :     for (a = array; *a != NULL; a++)
    2593             :     {
    2594             :         const char *p;
    2595             :         const char *n;
    2596             : 
    2597             :         /* compare first chars */
    2598        1056 :         if (pg_ascii_tolower((unsigned char) **a) != firstc)
    2599         780 :             continue;
    2600             : 
    2601             :         /* compare rest of string */
    2602         786 :         for (p = *a + 1, n = name + 1;; p++, n++)
    2603             :         {
    2604             :             /* return success if we matched whole array entry */
    2605         786 :             if (*p == '\0')
    2606             :             {
    2607         228 :                 *len = n - name;
    2608         228 :                 return a - array;
    2609             :             }
    2610             :             /* else, must have another character in "name" ... */
    2611         558 :             if (*n == '\0')
    2612           0 :                 break;
    2613             :             /* ... and it must match */
    2614        1116 :             if (pg_ascii_tolower((unsigned char) *p) !=
    2615         558 :                 pg_ascii_tolower((unsigned char) *n))
    2616          48 :                 break;
    2617             :         }
    2618             :     }
    2619             : 
    2620          12 :     return -1;
    2621             : }
    2622             : 
    2623             : /*
    2624             :  * Sequentially search an array of possibly non-English words for
    2625             :  * a case-insensitive match to the initial character(s) of "name".
    2626             :  *
    2627             :  * This has the same API as seq_search_ascii(), but we use a more general
    2628             :  * case-folding transformation to achieve case-insensitivity.  Case folding
    2629             :  * is done per the rules of the collation identified by "collid".
    2630             :  *
    2631             :  * The array is treated as const, but we don't declare it that way because
    2632             :  * the arrays exported by pg_locale.c aren't const.
    2633             :  */
    2634             : static int
    2635           0 : seq_search_localized(const char *name, char **array, int *len, Oid collid)
    2636             : {
    2637             :     char      **a;
    2638             :     char       *upper_name;
    2639             :     char       *lower_name;
    2640             : 
    2641           0 :     *len = 0;
    2642             : 
    2643             :     /* empty string can't match anything */
    2644           0 :     if (!*name)
    2645           0 :         return -1;
    2646             : 
    2647             :     /*
    2648             :      * The case-folding processing done below is fairly expensive, so before
    2649             :      * doing that, make a quick pass to see if there is an exact match.
    2650             :      */
    2651           0 :     for (a = array; *a != NULL; a++)
    2652             :     {
    2653           0 :         int         element_len = strlen(*a);
    2654             : 
    2655           0 :         if (strncmp(name, *a, element_len) == 0)
    2656             :         {
    2657           0 :             *len = element_len;
    2658           0 :             return a - array;
    2659             :         }
    2660             :     }
    2661             : 
    2662             :     /*
    2663             :      * Fold to upper case, then to lower case, so that we can match reliably
    2664             :      * even in languages in which case conversions are not injective.
    2665             :      */
    2666           0 :     upper_name = str_toupper(unconstify(char *, name), strlen(name), collid);
    2667           0 :     lower_name = str_tolower(upper_name, strlen(upper_name), collid);
    2668           0 :     pfree(upper_name);
    2669             : 
    2670           0 :     for (a = array; *a != NULL; a++)
    2671             :     {
    2672             :         char       *upper_element;
    2673             :         char       *lower_element;
    2674             :         int         element_len;
    2675             : 
    2676             :         /* Likewise upper/lower-case array element */
    2677           0 :         upper_element = str_toupper(*a, strlen(*a), collid);
    2678           0 :         lower_element = str_tolower(upper_element, strlen(upper_element),
    2679             :                                     collid);
    2680           0 :         pfree(upper_element);
    2681           0 :         element_len = strlen(lower_element);
    2682             : 
    2683             :         /* Match? */
    2684           0 :         if (strncmp(lower_name, lower_element, element_len) == 0)
    2685             :         {
    2686           0 :             *len = element_len;
    2687           0 :             pfree(lower_element);
    2688           0 :             pfree(lower_name);
    2689           0 :             return a - array;
    2690             :         }
    2691           0 :         pfree(lower_element);
    2692             :     }
    2693             : 
    2694           0 :     pfree(lower_name);
    2695           0 :     return -1;
    2696             : }
    2697             : 
    2698             : /*
    2699             :  * Perform a sequential search in 'array' (or 'localized_array', if that's
    2700             :  * not NULL) for an entry matching the first character(s) of the 'src'
    2701             :  * string case-insensitively.
    2702             :  *
    2703             :  * The 'array' is presumed to be English words (all-ASCII), but
    2704             :  * if 'localized_array' is supplied, that might be non-English
    2705             :  * so we need a more expensive case-folding transformation
    2706             :  * (which will follow the rules of the collation 'collid').
    2707             :  *
    2708             :  * If a match is found, copy the array index of the match into the integer
    2709             :  * pointed to by 'dest' and advance 'src' to the end of the part of the string
    2710             :  * which matched.
    2711             :  *
    2712             :  * Returns true on match, false on failure (if escontext points to an
    2713             :  * ErrorSaveContext; otherwise errors are thrown).
    2714             :  *
    2715             :  * 'node' is used only for error reports: node->key->name identifies the
    2716             :  * field type we were searching for.
    2717             :  */
    2718             : static bool
    2719         240 : from_char_seq_search(int *dest, const char **src, const char *const *array,
    2720             :                      char **localized_array, Oid collid,
    2721             :                      FormatNode *node, Node *escontext)
    2722             : {
    2723             :     int         len;
    2724             : 
    2725         240 :     if (localized_array == NULL)
    2726         240 :         *dest = seq_search_ascii(*src, array, &len);
    2727             :     else
    2728           0 :         *dest = seq_search_localized(*src, localized_array, &len, collid);
    2729             : 
    2730         240 :     if (len <= 0)
    2731             :     {
    2732             :         /*
    2733             :          * In the error report, truncate the string at the next whitespace (if
    2734             :          * any) to avoid including irrelevant data.
    2735             :          */
    2736          12 :         char       *copy = pstrdup(*src);
    2737             :         char       *c;
    2738             : 
    2739          60 :         for (c = copy; *c; c++)
    2740             :         {
    2741          54 :             if (scanner_isspace(*c))
    2742             :             {
    2743           6 :                 *c = '\0';
    2744           6 :                 break;
    2745             :             }
    2746             :         }
    2747             : 
    2748          12 :         ereturn(escontext, false,
    2749             :                 (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    2750             :                  errmsg("invalid value \"%s\" for \"%s\"",
    2751             :                         copy, node->key->name),
    2752             :                  errdetail("The given value did not match any of "
    2753             :                            "the allowed values for this field.")));
    2754             :     }
    2755         228 :     *src += len;
    2756         228 :     return true;
    2757             : }
    2758             : 
    2759             : /* ----------
    2760             :  * Process a TmToChar struct as denoted by a list of FormatNodes.
    2761             :  * The formatted data is written to the string pointed to by 'out'.
    2762             :  * ----------
    2763             :  */
    2764             : static void
    2765        9098 : DCH_to_char(FormatNode *node, bool is_interval, TmToChar *in, char *out, Oid collid)
    2766             : {
    2767             :     FormatNode *n;
    2768             :     char       *s;
    2769        9098 :     struct fmt_tm *tm = &in->tm;
    2770             :     int         i;
    2771             : 
    2772             :     /* cache localized days and months */
    2773        9098 :     cache_locale_time();
    2774             : 
    2775        9098 :     s = out;
    2776      185498 :     for (n = node; n->type != NODE_TYPE_END; n++)
    2777             :     {
    2778      176400 :         if (n->type != NODE_TYPE_ACTION)
    2779             :         {
    2780      103896 :             strcpy(s, n->character);
    2781      103896 :             s += strlen(s);
    2782      103896 :             continue;
    2783             :         }
    2784             : 
    2785       72504 :         switch (n->key->id)
    2786             :         {
    2787         762 :             case DCH_A_M:
    2788             :             case DCH_P_M:
    2789         762 :                 strcpy(s, (tm->tm_hour % HOURS_PER_DAY >= HOURS_PER_DAY / 2)
    2790             :                        ? P_M_STR : A_M_STR);
    2791         762 :                 s += strlen(s);
    2792         762 :                 break;
    2793           0 :             case DCH_AM:
    2794             :             case DCH_PM:
    2795           0 :                 strcpy(s, (tm->tm_hour % HOURS_PER_DAY >= HOURS_PER_DAY / 2)
    2796             :                        ? PM_STR : AM_STR);
    2797           0 :                 s += strlen(s);
    2798           0 :                 break;
    2799         762 :             case DCH_a_m:
    2800             :             case DCH_p_m:
    2801         762 :                 strcpy(s, (tm->tm_hour % HOURS_PER_DAY >= HOURS_PER_DAY / 2)
    2802             :                        ? p_m_STR : a_m_STR);
    2803         762 :                 s += strlen(s);
    2804         762 :                 break;
    2805         762 :             case DCH_am:
    2806             :             case DCH_pm:
    2807         762 :                 strcpy(s, (tm->tm_hour % HOURS_PER_DAY >= HOURS_PER_DAY / 2)
    2808             :                        ? pm_STR : am_STR);
    2809         762 :                 s += strlen(s);
    2810         762 :                 break;
    2811        4600 :             case DCH_HH:
    2812             :             case DCH_HH12:
    2813             : 
    2814             :                 /*
    2815             :                  * display time as shown on a 12-hour clock, even for
    2816             :                  * intervals
    2817             :                  */
    2818        4600 :                 sprintf(s, "%0*lld", S_FM(n->suffix) ? 0 : (tm->tm_hour >= 0) ? 2 : 3,
    2819        4600 :                         tm->tm_hour % (HOURS_PER_DAY / 2) == 0 ?
    2820             :                         (long long) (HOURS_PER_DAY / 2) :
    2821        4432 :                         (long long) (tm->tm_hour % (HOURS_PER_DAY / 2)));
    2822        4600 :                 if (S_THth(n->suffix))
    2823           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    2824        4600 :                 s += strlen(s);
    2825        4600 :                 break;
    2826        1526 :             case DCH_HH24:
    2827        1526 :                 sprintf(s, "%0*lld", S_FM(n->suffix) ? 0 : (tm->tm_hour >= 0) ? 2 : 3,
    2828        1526 :                         (long long) tm->tm_hour);
    2829        1526 :                 if (S_THth(n->suffix))
    2830           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    2831        1526 :                 s += strlen(s);
    2832        1526 :                 break;
    2833        4602 :             case DCH_MI:
    2834        4602 :                 sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : (tm->tm_min >= 0) ? 2 : 3,
    2835             :                         tm->tm_min);
    2836        4602 :                 if (S_THth(n->suffix))
    2837           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    2838        4602 :                 s += strlen(s);
    2839        4602 :                 break;
    2840        4602 :             case DCH_SS:
    2841        4602 :                 sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : (tm->tm_sec >= 0) ? 2 : 3,
    2842             :                         tm->tm_sec);
    2843        4602 :                 if (S_THth(n->suffix))
    2844           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    2845        4602 :                 s += strlen(s);
    2846        4602 :                 break;
    2847             : 
    2848             : #define DCH_to_char_fsec(frac_fmt, frac_val) \
    2849             :                 sprintf(s, frac_fmt, (int) (frac_val)); \
    2850             :                 if (S_THth(n->suffix)) \
    2851             :                     str_numth(s, s, S_TH_TYPE(n->suffix)); \
    2852             :                 s += strlen(s)
    2853             : 
    2854          96 :             case DCH_FF1:       /* tenth of second */
    2855          96 :                 DCH_to_char_fsec("%01d", in->fsec / 100000);
    2856          96 :                 break;
    2857          96 :             case DCH_FF2:       /* hundredth of second */
    2858          96 :                 DCH_to_char_fsec("%02d", in->fsec / 10000);
    2859          96 :                 break;
    2860         144 :             case DCH_FF3:
    2861             :             case DCH_MS:        /* millisecond */
    2862         144 :                 DCH_to_char_fsec("%03d", in->fsec / 1000);
    2863         144 :                 break;
    2864          96 :             case DCH_FF4:       /* tenth of a millisecond */
    2865          96 :                 DCH_to_char_fsec("%04d", in->fsec / 100);
    2866          96 :                 break;
    2867          96 :             case DCH_FF5:       /* hundredth of a millisecond */
    2868          96 :                 DCH_to_char_fsec("%05d", in->fsec / 10);
    2869          96 :                 break;
    2870         144 :             case DCH_FF6:
    2871             :             case DCH_US:        /* microsecond */
    2872         144 :                 DCH_to_char_fsec("%06d", in->fsec);
    2873         144 :                 break;
    2874             : #undef DCH_to_char_fsec
    2875         774 :             case DCH_SSSS:
    2876         774 :                 sprintf(s, "%lld",
    2877         774 :                         (long long) (tm->tm_hour * SECS_PER_HOUR +
    2878         774 :                                      tm->tm_min * SECS_PER_MINUTE +
    2879         774 :                                      tm->tm_sec));
    2880         774 :                 if (S_THth(n->suffix))
    2881           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    2882         774 :                 s += strlen(s);
    2883         774 :                 break;
    2884           6 :             case DCH_tz:
    2885           6 :                 INVALID_FOR_INTERVAL;
    2886           6 :                 if (tmtcTzn(in))
    2887             :                 {
    2888             :                     /* We assume here that timezone names aren't localized */
    2889           6 :                     char       *p = asc_tolower_z(tmtcTzn(in));
    2890             : 
    2891           6 :                     strcpy(s, p);
    2892           6 :                     pfree(p);
    2893           6 :                     s += strlen(s);
    2894             :                 }
    2895           6 :                 break;
    2896          18 :             case DCH_TZ:
    2897          18 :                 INVALID_FOR_INTERVAL;
    2898          18 :                 if (tmtcTzn(in))
    2899             :                 {
    2900          18 :                     strcpy(s, tmtcTzn(in));
    2901          18 :                     s += strlen(s);
    2902             :                 }
    2903          18 :                 break;
    2904         108 :             case DCH_TZH:
    2905         108 :                 INVALID_FOR_INTERVAL;
    2906         108 :                 sprintf(s, "%c%02d",
    2907         108 :                         (tm->tm_gmtoff >= 0) ? '+' : '-',
    2908         108 :                         abs((int) tm->tm_gmtoff) / SECS_PER_HOUR);
    2909         108 :                 s += strlen(s);
    2910         108 :                 break;
    2911         108 :             case DCH_TZM:
    2912         108 :                 INVALID_FOR_INTERVAL;
    2913         108 :                 sprintf(s, "%02d",
    2914         108 :                         (abs((int) tm->tm_gmtoff) % SECS_PER_HOUR) / SECS_PER_MINUTE);
    2915         108 :                 s += strlen(s);
    2916         108 :                 break;
    2917         108 :             case DCH_OF:
    2918         108 :                 INVALID_FOR_INTERVAL;
    2919         216 :                 sprintf(s, "%c%0*d",
    2920         108 :                         (tm->tm_gmtoff >= 0) ? '+' : '-',
    2921         108 :                         S_FM(n->suffix) ? 0 : 2,
    2922         108 :                         abs((int) tm->tm_gmtoff) / SECS_PER_HOUR);
    2923         108 :                 s += strlen(s);
    2924         108 :                 if (abs((int) tm->tm_gmtoff) % SECS_PER_HOUR != 0)
    2925             :                 {
    2926          72 :                     sprintf(s, ":%02d",
    2927          72 :                             (abs((int) tm->tm_gmtoff) % SECS_PER_HOUR) / SECS_PER_MINUTE);
    2928          72 :                     s += strlen(s);
    2929             :                 }
    2930         108 :                 break;
    2931         762 :             case DCH_A_D:
    2932             :             case DCH_B_C:
    2933         762 :                 INVALID_FOR_INTERVAL;
    2934         762 :                 strcpy(s, (tm->tm_year <= 0 ? B_C_STR : A_D_STR));
    2935         762 :                 s += strlen(s);
    2936         762 :                 break;
    2937           0 :             case DCH_AD:
    2938             :             case DCH_BC:
    2939           0 :                 INVALID_FOR_INTERVAL;
    2940           0 :                 strcpy(s, (tm->tm_year <= 0 ? BC_STR : AD_STR));
    2941           0 :                 s += strlen(s);
    2942           0 :                 break;
    2943         762 :             case DCH_a_d:
    2944             :             case DCH_b_c:
    2945         762 :                 INVALID_FOR_INTERVAL;
    2946         762 :                 strcpy(s, (tm->tm_year <= 0 ? b_c_STR : a_d_STR));
    2947         762 :                 s += strlen(s);
    2948         762 :                 break;
    2949         762 :             case DCH_ad:
    2950             :             case DCH_bc:
    2951         762 :                 INVALID_FOR_INTERVAL;
    2952         762 :                 strcpy(s, (tm->tm_year <= 0 ? bc_STR : ad_STR));
    2953         762 :                 s += strlen(s);
    2954         762 :                 break;
    2955        1524 :             case DCH_MONTH:
    2956        1524 :                 INVALID_FOR_INTERVAL;
    2957        1524 :                 if (!tm->tm_mon)
    2958           0 :                     break;
    2959        1524 :                 if (S_TM(n->suffix))
    2960             :                 {
    2961           0 :                     char       *str = str_toupper_z(localized_full_months[tm->tm_mon - 1], collid);
    2962             : 
    2963           0 :                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
    2964           0 :                         strcpy(s, str);
    2965             :                     else
    2966           0 :                         ereport(ERROR,
    2967             :                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    2968             :                                  errmsg("localized string format value too long")));
    2969             :                 }
    2970             :                 else
    2971        1524 :                     sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -9,
    2972        1524 :                             asc_toupper_z(months_full[tm->tm_mon - 1]));
    2973        1524 :                 s += strlen(s);
    2974        1524 :                 break;
    2975        1524 :             case DCH_Month:
    2976        1524 :                 INVALID_FOR_INTERVAL;
    2977        1524 :                 if (!tm->tm_mon)
    2978           0 :                     break;
    2979        1524 :                 if (S_TM(n->suffix))
    2980             :                 {
    2981           0 :                     char       *str = str_initcap_z(localized_full_months[tm->tm_mon - 1], collid);
    2982             : 
    2983           0 :                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
    2984           0 :                         strcpy(s, str);
    2985             :                     else
    2986           0 :                         ereport(ERROR,
    2987             :                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    2988             :                                  errmsg("localized string format value too long")));
    2989             :                 }
    2990             :                 else
    2991        1524 :                     sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -9,
    2992        1524 :                             months_full[tm->tm_mon - 1]);
    2993        1524 :                 s += strlen(s);
    2994        1524 :                 break;
    2995        1524 :             case DCH_month:
    2996        1524 :                 INVALID_FOR_INTERVAL;
    2997        1524 :                 if (!tm->tm_mon)
    2998           0 :                     break;
    2999        1524 :                 if (S_TM(n->suffix))
    3000             :                 {
    3001           0 :                     char       *str = str_tolower_z(localized_full_months[tm->tm_mon - 1], collid);
    3002             : 
    3003           0 :                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
    3004           0 :                         strcpy(s, str);
    3005             :                     else
    3006           0 :                         ereport(ERROR,
    3007             :                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    3008             :                                  errmsg("localized string format value too long")));
    3009             :                 }
    3010             :                 else
    3011        1524 :                     sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -9,
    3012        1524 :                             asc_tolower_z(months_full[tm->tm_mon - 1]));
    3013        1524 :                 s += strlen(s);
    3014        1524 :                 break;
    3015         762 :             case DCH_MON:
    3016         762 :                 INVALID_FOR_INTERVAL;
    3017         762 :                 if (!tm->tm_mon)
    3018           0 :                     break;
    3019         762 :                 if (S_TM(n->suffix))
    3020             :                 {
    3021           0 :                     char       *str = str_toupper_z(localized_abbrev_months[tm->tm_mon - 1], collid);
    3022             : 
    3023           0 :                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
    3024           0 :                         strcpy(s, str);
    3025             :                     else
    3026           0 :                         ereport(ERROR,
    3027             :                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    3028             :                                  errmsg("localized string format value too long")));
    3029             :                 }
    3030             :                 else
    3031         762 :                     strcpy(s, asc_toupper_z(months[tm->tm_mon - 1]));
    3032         762 :                 s += strlen(s);
    3033         762 :                 break;
    3034         846 :             case DCH_Mon:
    3035         846 :                 INVALID_FOR_INTERVAL;
    3036         846 :                 if (!tm->tm_mon)
    3037           0 :                     break;
    3038         846 :                 if (S_TM(n->suffix))
    3039             :                 {
    3040           0 :                     char       *str = str_initcap_z(localized_abbrev_months[tm->tm_mon - 1], collid);
    3041             : 
    3042           0 :                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
    3043           0 :                         strcpy(s, str);
    3044             :                     else
    3045           0 :                         ereport(ERROR,
    3046             :                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    3047             :                                  errmsg("localized string format value too long")));
    3048             :                 }
    3049             :                 else
    3050         846 :                     strcpy(s, months[tm->tm_mon - 1]);
    3051         846 :                 s += strlen(s);
    3052         846 :                 break;
    3053         762 :             case DCH_mon:
    3054         762 :                 INVALID_FOR_INTERVAL;
    3055         762 :                 if (!tm->tm_mon)
    3056           0 :                     break;
    3057         762 :                 if (S_TM(n->suffix))
    3058             :                 {
    3059           0 :                     char       *str = str_tolower_z(localized_abbrev_months[tm->tm_mon - 1], collid);
    3060             : 
    3061           0 :                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
    3062           0 :                         strcpy(s, str);
    3063             :                     else
    3064           0 :                         ereport(ERROR,
    3065             :                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    3066             :                                  errmsg("localized string format value too long")));
    3067             :                 }
    3068             :                 else
    3069         762 :                     strcpy(s, asc_tolower_z(months[tm->tm_mon - 1]));
    3070         762 :                 s += strlen(s);
    3071         762 :                 break;
    3072        1560 :             case DCH_MM:
    3073        1560 :                 sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : (tm->tm_mon >= 0) ? 2 : 3,
    3074             :                         tm->tm_mon);
    3075        1560 :                 if (S_THth(n->suffix))
    3076           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3077        1560 :                 s += strlen(s);
    3078        1560 :                 break;
    3079        1524 :             case DCH_DAY:
    3080        1524 :                 INVALID_FOR_INTERVAL;
    3081        1524 :                 if (S_TM(n->suffix))
    3082             :                 {
    3083           0 :                     char       *str = str_toupper_z(localized_full_days[tm->tm_wday], collid);
    3084             : 
    3085           0 :                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
    3086           0 :                         strcpy(s, str);
    3087             :                     else
    3088           0 :                         ereport(ERROR,
    3089             :                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    3090             :                                  errmsg("localized string format value too long")));
    3091             :                 }
    3092             :                 else
    3093        1524 :                     sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -9,
    3094        1524 :                             asc_toupper_z(days[tm->tm_wday]));
    3095        1524 :                 s += strlen(s);
    3096        1524 :                 break;
    3097        1524 :             case DCH_Day:
    3098        1524 :                 INVALID_FOR_INTERVAL;
    3099        1524 :                 if (S_TM(n->suffix))
    3100             :                 {
    3101           0 :                     char       *str = str_initcap_z(localized_full_days[tm->tm_wday], collid);
    3102             : 
    3103           0 :                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
    3104           0 :                         strcpy(s, str);
    3105             :                     else
    3106           0 :                         ereport(ERROR,
    3107             :                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    3108             :                                  errmsg("localized string format value too long")));
    3109             :                 }
    3110             :                 else
    3111        1524 :                     sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -9,
    3112        1524 :                             days[tm->tm_wday]);
    3113        1524 :                 s += strlen(s);
    3114        1524 :                 break;
    3115        1524 :             case DCH_day:
    3116        1524 :                 INVALID_FOR_INTERVAL;
    3117        1524 :                 if (S_TM(n->suffix))
    3118             :                 {
    3119           0 :                     char       *str = str_tolower_z(localized_full_days[tm->tm_wday], collid);
    3120             : 
    3121           0 :                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
    3122           0 :                         strcpy(s, str);
    3123             :                     else
    3124           0 :                         ereport(ERROR,
    3125             :                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    3126             :                                  errmsg("localized string format value too long")));
    3127             :                 }
    3128             :                 else
    3129        1524 :                     sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -9,
    3130        1524 :                             asc_tolower_z(days[tm->tm_wday]));
    3131        1524 :                 s += strlen(s);
    3132        1524 :                 break;
    3133         762 :             case DCH_DY:
    3134         762 :                 INVALID_FOR_INTERVAL;
    3135         762 :                 if (S_TM(n->suffix))
    3136             :                 {
    3137           0 :                     char       *str = str_toupper_z(localized_abbrev_days[tm->tm_wday], collid);
    3138             : 
    3139           0 :                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
    3140           0 :                         strcpy(s, str);
    3141             :                     else
    3142           0 :                         ereport(ERROR,
    3143             :                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    3144             :                                  errmsg("localized string format value too long")));
    3145             :                 }
    3146             :                 else
    3147         762 :                     strcpy(s, asc_toupper_z(days_short[tm->tm_wday]));
    3148         762 :                 s += strlen(s);
    3149         762 :                 break;
    3150         762 :             case DCH_Dy:
    3151         762 :                 INVALID_FOR_INTERVAL;
    3152         762 :                 if (S_TM(n->suffix))
    3153             :                 {
    3154           0 :                     char       *str = str_initcap_z(localized_abbrev_days[tm->tm_wday], collid);
    3155             : 
    3156           0 :                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
    3157           0 :                         strcpy(s, str);
    3158             :                     else
    3159           0 :                         ereport(ERROR,
    3160             :                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    3161             :                                  errmsg("localized string format value too long")));
    3162             :                 }
    3163             :                 else
    3164         762 :                     strcpy(s, days_short[tm->tm_wday]);
    3165         762 :                 s += strlen(s);
    3166         762 :                 break;
    3167         762 :             case DCH_dy:
    3168         762 :                 INVALID_FOR_INTERVAL;
    3169         762 :                 if (S_TM(n->suffix))
    3170             :                 {
    3171           0 :                     char       *str = str_tolower_z(localized_abbrev_days[tm->tm_wday], collid);
    3172             : 
    3173           0 :                     if (strlen(str) <= (n->key->len + TM_SUFFIX_LEN) * DCH_MAX_ITEM_SIZ)
    3174           0 :                         strcpy(s, str);
    3175             :                     else
    3176           0 :                         ereport(ERROR,
    3177             :                                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    3178             :                                  errmsg("localized string format value too long")));
    3179             :                 }
    3180             :                 else
    3181         762 :                     strcpy(s, asc_tolower_z(days_short[tm->tm_wday]));
    3182         762 :                 s += strlen(s);
    3183         762 :                 break;
    3184        3048 :             case DCH_DDD:
    3185             :             case DCH_IDDD:
    3186        3048 :                 sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : 3,
    3187        3048 :                         (n->key->id == DCH_DDD) ?
    3188             :                         tm->tm_yday :
    3189        1524 :                         date2isoyearday(tm->tm_year, tm->tm_mon, tm->tm_mday));
    3190        3048 :                 if (S_THth(n->suffix))
    3191           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3192        3048 :                 s += strlen(s);
    3193        3048 :                 break;
    3194        1560 :             case DCH_DD:
    3195        1560 :                 sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : 2, tm->tm_mday);
    3196        1560 :                 if (S_THth(n->suffix))
    3197           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3198        1560 :                 s += strlen(s);
    3199        1560 :                 break;
    3200        1524 :             case DCH_D:
    3201        1524 :                 INVALID_FOR_INTERVAL;
    3202        1524 :                 sprintf(s, "%d", tm->tm_wday + 1);
    3203        1524 :                 if (S_THth(n->suffix))
    3204           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3205        1524 :                 s += strlen(s);
    3206        1524 :                 break;
    3207        1524 :             case DCH_ID:
    3208        1524 :                 INVALID_FOR_INTERVAL;
    3209        1524 :                 sprintf(s, "%d", (tm->tm_wday == 0) ? 7 : tm->tm_wday);
    3210        1524 :                 if (S_THth(n->suffix))
    3211           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3212        1524 :                 s += strlen(s);
    3213        1524 :                 break;
    3214        1524 :             case DCH_WW:
    3215        1524 :                 sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : 2,
    3216        1524 :                         (tm->tm_yday - 1) / 7 + 1);
    3217        1524 :                 if (S_THth(n->suffix))
    3218           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3219        1524 :                 s += strlen(s);
    3220        1524 :                 break;
    3221        1524 :             case DCH_IW:
    3222        1524 :                 sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : 2,
    3223             :                         date2isoweek(tm->tm_year, tm->tm_mon, tm->tm_mday));
    3224        1524 :                 if (S_THth(n->suffix))
    3225           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3226        1524 :                 s += strlen(s);
    3227        1524 :                 break;
    3228        1524 :             case DCH_Q:
    3229        1524 :                 if (!tm->tm_mon)
    3230           0 :                     break;
    3231        1524 :                 sprintf(s, "%d", (tm->tm_mon - 1) / 3 + 1);
    3232        1524 :                 if (S_THth(n->suffix))
    3233           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3234        1524 :                 s += strlen(s);
    3235        1524 :                 break;
    3236        1524 :             case DCH_CC:
    3237        1524 :                 if (is_interval)    /* straight calculation */
    3238           0 :                     i = tm->tm_year / 100;
    3239             :                 else
    3240             :                 {
    3241        1524 :                     if (tm->tm_year > 0)
    3242             :                         /* Century 20 == 1901 - 2000 */
    3243        1500 :                         i = (tm->tm_year - 1) / 100 + 1;
    3244             :                     else
    3245             :                         /* Century 6BC == 600BC - 501BC */
    3246          24 :                         i = tm->tm_year / 100 - 1;
    3247             :                 }
    3248        1524 :                 if (i <= 99 && i >= -99)
    3249        1524 :                     sprintf(s, "%0*d", S_FM(n->suffix) ? 0 : (i >= 0) ? 2 : 3, i);
    3250             :                 else
    3251           0 :                     sprintf(s, "%d", i);
    3252        1524 :                 if (S_THth(n->suffix))
    3253           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3254        1524 :                 s += strlen(s);
    3255        1524 :                 break;
    3256        1524 :             case DCH_Y_YYY:
    3257        1524 :                 i = ADJUST_YEAR(tm->tm_year, is_interval) / 1000;
    3258        1524 :                 sprintf(s, "%d,%03d", i,
    3259        1524 :                         ADJUST_YEAR(tm->tm_year, is_interval) - (i * 1000));
    3260        1524 :                 if (S_THth(n->suffix))
    3261           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3262        1524 :                 s += strlen(s);
    3263        1524 :                 break;
    3264        6894 :             case DCH_YYYY:
    3265             :             case DCH_IYYY:
    3266       13788 :                 sprintf(s, "%0*d",
    3267        6894 :                         S_FM(n->suffix) ? 0 :
    3268        5370 :                         (ADJUST_YEAR(tm->tm_year, is_interval) >= 0) ? 4 : 5,
    3269        6894 :                         (n->key->id == DCH_YYYY ?
    3270        5370 :                          ADJUST_YEAR(tm->tm_year, is_interval) :
    3271        1524 :                          ADJUST_YEAR(date2isoyear(tm->tm_year,
    3272             :                                                   tm->tm_mon,
    3273             :                                                   tm->tm_mday),
    3274             :                                      is_interval)));
    3275        6894 :                 if (S_THth(n->suffix))
    3276        1524 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3277        6894 :                 s += strlen(s);
    3278        6894 :                 break;
    3279        3048 :             case DCH_YYY:
    3280             :             case DCH_IYY:
    3281        6096 :                 sprintf(s, "%0*d",
    3282        3048 :                         S_FM(n->suffix) ? 0 :
    3283        1524 :                         (ADJUST_YEAR(tm->tm_year, is_interval) >= 0) ? 3 : 4,
    3284        3048 :                         (n->key->id == DCH_YYY ?
    3285        3048 :                          ADJUST_YEAR(tm->tm_year, is_interval) :
    3286        3048 :                          ADJUST_YEAR(date2isoyear(tm->tm_year,
    3287             :                                                   tm->tm_mon,
    3288             :                                                   tm->tm_mday),
    3289        6096 :                                      is_interval)) % 1000);
    3290        3048 :                 if (S_THth(n->suffix))
    3291           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3292        3048 :                 s += strlen(s);
    3293        3048 :                 break;
    3294        3048 :             case DCH_YY:
    3295             :             case DCH_IY:
    3296        6096 :                 sprintf(s, "%0*d",
    3297        3048 :                         S_FM(n->suffix) ? 0 :
    3298        1524 :                         (ADJUST_YEAR(tm->tm_year, is_interval) >= 0) ? 2 : 3,
    3299        3048 :                         (n->key->id == DCH_YY ?
    3300        3048 :                          ADJUST_YEAR(tm->tm_year, is_interval) :
    3301        3048 :                          ADJUST_YEAR(date2isoyear(tm->tm_year,
    3302             :                                                   tm->tm_mon,
    3303             :                                                   tm->tm_mday),
    3304        6096 :                                      is_interval)) % 100);
    3305        3048 :                 if (S_THth(n->suffix))
    3306           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3307        3048 :                 s += strlen(s);
    3308        3048 :                 break;
    3309        3048 :             case DCH_Y:
    3310             :             case DCH_I:
    3311        3048 :                 sprintf(s, "%1d",
    3312        3048 :                         (n->key->id == DCH_Y ?
    3313        3048 :                          ADJUST_YEAR(tm->tm_year, is_interval) :
    3314        3048 :                          ADJUST_YEAR(date2isoyear(tm->tm_year,
    3315             :                                                   tm->tm_mon,
    3316             :                                                   tm->tm_mday),
    3317        6096 :                                      is_interval)) % 10);
    3318        3048 :                 if (S_THth(n->suffix))
    3319           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3320        3048 :                 s += strlen(s);
    3321        3048 :                 break;
    3322        1848 :             case DCH_RM:
    3323             :                 /* FALLTHROUGH */
    3324             :             case DCH_rm:
    3325             : 
    3326             :                 /*
    3327             :                  * For intervals, values like '12 month' will be reduced to 0
    3328             :                  * month and some years.  These should be processed.
    3329             :                  */
    3330        1848 :                 if (!tm->tm_mon && !tm->tm_year)
    3331             :                     break;
    3332             :                 else
    3333             :                 {
    3334        1836 :                     int         mon = 0;
    3335             :                     const char *const *months;
    3336             : 
    3337        1836 :                     if (n->key->id == DCH_RM)
    3338        1680 :                         months = rm_months_upper;
    3339             :                     else
    3340         156 :                         months = rm_months_lower;
    3341             : 
    3342             :                     /*
    3343             :                      * Compute the position in the roman-numeral array.  Note
    3344             :                      * that the contents of the array are reversed, December
    3345             :                      * being first and January last.
    3346             :                      */
    3347        1836 :                     if (tm->tm_mon == 0)
    3348             :                     {
    3349             :                         /*
    3350             :                          * This case is special, and tracks the case of full
    3351             :                          * interval years.
    3352             :                          */
    3353          24 :                         mon = tm->tm_year >= 0 ? 0 : MONTHS_PER_YEAR - 1;
    3354             :                     }
    3355        1812 :                     else if (tm->tm_mon < 0)
    3356             :                     {
    3357             :                         /*
    3358             :                          * Negative case.  In this case, the calculation is
    3359             :                          * reversed, where -1 means December, -2 November,
    3360             :                          * etc.
    3361             :                          */
    3362         144 :                         mon = -1 * (tm->tm_mon + 1);
    3363             :                     }
    3364             :                     else
    3365             :                     {
    3366             :                         /*
    3367             :                          * Common case, with a strictly positive value.  The
    3368             :                          * position in the array matches with the value of
    3369             :                          * tm_mon.
    3370             :                          */
    3371        1668 :                         mon = MONTHS_PER_YEAR - tm->tm_mon;
    3372             :                     }
    3373             : 
    3374        1836 :                     sprintf(s, "%*s", S_FM(n->suffix) ? 0 : -4,
    3375        1836 :                             months[mon]);
    3376        1836 :                     s += strlen(s);
    3377             :                 }
    3378        1836 :                 break;
    3379           0 :             case DCH_W:
    3380           0 :                 sprintf(s, "%d", (tm->tm_mday - 1) / 7 + 1);
    3381           0 :                 if (S_THth(n->suffix))
    3382           0 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3383           0 :                 s += strlen(s);
    3384           0 :                 break;
    3385        2286 :             case DCH_J:
    3386        2286 :                 sprintf(s, "%d", date2j(tm->tm_year, tm->tm_mon, tm->tm_mday));
    3387        2286 :                 if (S_THth(n->suffix))
    3388         762 :                     str_numth(s, s, S_TH_TYPE(n->suffix));
    3389        2286 :                 s += strlen(s);
    3390        2286 :                 break;
    3391             :         }
    3392      176400 :     }
    3393             : 
    3394        9098 :     *s = '\0';
    3395        9098 : }
    3396             : 
    3397             : /*
    3398             :  * Process the string 'in' as denoted by the array of FormatNodes 'node[]'.
    3399             :  * The TmFromChar struct pointed to by 'out' is populated with the results.
    3400             :  *
    3401             :  * 'collid' identifies the collation to use, if needed.
    3402             :  * 'std' specifies standard parsing mode.
    3403             :  *
    3404             :  * If escontext points to an ErrorSaveContext, data errors will be reported
    3405             :  * by filling that struct; the caller must test SOFT_ERROR_OCCURRED() to see
    3406             :  * whether an error occurred.  Otherwise, errors are thrown.
    3407             :  *
    3408             :  * Note: we currently don't have any to_interval() function, so there
    3409             :  * is no need here for INVALID_FOR_INTERVAL checks.
    3410             :  */
    3411             : static void
    3412       39926 : DCH_from_char(FormatNode *node, const char *in, TmFromChar *out,
    3413             :               Oid collid, bool std, Node *escontext)
    3414             : {
    3415             :     FormatNode *n;
    3416             :     const char *s;
    3417             :     int         len,
    3418             :                 value;
    3419       39926 :     bool        fx_mode = std;
    3420             : 
    3421             :     /* number of extra skipped characters (more than given in format string) */
    3422       39926 :     int         extra_skip = 0;
    3423             : 
    3424             :     /* cache localized days and months */
    3425       39926 :     cache_locale_time();
    3426             : 
    3427      240008 :     for (n = node, s = in; n->type != NODE_TYPE_END && *s != '\0'; n++)
    3428             :     {
    3429             :         /*
    3430             :          * Ignore spaces at the beginning of the string and before fields when
    3431             :          * not in FX (fixed width) mode.
    3432             :          */
    3433      221270 :         if (!fx_mode && (n->type != NODE_TYPE_ACTION || n->key->id != DCH_FX) &&
    3434        8930 :             (n->type == NODE_TYPE_ACTION || n == node))
    3435             :         {
    3436        4916 :             while (*s != '\0' && isspace((unsigned char) *s))
    3437             :             {
    3438          84 :                 s++;
    3439          84 :                 extra_skip++;
    3440             :             }
    3441             :         }
    3442             : 
    3443      221270 :         if (n->type == NODE_TYPE_SPACE || n->type == NODE_TYPE_SEPARATOR)
    3444             :         {
    3445       96090 :             if (std)
    3446             :             {
    3447             :                 /*
    3448             :                  * Standard mode requires strict matching between format
    3449             :                  * string separators/spaces and input string.
    3450             :                  */
    3451             :                 Assert(n->character[0] && !n->character[1]);
    3452             : 
    3453       92400 :                 if (*s == n->character[0])
    3454       74760 :                     s++;
    3455             :                 else
    3456       30720 :                     ereturn(escontext,,
    3457             :                             (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    3458             :                              errmsg("unmatched format separator \"%c\"",
    3459             :                                     n->character[0])));
    3460             :             }
    3461        3690 :             else if (!fx_mode)
    3462             :             {
    3463             :                 /*
    3464             :                  * In non FX (fixed format) mode one format string space or
    3465             :                  * separator match to one space or separator in input string.
    3466             :                  * Or match nothing if there is no space or separator in the
    3467             :                  * current position of input string.
    3468             :                  */
    3469        3666 :                 extra_skip--;
    3470        3666 :                 if (isspace((unsigned char) *s) || is_separator_char(s))
    3471             :                 {
    3472        2634 :                     s++;
    3473        2634 :                     extra_skip++;
    3474             :                 }
    3475             :             }
    3476             :             else
    3477             :             {
    3478             :                 /*
    3479             :                  * In FX mode, on format string space or separator we consume
    3480             :                  * exactly one character from input string.  Notice we don't
    3481             :                  * insist that the consumed character match the format's
    3482             :                  * character.
    3483             :                  */
    3484          24 :                 s += pg_mblen(s);
    3485             :             }
    3486       78450 :             continue;
    3487             :         }
    3488      125180 :         else if (n->type != NODE_TYPE_ACTION)
    3489             :         {
    3490             :             /*
    3491             :              * Text character, so consume one character from input string.
    3492             :              * Notice we don't insist that the consumed character match the
    3493             :              * format's character.
    3494             :              */
    3495        3138 :             if (!fx_mode)
    3496             :             {
    3497             :                 /*
    3498             :                  * In non FX mode we might have skipped some extra characters
    3499             :                  * (more than specified in format string) before.  In this
    3500             :                  * case we don't skip input string character, because it might
    3501             :                  * be part of field.
    3502             :                  */
    3503         438 :                 if (extra_skip > 0)
    3504          24 :                     extra_skip--;
    3505             :                 else
    3506         414 :                     s += pg_mblen(s);
    3507             :             }
    3508             :             else
    3509             :             {
    3510        2700 :                 int         chlen = pg_mblen(s);
    3511             : 
    3512             :                 /*
    3513             :                  * Standard mode requires strict match of format characters.
    3514             :                  */
    3515        2700 :                 if (std && n->type == NODE_TYPE_CHAR &&
    3516        2700 :                     strncmp(s, n->character, chlen) != 0)
    3517        2664 :                     ereturn(escontext,,
    3518             :                             (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    3519             :                              errmsg("unmatched format character \"%s\"",
    3520             :                                     n->character)));
    3521             : 
    3522          36 :                 s += chlen;
    3523             :             }
    3524         474 :             continue;
    3525             :         }
    3526             : 
    3527      122042 :         if (!from_char_set_mode(out, n->key->date_mode, escontext))
    3528           0 :             return;
    3529             : 
    3530      122036 :         switch (n->key->id)
    3531             :         {
    3532          12 :             case DCH_FX:
    3533          12 :                 fx_mode = true;
    3534          12 :                 break;
    3535          12 :             case DCH_A_M:
    3536             :             case DCH_P_M:
    3537             :             case DCH_a_m:
    3538             :             case DCH_p_m:
    3539          12 :                 if (!from_char_seq_search(&value, &s, ampm_strings_long,
    3540             :                                           NULL, InvalidOid,
    3541             :                                           n, escontext))
    3542           0 :                     return;
    3543          12 :                 if (!from_char_set_int(&out->pm, value % 2, n, escontext))
    3544           0 :                     return;
    3545          12 :                 out->clock = CLOCK_12_HOUR;
    3546          12 :                 break;
    3547          12 :             case DCH_AM:
    3548             :             case DCH_PM:
    3549             :             case DCH_am:
    3550             :             case DCH_pm:
    3551          12 :                 if (!from_char_seq_search(&value, &s, ampm_strings,
    3552             :                                           NULL, InvalidOid,
    3553             :                                           n, escontext))
    3554           0 :                     return;
    3555          12 :                 if (!from_char_set_int(&out->pm, value % 2, n, escontext))
    3556           0 :                     return;
    3557          12 :                 out->clock = CLOCK_12_HOUR;
    3558          12 :                 break;
    3559         144 :             case DCH_HH:
    3560             :             case DCH_HH12:
    3561         144 :                 if (from_char_parse_int_len(&out->hh, &s, 2, n, escontext) < 0)
    3562           0 :                     return;
    3563         144 :                 out->clock = CLOCK_12_HOUR;
    3564         144 :                 SKIP_THth(s, n->suffix);
    3565         144 :                 break;
    3566       29316 :             case DCH_HH24:
    3567       29316 :                 if (from_char_parse_int_len(&out->hh, &s, 2, n, escontext) < 0)
    3568         144 :                     return;
    3569       29166 :                 SKIP_THth(s, n->suffix);
    3570       29166 :                 break;
    3571       16998 :             case DCH_MI:
    3572       16998 :                 if (from_char_parse_int(&out->mi, &s, n, escontext) < 0)
    3573           0 :                     return;
    3574       16998 :                 SKIP_THth(s, n->suffix);
    3575       16998 :                 break;
    3576       15612 :             case DCH_SS:
    3577       15612 :                 if (from_char_parse_int(&out->ss, &s, n, escontext) < 0)
    3578           0 :                     return;
    3579       15612 :                 SKIP_THth(s, n->suffix);
    3580       15612 :                 break;
    3581           6 :             case DCH_MS:        /* millisecond */
    3582           6 :                 len = from_char_parse_int_len(&out->ms, &s, 3, n, escontext);
    3583           6 :                 if (len < 0)
    3584           0 :                     return;
    3585             : 
    3586             :                 /*
    3587             :                  * 25 is 0.25 and 250 is 0.25 too; 025 is 0.025 and not 0.25
    3588             :                  */
    3589          12 :                 out->ms *= len == 1 ? 100 :
    3590           6 :                     len == 2 ? 10 : 1;
    3591             : 
    3592           6 :                 SKIP_THth(s, n->suffix);
    3593           6 :                 break;
    3594         222 :             case DCH_FF1:
    3595             :             case DCH_FF2:
    3596             :             case DCH_FF3:
    3597             :             case DCH_FF4:
    3598             :             case DCH_FF5:
    3599             :             case DCH_FF6:
    3600         222 :                 out->ff = n->key->id - DCH_FF1 + 1;
    3601             :                 /* FALLTHROUGH */
    3602        1296 :             case DCH_US:        /* microsecond */
    3603        1296 :                 len = from_char_parse_int_len(&out->us, &s,
    3604        1296 :                                               n->key->id == DCH_US ? 6 :
    3605             :                                               out->ff, n, escontext);
    3606        1296 :                 if (len < 0)
    3607           0 :                     return;
    3608             : 
    3609        2514 :                 out->us *= len == 1 ? 100000 :
    3610        2400 :                     len == 2 ? 10000 :
    3611        1452 :                     len == 3 ? 1000 :
    3612         384 :                     len == 4 ? 100 :
    3613         114 :                     len == 5 ? 10 : 1;
    3614             : 
    3615        1296 :                 SKIP_THth(s, n->suffix);
    3616        1296 :                 break;
    3617          24 :             case DCH_SSSS:
    3618          24 :                 if (from_char_parse_int(&out->ssss, &s, n, escontext) < 0)
    3619           0 :                     return;
    3620          24 :                 SKIP_THth(s, n->suffix);
    3621          24 :                 break;
    3622        3534 :             case DCH_tz:
    3623             :             case DCH_TZ:
    3624             :                 {
    3625             :                     int         tzlen;
    3626             : 
    3627        3534 :                     tzlen = DecodeTimezoneAbbrevPrefix(s,
    3628             :                                                        &out->gmtoffset,
    3629             :                                                        &out->tzp);
    3630        3534 :                     if (tzlen > 0)
    3631             :                     {
    3632          30 :                         out->has_tz = true;
    3633             :                         /* we only need the zone abbrev for DYNTZ case */
    3634          30 :                         if (out->tzp)
    3635           6 :                             out->abbrev = pnstrdup(s, tzlen);
    3636          30 :                         out->tzsign = 0; /* drop any earlier TZH/TZM info */
    3637          30 :                         s += tzlen;
    3638          30 :                         break;
    3639             :                     }
    3640        3504 :                     else if (isalpha((unsigned char) *s))
    3641             :                     {
    3642             :                         /*
    3643             :                          * It doesn't match any abbreviation, but it starts
    3644             :                          * with a letter.  OF format certainly won't succeed;
    3645             :                          * assume it's a misspelled abbreviation and complain
    3646             :                          * accordingly.
    3647             :                          */
    3648           6 :                         ereturn(escontext,,
    3649             :                                 (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    3650             :                                  errmsg("invalid value \"%s\" for \"%s\"",
    3651             :                                         s, n->key->name),
    3652             :                                  errdetail("Time zone abbreviation is not recognized.")));
    3653             :                     }
    3654             :                     /* otherwise parse it like OF */
    3655             :                 }
    3656             :                 /* FALLTHROUGH */
    3657             :             case DCH_OF:
    3658             :                 /* OF is equivalent to TZH or TZH:TZM */
    3659             :                 /* see TZH comments below */
    3660        3522 :                 if (*s == '+' || *s == '-' || *s == ' ')
    3661             :                 {
    3662        3162 :                     out->tzsign = *s == '-' ? -1 : +1;
    3663        3162 :                     s++;
    3664             :                 }
    3665             :                 else
    3666             :                 {
    3667         360 :                     if (extra_skip > 0 && *(s - 1) == '-')
    3668          12 :                         out->tzsign = -1;
    3669             :                     else
    3670         348 :                         out->tzsign = +1;
    3671             :                 }
    3672        3522 :                 if (from_char_parse_int_len(&out->tzh, &s, 2, n, escontext) < 0)
    3673         318 :                     return;
    3674        3192 :                 if (*s == ':')
    3675             :                 {
    3676         312 :                     s++;
    3677         312 :                     if (from_char_parse_int_len(&out->tzm, &s, 2, n,
    3678             :                                                 escontext) < 0)
    3679           0 :                         return;
    3680             :                 }
    3681        3186 :                 break;
    3682         774 :             case DCH_TZH:
    3683             : 
    3684             :                 /*
    3685             :                  * Value of TZH might be negative.  And the issue is that we
    3686             :                  * might swallow minus sign as the separator.  So, if we have
    3687             :                  * skipped more characters than specified in the format
    3688             :                  * string, then we consider prepending last skipped minus to
    3689             :                  * TZH.
    3690             :                  */
    3691         774 :                 if (*s == '+' || *s == '-' || *s == ' ')
    3692             :                 {
    3693         738 :                     out->tzsign = *s == '-' ? -1 : +1;
    3694         738 :                     s++;
    3695             :                 }
    3696             :                 else
    3697             :                 {
    3698          36 :                     if (extra_skip > 0 && *(s - 1) == '-')
    3699          18 :                         out->tzsign = -1;
    3700             :                     else
    3701          18 :                         out->tzsign = +1;
    3702             :                 }
    3703             : 
    3704         774 :                 if (from_char_parse_int_len(&out->tzh, &s, 2, n, escontext) < 0)
    3705           0 :                     return;
    3706         774 :                 break;
    3707          78 :             case DCH_TZM:
    3708             :                 /* assign positive timezone sign if TZH was not seen before */
    3709          78 :                 if (!out->tzsign)
    3710           6 :                     out->tzsign = +1;
    3711          78 :                 if (from_char_parse_int_len(&out->tzm, &s, 2, n, escontext) < 0)
    3712           0 :                     return;
    3713          78 :                 break;
    3714          12 :             case DCH_A_D:
    3715             :             case DCH_B_C:
    3716             :             case DCH_a_d:
    3717             :             case DCH_b_c:
    3718          12 :                 if (!from_char_seq_search(&value, &s, adbc_strings_long,
    3719             :                                           NULL, InvalidOid,
    3720             :                                           n, escontext))
    3721           0 :                     return;
    3722          12 :                 if (!from_char_set_int(&out->bc, value % 2, n, escontext))
    3723           0 :                     return;
    3724          12 :                 break;
    3725          36 :             case DCH_AD:
    3726             :             case DCH_BC:
    3727             :             case DCH_ad:
    3728             :             case DCH_bc:
    3729          36 :                 if (!from_char_seq_search(&value, &s, adbc_strings,
    3730             :                                           NULL, InvalidOid,
    3731             :                                           n, escontext))
    3732           0 :                     return;
    3733          36 :                 if (!from_char_set_int(&out->bc, value % 2, n, escontext))
    3734           0 :                     return;
    3735          36 :                 break;
    3736          18 :             case DCH_MONTH:
    3737             :             case DCH_Month:
    3738             :             case DCH_month:
    3739          18 :                 if (!from_char_seq_search(&value, &s, months_full,
    3740          18 :                                           S_TM(n->suffix) ? localized_full_months : NULL,
    3741             :                                           collid,
    3742             :                                           n, escontext))
    3743           0 :                     return;
    3744          18 :                 if (!from_char_set_int(&out->mm, value + 1, n, escontext))
    3745           0 :                     return;
    3746          18 :                 break;
    3747         120 :             case DCH_MON:
    3748             :             case DCH_Mon:
    3749             :             case DCH_mon:
    3750         120 :                 if (!from_char_seq_search(&value, &s, months,
    3751         120 :                                           S_TM(n->suffix) ? localized_abbrev_months : NULL,
    3752             :                                           collid,
    3753             :                                           n, escontext))
    3754           0 :                     return;
    3755         108 :                 if (!from_char_set_int(&out->mm, value + 1, n, escontext))
    3756           0 :                     return;
    3757         102 :                 break;
    3758       16902 :             case DCH_MM:
    3759       16902 :                 if (from_char_parse_int(&out->mm, &s, n, escontext) < 0)
    3760           0 :                     return;
    3761       16884 :                 SKIP_THth(s, n->suffix);
    3762       16884 :                 break;
    3763           6 :             case DCH_DAY:
    3764             :             case DCH_Day:
    3765             :             case DCH_day:
    3766           6 :                 if (!from_char_seq_search(&value, &s, days,
    3767           6 :                                           S_TM(n->suffix) ? localized_full_days : NULL,
    3768             :                                           collid,
    3769             :                                           n, escontext))
    3770           0 :                     return;
    3771           6 :                 if (!from_char_set_int(&out->d, value, n, escontext))
    3772           0 :                     return;
    3773           6 :                 out->d++;
    3774           6 :                 break;
    3775          18 :             case DCH_DY:
    3776             :             case DCH_Dy:
    3777             :             case DCH_dy:
    3778          18 :                 if (!from_char_seq_search(&value, &s, days_short,
    3779          18 :                                           S_TM(n->suffix) ? localized_abbrev_days : NULL,
    3780             :                                           collid,
    3781             :                                           n, escontext))
    3782           0 :                     return;
    3783          18 :                 if (!from_char_set_int(&out->d, value, n, escontext))
    3784           0 :                     return;
    3785          18 :                 out->d++;
    3786          18 :                 break;
    3787          36 :             case DCH_DDD:
    3788          36 :                 if (from_char_parse_int(&out->ddd, &s, n, escontext) < 0)
    3789           0 :                     return;
    3790          36 :                 SKIP_THth(s, n->suffix);
    3791          36 :                 break;
    3792           6 :             case DCH_IDDD:
    3793           6 :                 if (from_char_parse_int_len(&out->ddd, &s, 3, n, escontext) < 0)
    3794           0 :                     return;
    3795           6 :                 SKIP_THth(s, n->suffix);
    3796           6 :                 break;
    3797       16970 :             case DCH_DD:
    3798       16970 :                 if (from_char_parse_int(&out->dd, &s, n, escontext) < 0)
    3799           0 :                     return;
    3800       16956 :                 SKIP_THth(s, n->suffix);
    3801       16956 :                 break;
    3802           6 :             case DCH_D:
    3803           6 :                 if (from_char_parse_int(&out->d, &s, n, escontext) < 0)
    3804           0 :                     return;
    3805           6 :                 SKIP_THth(s, n->suffix);
    3806           6 :                 break;
    3807          24 :             case DCH_ID:
    3808          24 :                 if (from_char_parse_int_len(&out->d, &s, 1, n, escontext) < 0)
    3809           0 :                     return;
    3810             :                 /* Shift numbering to match Gregorian where Sunday = 1 */
    3811          24 :                 if (++out->d > 7)
    3812          24 :                     out->d = 1;
    3813          24 :                 SKIP_THth(s, n->suffix);
    3814          24 :                 break;
    3815          30 :             case DCH_WW:
    3816             :             case DCH_IW:
    3817          30 :                 if (from_char_parse_int(&out->ww, &s, n, escontext) < 0)
    3818           0 :                     return;
    3819          30 :                 SKIP_THth(s, n->suffix);
    3820          30 :                 break;
    3821           6 :             case DCH_Q:
    3822             : 
    3823             :                 /*
    3824             :                  * We ignore 'Q' when converting to date because it is unclear
    3825             :                  * which date in the quarter to use, and some people specify
    3826             :                  * both quarter and month, so if it was honored it might
    3827             :                  * conflict with the supplied month. That is also why we don't
    3828             :                  * throw an error.
    3829             :                  *
    3830             :                  * We still parse the source string for an integer, but it
    3831             :                  * isn't stored anywhere in 'out'.
    3832             :                  */
    3833           6 :                 if (from_char_parse_int((int *) NULL, &s, n, escontext) < 0)
    3834           0 :                     return;
    3835           6 :                 SKIP_THth(s, n->suffix);
    3836           6 :                 break;
    3837           6 :             case DCH_CC:
    3838           6 :                 if (from_char_parse_int(&out->cc, &s, n, escontext) < 0)
    3839           0 :                     return;
    3840           6 :                 SKIP_THth(s, n->suffix);
    3841           6 :                 break;
    3842           6 :             case DCH_Y_YYY:
    3843             :                 {
    3844             :                     int         matched,
    3845             :                                 years,
    3846             :                                 millennia,
    3847             :                                 nch;
    3848             : 
    3849           6 :                     matched = sscanf(s, "%d,%03d%n", &millennia, &years, &nch);
    3850           6 :                     if (matched < 2)
    3851           0 :                         ereturn(escontext,,
    3852             :                                 (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    3853             :                                  errmsg("invalid input string for \"Y,YYY\"")));
    3854           6 :                     years += (millennia * 1000);
    3855           6 :                     if (!from_char_set_int(&out->year, years, n, escontext))
    3856           0 :                         return;
    3857           6 :                     out->yysz = 4;
    3858           6 :                     s += nch;
    3859           6 :                     SKIP_THth(s, n->suffix);
    3860             :                 }
    3861           6 :                 break;
    3862       19902 :             case DCH_YYYY:
    3863             :             case DCH_IYYY:
    3864       19902 :                 if (from_char_parse_int(&out->year, &s, n, escontext) < 0)
    3865         324 :                     return;
    3866       19566 :                 out->yysz = 4;
    3867       19566 :                 SKIP_THth(s, n->suffix);
    3868       19566 :                 break;
    3869          12 :             case DCH_YYY:
    3870             :             case DCH_IYY:
    3871          12 :                 len = from_char_parse_int(&out->year, &s, n, escontext);
    3872          12 :                 if (len < 0)
    3873           0 :                     return;
    3874          12 :                 if (len < 4)
    3875          12 :                     out->year = adjust_partial_year_to_2020(out->year);
    3876          12 :                 out->yysz = 3;
    3877          12 :                 SKIP_THth(s, n->suffix);
    3878          12 :                 break;
    3879          48 :             case DCH_YY:
    3880             :             case DCH_IY:
    3881          48 :                 len = from_char_parse_int(&out->year, &s, n, escontext);
    3882          48 :                 if (len < 0)
    3883           0 :                     return;
    3884          48 :                 if (len < 4)
    3885          48 :                     out->year = adjust_partial_year_to_2020(out->year);
    3886          48 :                 out->yysz = 2;
    3887          48 :                 SKIP_THth(s, n->suffix);
    3888          48 :                 break;
    3889          12 :             case DCH_Y:
    3890             :             case DCH_I:
    3891          12 :                 len = from_char_parse_int(&out->year, &s, n, escontext);
    3892          12 :                 if (len < 0)
    3893           0 :                     return;
    3894          12 :                 if (len < 4)
    3895          12 :                     out->year = adjust_partial_year_to_2020(out->year);
    3896          12 :                 out->yysz = 1;
    3897          12 :                 SKIP_THth(s, n->suffix);
    3898          12 :                 break;
    3899           6 :             case DCH_RM:
    3900             :             case DCH_rm:
    3901           6 :                 if (!from_char_seq_search(&value, &s, rm_months_lower,
    3902             :                                           NULL, InvalidOid,
    3903             :                                           n, escontext))
    3904           0 :                     return;
    3905           6 :                 if (!from_char_set_int(&out->mm, MONTHS_PER_YEAR - value, n,
    3906             :                                        escontext))
    3907           0 :                     return;
    3908           6 :                 break;
    3909           6 :             case DCH_W:
    3910           6 :                 if (from_char_parse_int(&out->w, &s, n, escontext) < 0)
    3911           0 :                     return;
    3912           6 :                 SKIP_THth(s, n->suffix);
    3913           6 :                 break;
    3914           6 :             case DCH_J:
    3915           6 :                 if (from_char_parse_int(&out->j, &s, n, escontext) < 0)
    3916           0 :                     return;
    3917           6 :                 SKIP_THth(s, n->suffix);
    3918           6 :                 break;
    3919             :         }
    3920             : 
    3921             :         /* Ignore all spaces after fields */
    3922      121158 :         if (!fx_mode)
    3923             :         {
    3924        4734 :             extra_skip = 0;
    3925        5904 :             while (*s != '\0' && isspace((unsigned char) *s))
    3926             :             {
    3927        1170 :                 s++;
    3928        1170 :                 extra_skip++;
    3929             :             }
    3930             :         }
    3931             :     }
    3932             : 
    3933             :     /*
    3934             :      * Standard parsing mode doesn't allow unmatched format patterns or
    3935             :      * trailing characters in the input string.
    3936             :      */
    3937       18738 :     if (std)
    3938             :     {
    3939       17790 :         if (n->type != NODE_TYPE_END)
    3940        6588 :             ereturn(escontext,,
    3941             :                     (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    3942             :                      errmsg("input string is too short for datetime format")));
    3943             : 
    3944       14256 :         while (*s != '\0' && isspace((unsigned char) *s))
    3945        3054 :             s++;
    3946             : 
    3947       11202 :         if (*s != '\0')
    3948        3090 :             ereturn(escontext,,
    3949             :                     (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    3950             :                      errmsg("trailing characters remain in input string after datetime format")));
    3951             :     }
    3952             : }
    3953             : 
    3954             : /*
    3955             :  * The invariant for DCH cache entry management is that DCHCounter is equal
    3956             :  * to the maximum age value among the existing entries, and we increment it
    3957             :  * whenever an access occurs.  If we approach overflow, deal with that by
    3958             :  * halving all the age values, so that we retain a fairly accurate idea of
    3959             :  * which entries are oldest.
    3960             :  */
    3961             : static inline void
    3962       49952 : DCH_prevent_counter_overflow(void)
    3963             : {
    3964       49952 :     if (DCHCounter >= (INT_MAX - 1))
    3965             :     {
    3966           0 :         for (int i = 0; i < n_DCHCache; i++)
    3967           0 :             DCHCache[i]->age >>= 1;
    3968           0 :         DCHCounter >>= 1;
    3969             :     }
    3970       49952 : }
    3971             : 
    3972             : /*
    3973             :  * Get mask of date/time/zone components present in format nodes.
    3974             :  */
    3975             : static int
    3976        8178 : DCH_datetime_type(FormatNode *node)
    3977             : {
    3978             :     FormatNode *n;
    3979        8178 :     int         flags = 0;
    3980             : 
    3981       75192 :     for (n = node; n->type != NODE_TYPE_END; n++)
    3982             :     {
    3983       67014 :         if (n->type != NODE_TYPE_ACTION)
    3984       27834 :             continue;
    3985             : 
    3986       39180 :         switch (n->key->id)
    3987             :         {
    3988           0 :             case DCH_FX:
    3989           0 :                 break;
    3990       20130 :             case DCH_A_M:
    3991             :             case DCH_P_M:
    3992             :             case DCH_a_m:
    3993             :             case DCH_p_m:
    3994             :             case DCH_AM:
    3995             :             case DCH_PM:
    3996             :             case DCH_am:
    3997             :             case DCH_pm:
    3998             :             case DCH_HH:
    3999             :             case DCH_HH12:
    4000             :             case DCH_HH24:
    4001             :             case DCH_MI:
    4002             :             case DCH_SS:
    4003             :             case DCH_MS:        /* millisecond */
    4004             :             case DCH_US:        /* microsecond */
    4005             :             case DCH_FF1:
    4006             :             case DCH_FF2:
    4007             :             case DCH_FF3:
    4008             :             case DCH_FF4:
    4009             :             case DCH_FF5:
    4010             :             case DCH_FF6:
    4011             :             case DCH_SSSS:
    4012       20130 :                 flags |= DCH_TIMED;
    4013       20130 :                 break;
    4014        4002 :             case DCH_tz:
    4015             :             case DCH_TZ:
    4016             :             case DCH_OF:
    4017             :             case DCH_TZH:
    4018             :             case DCH_TZM:
    4019        4002 :                 flags |= DCH_ZONED;
    4020        4002 :                 break;
    4021       15048 :             case DCH_A_D:
    4022             :             case DCH_B_C:
    4023             :             case DCH_a_d:
    4024             :             case DCH_b_c:
    4025             :             case DCH_AD:
    4026             :             case DCH_BC:
    4027             :             case DCH_ad:
    4028             :             case DCH_bc:
    4029             :             case DCH_MONTH:
    4030             :             case DCH_Month:
    4031             :             case DCH_month:
    4032             :             case DCH_MON:
    4033             :             case DCH_Mon:
    4034             :             case DCH_mon:
    4035             :             case DCH_MM:
    4036             :             case DCH_DAY:
    4037             :             case DCH_Day:
    4038             :             case DCH_day:
    4039             :             case DCH_DY:
    4040             :             case DCH_Dy:
    4041             :             case DCH_dy:
    4042             :             case DCH_DDD:
    4043             :             case DCH_IDDD:
    4044             :             case DCH_DD:
    4045             :             case DCH_D:
    4046             :             case DCH_ID:
    4047             :             case DCH_WW:
    4048             :             case DCH_Q:
    4049             :             case DCH_CC:
    4050             :             case DCH_Y_YYY:
    4051             :             case DCH_YYYY:
    4052             :             case DCH_IYYY:
    4053             :             case DCH_YYY:
    4054             :             case DCH_IYY:
    4055             :             case DCH_YY:
    4056             :             case DCH_IY:
    4057             :             case DCH_Y:
    4058             :             case DCH_I:
    4059             :             case DCH_RM:
    4060             :             case DCH_rm:
    4061             :             case DCH_W:
    4062             :             case DCH_J:
    4063       15048 :                 flags |= DCH_DATED;
    4064       15048 :                 break;
    4065             :         }
    4066       67014 :     }
    4067             : 
    4068        8178 :     return flags;
    4069             : }
    4070             : 
    4071             : /* select a DCHCacheEntry to hold the given format picture */
    4072             : static DCHCacheEntry *
    4073         856 : DCH_cache_getnew(const char *str, bool std)
    4074             : {
    4075             :     DCHCacheEntry *ent;
    4076             : 
    4077             :     /* Ensure we can advance DCHCounter below */
    4078         856 :     DCH_prevent_counter_overflow();
    4079             : 
    4080             :     /*
    4081             :      * If cache is full, remove oldest entry (or recycle first not-valid one)
    4082             :      */
    4083         856 :     if (n_DCHCache >= DCH_CACHE_ENTRIES)
    4084             :     {
    4085         384 :         DCHCacheEntry *old = DCHCache[0];
    4086             : 
    4087             : #ifdef DEBUG_TO_FROM_CHAR
    4088             :         elog(DEBUG_elog_output, "cache is full (%d)", n_DCHCache);
    4089             : #endif
    4090         384 :         if (old->valid)
    4091             :         {
    4092        7638 :             for (int i = 1; i < DCH_CACHE_ENTRIES; i++)
    4093             :             {
    4094        7260 :                 ent = DCHCache[i];
    4095        7260 :                 if (!ent->valid)
    4096             :                 {
    4097           6 :                     old = ent;
    4098           6 :                     break;
    4099             :                 }
    4100        7254 :                 if (ent->age < old->age)
    4101         480 :                     old = ent;
    4102             :             }
    4103             :         }
    4104             : #ifdef DEBUG_TO_FROM_CHAR
    4105             :         elog(DEBUG_elog_output, "OLD: '%s' AGE: %d", old->str, old->age);
    4106             : #endif
    4107         384 :         old->valid = false;
    4108         384 :         strlcpy(old->str, str, DCH_CACHE_SIZE + 1);
    4109         384 :         old->age = (++DCHCounter);
    4110             :         /* caller is expected to fill format, then set valid */
    4111         384 :         return old;
    4112             :     }
    4113             :     else
    4114             :     {
    4115             : #ifdef DEBUG_TO_FROM_CHAR
    4116             :         elog(DEBUG_elog_output, "NEW (%d)", n_DCHCache);
    4117             : #endif
    4118             :         Assert(DCHCache[n_DCHCache] == NULL);
    4119         472 :         DCHCache[n_DCHCache] = ent = (DCHCacheEntry *)
    4120         472 :             MemoryContextAllocZero(TopMemoryContext, sizeof(DCHCacheEntry));
    4121         472 :         ent->valid = false;
    4122         472 :         strlcpy(ent->str, str, DCH_CACHE_SIZE + 1);
    4123         472 :         ent->std = std;
    4124         472 :         ent->age = (++DCHCounter);
    4125             :         /* caller is expected to fill format, then set valid */
    4126         472 :         ++n_DCHCache;
    4127         472 :         return ent;
    4128             :     }
    4129             : }
    4130             : 
    4131             : /* look for an existing DCHCacheEntry matching the given format picture */
    4132             : static DCHCacheEntry *
    4133       49096 : DCH_cache_search(const char *str, bool std)
    4134             : {
    4135             :     /* Ensure we can advance DCHCounter below */
    4136       49096 :     DCH_prevent_counter_overflow();
    4137             : 
    4138      261684 :     for (int i = 0; i < n_DCHCache; i++)
    4139             :     {
    4140      260828 :         DCHCacheEntry *ent = DCHCache[i];
    4141             : 
    4142      260828 :         if (ent->valid && strcmp(ent->str, str) == 0 && ent->std == std)
    4143             :         {
    4144       48240 :             ent->age = (++DCHCounter);
    4145       48240 :             return ent;
    4146             :         }
    4147             :     }
    4148             : 
    4149         856 :     return NULL;
    4150             : }
    4151             : 
    4152             : /* Find or create a DCHCacheEntry for the given format picture */
    4153             : static DCHCacheEntry *
    4154       49096 : DCH_cache_fetch(const char *str, bool std)
    4155             : {
    4156             :     DCHCacheEntry *ent;
    4157             : 
    4158       49096 :     if ((ent = DCH_cache_search(str, std)) == NULL)
    4159             :     {
    4160             :         /*
    4161             :          * Not in the cache, must run parser and save a new format-picture to
    4162             :          * the cache.  Do not mark the cache entry valid until parsing
    4163             :          * succeeds.
    4164             :          */
    4165         856 :         ent = DCH_cache_getnew(str, std);
    4166             : 
    4167         856 :         parse_format(ent->format, str, DCH_keywords, DCH_suff, DCH_index,
    4168             :                      DCH_FLAG | (std ? STD_FLAG : 0), NULL);
    4169             : 
    4170         850 :         ent->valid = true;
    4171             :     }
    4172       49090 :     return ent;
    4173             : }
    4174             : 
    4175             : /*
    4176             :  * Format a date/time or interval into a string according to fmt.
    4177             :  * We parse fmt into a list of FormatNodes.  This is then passed to DCH_to_char
    4178             :  * for formatting.
    4179             :  */
    4180             : static text *
    4181        9098 : datetime_to_char_body(TmToChar *tmtc, text *fmt, bool is_interval, Oid collid)
    4182             : {
    4183             :     FormatNode *format;
    4184             :     char       *fmt_str,
    4185             :                *result;
    4186             :     bool        incache;
    4187             :     int         fmt_len;
    4188             :     text       *res;
    4189             : 
    4190             :     /*
    4191             :      * Convert fmt to C string
    4192             :      */
    4193        9098 :     fmt_str = text_to_cstring(fmt);
    4194        9098 :     fmt_len = strlen(fmt_str);
    4195             : 
    4196             :     /*
    4197             :      * Allocate workspace for result as C string
    4198             :      */
    4199        9098 :     result = palloc((fmt_len * DCH_MAX_ITEM_SIZ) + 1);
    4200        9098 :     *result = '\0';
    4201             : 
    4202        9098 :     if (fmt_len > DCH_CACHE_SIZE)
    4203             :     {
    4204             :         /*
    4205             :          * Allocate new memory if format picture is bigger than static cache
    4206             :          * and do not use cache (call parser always)
    4207             :          */
    4208           0 :         incache = false;
    4209             : 
    4210           0 :         format = (FormatNode *) palloc((fmt_len + 1) * sizeof(FormatNode));
    4211             : 
    4212           0 :         parse_format(format, fmt_str, DCH_keywords,
    4213             :                      DCH_suff, DCH_index, DCH_FLAG, NULL);
    4214             :     }
    4215             :     else
    4216             :     {
    4217             :         /*
    4218             :          * Use cache buffers
    4219             :          */
    4220        9098 :         DCHCacheEntry *ent = DCH_cache_fetch(fmt_str, false);
    4221             : 
    4222        9098 :         incache = true;
    4223        9098 :         format = ent->format;
    4224             :     }
    4225             : 
    4226             :     /* The real work is here */
    4227        9098 :     DCH_to_char(format, is_interval, tmtc, result, collid);
    4228             : 
    4229        9098 :     if (!incache)
    4230           0 :         pfree(format);
    4231             : 
    4232        9098 :     pfree(fmt_str);
    4233             : 
    4234             :     /* convert C-string result to TEXT format */
    4235        9098 :     res = cstring_to_text(result);
    4236             : 
    4237        9098 :     pfree(result);
    4238        9098 :     return res;
    4239             : }
    4240             : 
    4241             : /****************************************************************************
    4242             :  *              Public routines
    4243             :  ***************************************************************************/
    4244             : 
    4245             : /* -------------------
    4246             :  * TIMESTAMP to_char()
    4247             :  * -------------------
    4248             :  */
    4249             : Datum
    4250        4316 : timestamp_to_char(PG_FUNCTION_ARGS)
    4251             : {
    4252        4316 :     Timestamp   dt = PG_GETARG_TIMESTAMP(0);
    4253        4316 :     text       *fmt = PG_GETARG_TEXT_PP(1),
    4254             :                *res;
    4255             :     TmToChar    tmtc;
    4256             :     struct pg_tm tt;
    4257             :     struct fmt_tm *tm;
    4258             :     int         thisdate;
    4259             : 
    4260        4316 :     if (VARSIZE_ANY_EXHDR(fmt) <= 0 || TIMESTAMP_NOT_FINITE(dt))
    4261         132 :         PG_RETURN_NULL();
    4262             : 
    4263        4184 :     ZERO_tmtc(&tmtc);
    4264        4184 :     tm = tmtcTm(&tmtc);
    4265             : 
    4266        4184 :     if (timestamp2tm(dt, NULL, &tt, &tmtcFsec(&tmtc), NULL, NULL) != 0)
    4267           0 :         ereport(ERROR,
    4268             :                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    4269             :                  errmsg("timestamp out of range")));
    4270             : 
    4271             :     /* calculate wday and yday, because timestamp2tm doesn't */
    4272        4184 :     thisdate = date2j(tt.tm_year, tt.tm_mon, tt.tm_mday);
    4273        4184 :     tt.tm_wday = (thisdate + 1) % 7;
    4274        4184 :     tt.tm_yday = thisdate - date2j(tt.tm_year, 1, 1) + 1;
    4275             : 
    4276        4184 :     COPY_tm(tm, &tt);
    4277             : 
    4278        4184 :     if (!(res = datetime_to_char_body(&tmtc, fmt, false, PG_GET_COLLATION())))
    4279           0 :         PG_RETURN_NULL();
    4280             : 
    4281        4184 :     PG_RETURN_TEXT_P(res);
    4282             : }
    4283             : 
    4284             : Datum
    4285        4720 : timestamptz_to_char(PG_FUNCTION_ARGS)
    4286             : {
    4287        4720 :     TimestampTz dt = PG_GETARG_TIMESTAMP(0);
    4288        4720 :     text       *fmt = PG_GETARG_TEXT_PP(1),
    4289             :                *res;
    4290             :     TmToChar    tmtc;
    4291             :     int         tz;
    4292             :     struct pg_tm tt;
    4293             :     struct fmt_tm *tm;
    4294             :     int         thisdate;
    4295             : 
    4296        4720 :     if (VARSIZE_ANY_EXHDR(fmt) <= 0 || TIMESTAMP_NOT_FINITE(dt))
    4297         132 :         PG_RETURN_NULL();
    4298             : 
    4299        4588 :     ZERO_tmtc(&tmtc);
    4300        4588 :     tm = tmtcTm(&tmtc);
    4301             : 
    4302        4588 :     if (timestamp2tm(dt, &tz, &tt, &tmtcFsec(&tmtc), &tmtcTzn(&tmtc), NULL) != 0)
    4303           0 :         ereport(ERROR,
    4304             :                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    4305             :                  errmsg("timestamp out of range")));
    4306             : 
    4307             :     /* calculate wday and yday, because timestamp2tm doesn't */
    4308        4588 :     thisdate = date2j(tt.tm_year, tt.tm_mon, tt.tm_mday);
    4309        4588 :     tt.tm_wday = (thisdate + 1) % 7;
    4310        4588 :     tt.tm_yday = thisdate - date2j(tt.tm_year, 1, 1) + 1;
    4311             : 
    4312        4588 :     COPY_tm(tm, &tt);
    4313             : 
    4314        4588 :     if (!(res = datetime_to_char_body(&tmtc, fmt, false, PG_GET_COLLATION())))
    4315           0 :         PG_RETURN_NULL();
    4316             : 
    4317        4588 :     PG_RETURN_TEXT_P(res);
    4318             : }
    4319             : 
    4320             : 
    4321             : /* -------------------
    4322             :  * INTERVAL to_char()
    4323             :  * -------------------
    4324             :  */
    4325             : Datum
    4326         338 : interval_to_char(PG_FUNCTION_ARGS)
    4327             : {
    4328         338 :     Interval   *it = PG_GETARG_INTERVAL_P(0);
    4329         338 :     text       *fmt = PG_GETARG_TEXT_PP(1),
    4330             :                *res;
    4331             :     TmToChar    tmtc;
    4332             :     struct fmt_tm *tm;
    4333             :     struct pg_itm tt,
    4334         338 :                *itm = &tt;
    4335             : 
    4336         338 :     if (VARSIZE_ANY_EXHDR(fmt) <= 0 || INTERVAL_NOT_FINITE(it))
    4337          12 :         PG_RETURN_NULL();
    4338             : 
    4339         326 :     ZERO_tmtc(&tmtc);
    4340         326 :     tm = tmtcTm(&tmtc);
    4341             : 
    4342         326 :     interval2itm(*it, itm);
    4343         326 :     tmtc.fsec = itm->tm_usec;
    4344         326 :     tm->tm_sec = itm->tm_sec;
    4345         326 :     tm->tm_min = itm->tm_min;
    4346         326 :     tm->tm_hour = itm->tm_hour;
    4347         326 :     tm->tm_mday = itm->tm_mday;
    4348         326 :     tm->tm_mon = itm->tm_mon;
    4349         326 :     tm->tm_year = itm->tm_year;
    4350             : 
    4351             :     /* wday is meaningless, yday approximates the total span in days */
    4352         326 :     tm->tm_yday = (tm->tm_year * MONTHS_PER_YEAR + tm->tm_mon) * DAYS_PER_MONTH + tm->tm_mday;
    4353             : 
    4354         326 :     if (!(res = datetime_to_char_body(&tmtc, fmt, true, PG_GET_COLLATION())))
    4355           0 :         PG_RETURN_NULL();
    4356             : 
    4357         326 :     PG_RETURN_TEXT_P(res);
    4358             : }
    4359             : 
    4360             : /* ---------------------
    4361             :  * TO_TIMESTAMP()
    4362             :  *
    4363             :  * Make Timestamp from date_str which is formatted at argument 'fmt'
    4364             :  * ( to_timestamp is reverse to_char() )
    4365             :  * ---------------------
    4366             :  */
    4367             : Datum
    4368         858 : to_timestamp(PG_FUNCTION_ARGS)
    4369             : {
    4370         858 :     text       *date_txt = PG_GETARG_TEXT_PP(0);
    4371         858 :     text       *fmt = PG_GETARG_TEXT_PP(1);
    4372         858 :     Oid         collid = PG_GET_COLLATION();
    4373             :     Timestamp   result;
    4374             :     int         tz;
    4375             :     struct pg_tm tm;
    4376             :     struct fmt_tz ftz;
    4377             :     fsec_t      fsec;
    4378             :     int         fprec;
    4379             : 
    4380         858 :     do_to_timestamp(date_txt, fmt, collid, false,
    4381             :                     &tm, &fsec, &ftz, &fprec, NULL, NULL);
    4382             : 
    4383             :     /* Use the specified time zone, if any. */
    4384         714 :     if (ftz.has_tz)
    4385          90 :         tz = ftz.gmtoffset;
    4386             :     else
    4387         624 :         tz = DetermineTimeZoneOffset(&tm, session_timezone);
    4388             : 
    4389         714 :     if (tm2timestamp(&tm, fsec, &tz, &result) != 0)
    4390           0 :         ereport(ERROR,
    4391             :                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    4392             :                  errmsg("timestamp out of range")));
    4393             : 
    4394             :     /* Use the specified fractional precision, if any. */
    4395         714 :     if (fprec)
    4396         216 :         AdjustTimestampForTypmod(&result, fprec, NULL);
    4397             : 
    4398         714 :     PG_RETURN_TIMESTAMP(result);
    4399             : }
    4400             : 
    4401             : /* ----------
    4402             :  * TO_DATE
    4403             :  *  Make Date from date_str which is formatted at argument 'fmt'
    4404             :  * ----------
    4405             :  */
    4406             : Datum
    4407         182 : to_date(PG_FUNCTION_ARGS)
    4408             : {
    4409         182 :     text       *date_txt = PG_GETARG_TEXT_PP(0);
    4410         182 :     text       *fmt = PG_GETARG_TEXT_PP(1);
    4411         182 :     Oid         collid = PG_GET_COLLATION();
    4412             :     DateADT     result;
    4413             :     struct pg_tm tm;
    4414             :     struct fmt_tz ftz;
    4415             :     fsec_t      fsec;
    4416             : 
    4417         182 :     do_to_timestamp(date_txt, fmt, collid, false,
    4418             :                     &tm, &fsec, &ftz, NULL, NULL, NULL);
    4419             : 
    4420             :     /* Prevent overflow in Julian-day routines */
    4421         144 :     if (!IS_VALID_JULIAN(tm.tm_year, tm.tm_mon, tm.tm_mday))
    4422           0 :         ereport(ERROR,
    4423             :                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    4424             :                  errmsg("date out of range: \"%s\"",
    4425             :                         text_to_cstring(date_txt))));
    4426             : 
    4427         144 :     result = date2j(tm.tm_year, tm.tm_mon, tm.tm_mday) - POSTGRES_EPOCH_JDATE;
    4428             : 
    4429             :     /* Now check for just-out-of-range dates */
    4430         144 :     if (!IS_VALID_DATE(result))
    4431           0 :         ereport(ERROR,
    4432             :                 (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    4433             :                  errmsg("date out of range: \"%s\"",
    4434             :                         text_to_cstring(date_txt))));
    4435             : 
    4436         144 :     PG_RETURN_DATEADT(result);
    4437             : }
    4438             : 
    4439             : /*
    4440             :  * Convert the 'date_txt' input to a datetime type using argument 'fmt'
    4441             :  * as a format string.  The collation 'collid' may be used for case-folding
    4442             :  * rules in some cases.  'strict' specifies standard parsing mode.
    4443             :  *
    4444             :  * The actual data type (returned in 'typid', 'typmod') is determined by
    4445             :  * the presence of date/time/zone components in the format string.
    4446             :  *
    4447             :  * When a timezone component is present, the corresponding offset is
    4448             :  * returned in '*tz'.
    4449             :  *
    4450             :  * If escontext points to an ErrorSaveContext, data errors will be reported
    4451             :  * by filling that struct; the caller must test SOFT_ERROR_OCCURRED() to see
    4452             :  * whether an error occurred.  Otherwise, errors are thrown.
    4453             :  */
    4454             : Datum
    4455       38892 : parse_datetime(text *date_txt, text *fmt, Oid collid, bool strict,
    4456             :                Oid *typid, int32 *typmod, int *tz,
    4457             :                Node *escontext)
    4458             : {
    4459             :     struct pg_tm tm;
    4460             :     struct fmt_tz ftz;
    4461             :     fsec_t      fsec;
    4462             :     int         fprec;
    4463             :     uint32      flags;
    4464             : 
    4465       38892 :     if (!do_to_timestamp(date_txt, fmt, collid, strict,
    4466             :                          &tm, &fsec, &ftz, &fprec, &flags, escontext))
    4467       30720 :         return (Datum) 0;
    4468             : 
    4469        8112 :     *typmod = fprec ? fprec : -1;   /* fractional part precision */
    4470             : 
    4471        8112 :     if (flags & DCH_DATED)
    4472             :     {
    4473        4998 :         if (flags & DCH_TIMED)
    4474             :         {
    4475        3720 :             if (flags & DCH_ZONED)
    4476             :             {
    4477             :                 TimestampTz result;
    4478             : 
    4479        2142 :                 if (ftz.has_tz)
    4480             :                 {
    4481        2142 :                     *tz = ftz.gmtoffset;
    4482             :                 }
    4483             :                 else
    4484             :                 {
    4485             :                     /*
    4486             :                      * Time zone is present in format string, but not in input
    4487             :                      * string.  Assuming do_to_timestamp() triggers no error
    4488             :                      * this should be possible only in non-strict case.
    4489             :                      */
    4490             :                     Assert(!strict);
    4491             : 
    4492           0 :                     ereturn(escontext, (Datum) 0,
    4493             :                             (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    4494             :                              errmsg("missing time zone in input string for type timestamptz")));
    4495             :                 }
    4496             : 
    4497        2142 :                 if (tm2timestamp(&tm, fsec, tz, &result) != 0)
    4498           0 :                     ereturn(escontext, (Datum) 0,
    4499             :                             (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    4500             :                              errmsg("timestamptz out of range")));
    4501             : 
    4502        2142 :                 AdjustTimestampForTypmod(&result, *typmod, escontext);
    4503             : 
    4504        2142 :                 *typid = TIMESTAMPTZOID;
    4505        2142 :                 return TimestampTzGetDatum(result);
    4506             :             }
    4507             :             else
    4508             :             {
    4509             :                 Timestamp   result;
    4510             : 
    4511        1578 :                 if (tm2timestamp(&tm, fsec, NULL, &result) != 0)
    4512           0 :                     ereturn(escontext, (Datum) 0,
    4513             :                             (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    4514             :                              errmsg("timestamp out of range")));
    4515             : 
    4516        1578 :                 AdjustTimestampForTypmod(&result, *typmod, escontext);
    4517             : 
    4518        1578 :                 *typid = TIMESTAMPOID;
    4519        1578 :                 return TimestampGetDatum(result);
    4520             :             }
    4521             :         }
    4522             :         else
    4523             :         {
    4524        1278 :             if (flags & DCH_ZONED)
    4525             :             {
    4526           0 :                 ereturn(escontext, (Datum) 0,
    4527             :                         (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    4528             :                          errmsg("datetime format is zoned but not timed")));
    4529             :             }
    4530             :             else
    4531             :             {
    4532             :                 DateADT     result;
    4533             : 
    4534             :                 /* Prevent overflow in Julian-day routines */
    4535        1278 :                 if (!IS_VALID_JULIAN(tm.tm_year, tm.tm_mon, tm.tm_mday))
    4536           0 :                     ereturn(escontext, (Datum) 0,
    4537             :                             (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    4538             :                              errmsg("date out of range: \"%s\"",
    4539             :                                     text_to_cstring(date_txt))));
    4540             : 
    4541        1278 :                 result = date2j(tm.tm_year, tm.tm_mon, tm.tm_mday) -
    4542             :                     POSTGRES_EPOCH_JDATE;
    4543             : 
    4544             :                 /* Now check for just-out-of-range dates */
    4545        1278 :                 if (!IS_VALID_DATE(result))
    4546           0 :                     ereturn(escontext, (Datum) 0,
    4547             :                             (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    4548             :                              errmsg("date out of range: \"%s\"",
    4549             :                                     text_to_cstring(date_txt))));
    4550             : 
    4551        1278 :                 *typid = DATEOID;
    4552        1278 :                 return DateADTGetDatum(result);
    4553             :             }
    4554             :         }
    4555             :     }
    4556        3114 :     else if (flags & DCH_TIMED)
    4557             :     {
    4558        3114 :         if (flags & DCH_ZONED)
    4559             :         {
    4560        1764 :             TimeTzADT  *result = palloc(sizeof(TimeTzADT));
    4561             : 
    4562        1764 :             if (ftz.has_tz)
    4563             :             {
    4564        1764 :                 *tz = ftz.gmtoffset;
    4565             :             }
    4566             :             else
    4567             :             {
    4568             :                 /*
    4569             :                  * Time zone is present in format string, but not in input
    4570             :                  * string.  Assuming do_to_timestamp() triggers no error this
    4571             :                  * should be possible only in non-strict case.
    4572             :                  */
    4573             :                 Assert(!strict);
    4574             : 
    4575           0 :                 ereturn(escontext, (Datum) 0,
    4576             :                         (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    4577             :                          errmsg("missing time zone in input string for type timetz")));
    4578             :             }
    4579             : 
    4580        1764 :             if (tm2timetz(&tm, fsec, *tz, result) != 0)
    4581           0 :                 ereturn(escontext, (Datum) 0,
    4582             :                         (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    4583             :                          errmsg("timetz out of range")));
    4584             : 
    4585        1764 :             AdjustTimeForTypmod(&result->time, *typmod);
    4586             : 
    4587        1764 :             *typid = TIMETZOID;
    4588        1764 :             return TimeTzADTPGetDatum(result);
    4589             :         }
    4590             :         else
    4591             :         {
    4592             :             TimeADT     result;
    4593             : 
    4594        1350 :             if (tm2time(&tm, fsec, &result) != 0)
    4595           0 :                 ereturn(escontext, (Datum) 0,
    4596             :                         (errcode(ERRCODE_DATETIME_VALUE_OUT_OF_RANGE),
    4597             :                          errmsg("time out of range")));
    4598             : 
    4599        1350 :             AdjustTimeForTypmod(&result, *typmod);
    4600             : 
    4601        1350 :             *typid = TIMEOID;
    4602        1350 :             return TimeADTGetDatum(result);
    4603             :         }
    4604             :     }
    4605             :     else
    4606             :     {
    4607           0 :         ereturn(escontext, (Datum) 0,
    4608             :                 (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    4609             :                  errmsg("datetime format is not dated and not timed")));
    4610             :     }
    4611             : }
    4612             : 
    4613             : /*
    4614             :  * Parses the datetime format string in 'fmt_str' and returns true if it
    4615             :  * contains a timezone specifier, false if not.
    4616             :  */
    4617             : bool
    4618          66 : datetime_format_has_tz(const char *fmt_str)
    4619             : {
    4620             :     bool        incache;
    4621          66 :     int         fmt_len = strlen(fmt_str);
    4622             :     int         result;
    4623             :     FormatNode *format;
    4624             : 
    4625          66 :     if (fmt_len > DCH_CACHE_SIZE)
    4626             :     {
    4627             :         /*
    4628             :          * Allocate new memory if format picture is bigger than static cache
    4629             :          * and do not use cache (call parser always)
    4630             :          */
    4631           0 :         incache = false;
    4632             : 
    4633           0 :         format = (FormatNode *) palloc((fmt_len + 1) * sizeof(FormatNode));
    4634             : 
    4635           0 :         parse_format(format, fmt_str, DCH_keywords,
    4636             :                      DCH_suff, DCH_index, DCH_FLAG, NULL);
    4637             :     }
    4638             :     else
    4639             :     {
    4640             :         /*
    4641             :          * Use cache buffers
    4642             :          */
    4643          66 :         DCHCacheEntry *ent = DCH_cache_fetch(fmt_str, false);
    4644             : 
    4645          66 :         incache = true;
    4646          66 :         format = ent->format;
    4647             :     }
    4648             : 
    4649          66 :     result = DCH_datetime_type(format);
    4650             : 
    4651          66 :     if (!incache)
    4652           0 :         pfree(format);
    4653             : 
    4654          66 :     return result & DCH_ZONED;
    4655             : }
    4656             : 
    4657             : /*
    4658             :  * do_to_timestamp: shared code for to_timestamp and to_date
    4659             :  *
    4660             :  * Parse the 'date_txt' according to 'fmt', return results as a struct pg_tm,
    4661             :  * fractional seconds, struct fmt_tz, and fractional precision.
    4662             :  *
    4663             :  * 'collid' identifies the collation to use, if needed.
    4664             :  * 'std' specifies standard parsing mode.
    4665             :  *
    4666             :  * Bit mask of date/time/zone components found in 'fmt' is returned in 'flags',
    4667             :  * if that is not NULL.
    4668             :  *
    4669             :  * Returns true on success, false on failure (if escontext points to an
    4670             :  * ErrorSaveContext; otherwise errors are thrown).  Note that currently,
    4671             :  * soft-error behavior is provided for bad data but not bad format.
    4672             :  *
    4673             :  * We parse 'fmt' into a list of FormatNodes, which is then passed to
    4674             :  * DCH_from_char to populate a TmFromChar with the parsed contents of
    4675             :  * 'date_txt'.
    4676             :  *
    4677             :  * The TmFromChar is then analysed and converted into the final results in
    4678             :  * struct 'tm', 'fsec', struct 'tz', and 'fprec'.
    4679             :  */
    4680             : static bool
    4681       39932 : do_to_timestamp(text *date_txt, text *fmt, Oid collid, bool std,
    4682             :                 struct pg_tm *tm, fsec_t *fsec, struct fmt_tz *tz,
    4683             :                 int *fprec, uint32 *flags, Node *escontext)
    4684             : {
    4685       39932 :     FormatNode *format = NULL;
    4686             :     TmFromChar  tmfc;
    4687             :     int         fmt_len;
    4688             :     char       *date_str;
    4689             :     int         fmask;
    4690       39932 :     bool        incache = false;
    4691             : 
    4692             :     Assert(tm != NULL);
    4693             :     Assert(fsec != NULL);
    4694             : 
    4695       39932 :     date_str = text_to_cstring(date_txt);
    4696             : 
    4697       39932 :     ZERO_tmfc(&tmfc);
    4698       39932 :     ZERO_tm(tm);
    4699       39932 :     *fsec = 0;
    4700       39932 :     tz->has_tz = false;
    4701       39932 :     if (fprec)
    4702       39750 :         *fprec = 0;
    4703       39932 :     if (flags)
    4704       38892 :         *flags = 0;
    4705       39932 :     fmask = 0;                  /* bit mask for ValidateDate() */
    4706             : 
    4707       39932 :     fmt_len = VARSIZE_ANY_EXHDR(fmt);
    4708             : 
    4709       39932 :     if (fmt_len)
    4710             :     {
    4711             :         char       *fmt_str;
    4712             : 
    4713       39932 :         fmt_str = text_to_cstring(fmt);
    4714             : 
    4715       39932 :         if (fmt_len > DCH_CACHE_SIZE)
    4716             :         {
    4717             :             /*
    4718             :              * Allocate new memory if format picture is bigger than static
    4719             :              * cache and do not use cache (call parser always)
    4720             :              */
    4721           0 :             format = (FormatNode *) palloc((fmt_len + 1) * sizeof(FormatNode));
    4722             : 
    4723           0 :             parse_format(format, fmt_str, DCH_keywords, DCH_suff, DCH_index,
    4724             :                          DCH_FLAG | (std ? STD_FLAG : 0), NULL);
    4725             :         }
    4726             :         else
    4727             :         {
    4728             :             /*
    4729             :              * Use cache buffers
    4730             :              */
    4731       39932 :             DCHCacheEntry *ent = DCH_cache_fetch(fmt_str, std);
    4732             : 
    4733       39926 :             incache = true;
    4734       39926 :             format = ent->format;
    4735             :         }
    4736             : 
    4737             : #ifdef DEBUG_TO_FROM_CHAR
    4738             :         /* dump_node(format, fmt_len); */
    4739             :         /* dump_index(DCH_keywords, DCH_index); */
    4740             : #endif
    4741             : 
    4742       39926 :         DCH_from_char(format, date_str, &tmfc, collid, std, escontext);
    4743       39780 :         pfree(fmt_str);
    4744       39780 :         if (SOFT_ERROR_OCCURRED(escontext))
    4745       30720 :             goto fail;
    4746             : 
    4747        9060 :         if (flags)
    4748        8112 :             *flags = DCH_datetime_type(format);
    4749             : 
    4750        9060 :         if (!incache)
    4751             :         {
    4752           0 :             pfree(format);
    4753           0 :             format = NULL;
    4754             :         }
    4755             :     }
    4756             : 
    4757             :     DEBUG_TMFC(&tmfc);
    4758             : 
    4759             :     /*
    4760             :      * Convert to_date/to_timestamp input fields to standard 'tm'
    4761             :      */
    4762        9060 :     if (tmfc.ssss)
    4763             :     {
    4764          24 :         int         x = tmfc.ssss;
    4765             : 
    4766          24 :         tm->tm_hour = x / SECS_PER_HOUR;
    4767          24 :         x %= SECS_PER_HOUR;
    4768          24 :         tm->tm_min = x / SECS_PER_MINUTE;
    4769          24 :         x %= SECS_PER_MINUTE;
    4770          24 :         tm->tm_sec = x;
    4771             :     }
    4772             : 
    4773        9060 :     if (tmfc.ss)
    4774        1266 :         tm->tm_sec = tmfc.ss;
    4775        9060 :     if (tmfc.mi)
    4776        7182 :         tm->tm_min = tmfc.mi;
    4777        9060 :     if (tmfc.hh)
    4778        7248 :         tm->tm_hour = tmfc.hh;
    4779             : 
    4780        9060 :     if (tmfc.clock == CLOCK_12_HOUR)
    4781             :     {
    4782         120 :         if (tm->tm_hour < 1 || tm->tm_hour > HOURS_PER_DAY / 2)
    4783             :         {
    4784           6 :             errsave(escontext,
    4785             :                     (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    4786             :                      errmsg("hour \"%d\" is invalid for the 12-hour clock",
    4787             :                             tm->tm_hour),
    4788             :                      errhint("Use the 24-hour clock, or give an hour between 1 and 12.")));
    4789           0 :             goto fail;
    4790             :         }
    4791             : 
    4792         114 :         if (tmfc.pm && tm->tm_hour < HOURS_PER_DAY / 2)
    4793          12 :             tm->tm_hour += HOURS_PER_DAY / 2;
    4794         102 :         else if (!tmfc.pm && tm->tm_hour == HOURS_PER_DAY / 2)
    4795           0 :             tm->tm_hour = 0;
    4796             :     }
    4797             : 
    4798        9054 :     if (tmfc.year)
    4799             :     {
    4800             :         /*
    4801             :          * If CC and YY (or Y) are provided, use YY as 2 low-order digits for
    4802             :          * the year in the given century.  Keep in mind that the 21st century
    4803             :          * AD runs from 2001-2100, not 2000-2099; 6th century BC runs from
    4804             :          * 600BC to 501BC.
    4805             :          */
    4806        5928 :         if (tmfc.cc && tmfc.yysz <= 2)
    4807             :         {
    4808           6 :             if (tmfc.bc)
    4809           0 :                 tmfc.cc = -tmfc.cc;
    4810           6 :             tm->tm_year = tmfc.year % 100;
    4811           6 :             if (tm->tm_year)
    4812             :             {
    4813           6 :                 if (tmfc.cc >= 0)
    4814           6 :                     tm->tm_year += (tmfc.cc - 1) * 100;
    4815             :                 else
    4816           0 :                     tm->tm_year = (tmfc.cc + 1) * 100 - tm->tm_year + 1;
    4817             :             }
    4818             :             else
    4819             :             {
    4820             :                 /* find century year for dates ending in "00" */
    4821           0 :                 tm->tm_year = tmfc.cc * 100 + ((tmfc.cc >= 0) ? 0 : 1);
    4822             :             }
    4823             :         }
    4824             :         else
    4825             :         {
    4826             :             /* If a 4-digit year is provided, we use that and ignore CC. */
    4827        5922 :             tm->tm_year = tmfc.year;
    4828        5922 :             if (tmfc.bc)
    4829          36 :                 tm->tm_year = -tm->tm_year;
    4830             :             /* correct for our representation of BC years */
    4831        5922 :             if (tm->tm_year < 0)
    4832          36 :                 tm->tm_year++;
    4833             :         }
    4834        5928 :         fmask |= DTK_M(YEAR);
    4835             :     }
    4836        3126 :     else if (tmfc.cc)
    4837             :     {
    4838             :         /* use first year of century */
    4839           0 :         if (tmfc.bc)
    4840           0 :             tmfc.cc = -tmfc.cc;
    4841           0 :         if (tmfc.cc >= 0)
    4842             :             /* +1 because 21st century started in 2001 */
    4843           0 :             tm->tm_year = (tmfc.cc - 1) * 100 + 1;
    4844             :         else
    4845             :             /* +1 because year == 599 is 600 BC */
    4846           0 :             tm->tm_year = tmfc.cc * 100 + 1;
    4847           0 :         fmask |= DTK_M(YEAR);
    4848             :     }
    4849             : 
    4850        9054 :     if (tmfc.j)
    4851             :     {
    4852           6 :         j2date(tmfc.j, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
    4853           6 :         fmask |= DTK_DATE_M;
    4854             :     }
    4855             : 
    4856        9054 :     if (tmfc.ww)
    4857             :     {
    4858          30 :         if (tmfc.mode == FROM_CHAR_DATE_ISOWEEK)
    4859             :         {
    4860             :             /*
    4861             :              * If tmfc.d is not set, then the date is left at the beginning of
    4862             :              * the ISO week (Monday).
    4863             :              */
    4864          24 :             if (tmfc.d)
    4865          24 :                 isoweekdate2date(tmfc.ww, tmfc.d, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
    4866             :             else
    4867           0 :                 isoweek2date(tmfc.ww, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
    4868          24 :             fmask |= DTK_DATE_M;
    4869             :         }
    4870             :         else
    4871           6 :             tmfc.ddd = (tmfc.ww - 1) * 7 + 1;
    4872             :     }
    4873             : 
    4874        9054 :     if (tmfc.w)
    4875           6 :         tmfc.dd = (tmfc.w - 1) * 7 + 1;
    4876        9054 :     if (tmfc.dd)
    4877             :     {
    4878        5796 :         tm->tm_mday = tmfc.dd;
    4879        5796 :         fmask |= DTK_M(DAY);
    4880             :     }
    4881        9054 :     if (tmfc.mm)
    4882             :     {
    4883        5832 :         tm->tm_mon = tmfc.mm;
    4884        5832 :         fmask |= DTK_M(MONTH);
    4885             :     }
    4886             : 
    4887        9054 :     if (tmfc.ddd && (tm->tm_mon <= 1 || tm->tm_mday <= 1))
    4888             :     {
    4889             :         /*
    4890             :          * The month and day field have not been set, so we use the
    4891             :          * day-of-year field to populate them.  Depending on the date mode,
    4892             :          * this field may be interpreted as a Gregorian day-of-year, or an ISO
    4893             :          * week date day-of-year.
    4894             :          */
    4895             : 
    4896          48 :         if (!tm->tm_year && !tmfc.bc)
    4897             :         {
    4898           0 :             errsave(escontext,
    4899             :                     (errcode(ERRCODE_INVALID_DATETIME_FORMAT),
    4900             :                      errmsg("cannot calculate day of year without year information")));
    4901           0 :             goto fail;
    4902             :         }
    4903             : 
    4904          48 :         if (tmfc.mode == FROM_CHAR_DATE_ISOWEEK)
    4905             :         {
    4906             :             int         j0;     /* zeroth day of the ISO year, in Julian */
    4907             : 
    4908           6 :             j0 = isoweek2j(tm->tm_year, 1) - 1;
    4909             : 
    4910           6 :             j2date(j0 + tmfc.ddd, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);
    4911           6 :             fmask |= DTK_DATE_M;
    4912             :         }
    4913             :         else
    4914             :         {
    4915             :             const int  *y;
    4916             :             int         i;
    4917             : 
    4918             :             static const int ysum[2][13] = {
    4919             :                 {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
    4920             :             {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}};
    4921             : 
    4922          42 :             y = ysum[isleap(tm->tm_year)];
    4923             : 
    4924         492 :             for (i = 1; i <= MONTHS_PER_YEAR; i++)
    4925             :             {
    4926         480 :                 if (tmfc.ddd <= y[i])
    4927          30 :                     break;
    4928             :             }
    4929          42 :             if (tm->tm_mon <= 1)
    4930          42 :                 tm->tm_mon = i;
    4931             : 
    4932          42 :             if (tm->tm_mday <= 1)
    4933          42 :                 tm->tm_mday = tmfc.ddd - y[i - 1];
    4934             : 
    4935          42 :             fmask |= DTK_M(MONTH) | DTK_M(DAY);
    4936             :         }
    4937             :     }
    4938             : 
    4939        9054 :     if (tmfc.ms)
    4940           6 :         *fsec += tmfc.ms * 1000;
    4941        9054 :     if (tmfc.us)
    4942         978 :         *fsec += tmfc.us;
    4943        9054 :     if (fprec)
    4944        8880 :         *fprec = tmfc.ff;       /* fractional precision, if specified */
    4945             : 
    4946             :     /* Range-check date fields according to bit mask computed above */
    4947        9054 :     if (fmask != 0)
    4948             :     {
    4949             :         /* We already dealt with AD/BC, so pass isjulian = true */
    4950        5940 :         int         dterr = ValidateDate(fmask, true, false, false, tm);
    4951             : 
    4952        5940 :         if (dterr != 0)
    4953             :         {
    4954             :             /*
    4955             :              * Force the error to be DTERR_FIELD_OVERFLOW even if ValidateDate
    4956             :              * said DTERR_MD_FIELD_OVERFLOW, because we don't want to print an
    4957             :              * irrelevant hint about datestyle.
    4958             :              */
    4959          48 :             DateTimeParseError(DTERR_FIELD_OVERFLOW, NULL,
    4960             :                                date_str, "timestamp", escontext);
    4961           0 :             goto fail;
    4962             :         }
    4963             :     }
    4964             : 
    4965             :     /* Range-check time fields too */
    4966        9006 :     if (tm->tm_hour < 0 || tm->tm_hour >= HOURS_PER_DAY ||
    4967        8988 :         tm->tm_min < 0 || tm->tm_min >= MINS_PER_HOUR ||
    4968        8982 :         tm->tm_sec < 0 || tm->tm_sec >= SECS_PER_MINUTE ||
    4969        8976 :         *fsec < INT64CONST(0) || *fsec >= USECS_PER_SEC)
    4970             :     {
    4971          36 :         DateTimeParseError(DTERR_FIELD_OVERFLOW, NULL,
    4972             :                            date_str, "timestamp", escontext);
    4973           0 :         goto fail;
    4974             :     }
    4975             : 
    4976             :     /*
    4977             :      * If timezone info was present, reduce it to a GMT offset.  (We cannot do
    4978             :      * this until we've filled all of the tm struct, since the zone's offset
    4979             :      * might be time-varying.)
    4980             :      */
    4981        8970 :     if (tmfc.tzsign)
    4982             :     {
    4983             :         /* TZH and/or TZM fields */
    4984        3966 :         if (tmfc.tzh < 0 || tmfc.tzh > MAX_TZDISP_HOUR ||
    4985        3966 :             tmfc.tzm < 0 || tmfc.tzm >= MINS_PER_HOUR)
    4986             :         {
    4987           0 :             DateTimeParseError(DTERR_TZDISP_OVERFLOW, NULL,
    4988             :                                date_str, "timestamp", escontext);
    4989           0 :             goto fail;
    4990             :         }
    4991             : 
    4992        3966 :         tz->has_tz = true;
    4993        3966 :         tz->gmtoffset = (tmfc.tzh * MINS_PER_HOUR + tmfc.tzm) * SECS_PER_MINUTE;
    4994             :         /* note we are flipping the sign convention here */
    4995        3966 :         if (tmfc.tzsign > 0)
    4996        3618 :             tz->gmtoffset = -tz->gmtoffset;
    4997             :     }
    4998        5004 :     else if (tmfc.has_tz)
    4999             :     {
    5000             :         /* TZ field */
    5001          30 :         tz->has_tz = true;
    5002          30 :         if (tmfc.tzp == NULL)
    5003             :         {
    5004             :             /* fixed-offset abbreviation; flip the sign convention */
    5005          24 :             tz->gmtoffset = -tmfc.gmtoffset;
    5006             :         }
    5007             :         else
    5008             :         {
    5009             :             /* dynamic-offset abbreviation, resolve using specified time */
    5010           6 :             tz->gmtoffset = DetermineTimeZoneAbbrevOffset(tm, tmfc.abbrev,
    5011             :                                                           tmfc.tzp);
    5012             :         }
    5013             :     }
    5014             : 
    5015             :     DEBUG_TM(tm);
    5016             : 
    5017        8970 :     if (format && !incache)
    5018           0 :         pfree(format);
    5019        8970 :     pfree(date_str);
    5020             : 
    5021        8970 :     return true;
    5022             : 
    5023       30720 : fail:
    5024       30720 :     if (format && !incache)
    5025           0 :         pfree(format);
    5026       30720 :     pfree(date_str);
    5027             : 
    5028       30720 :     return false;
    5029             : }
    5030             : 
    5031             : 
    5032             : /**********************************************************************
    5033             :  *  the NUMBER version part
    5034             :  *********************************************************************/
    5035             : 
    5036             : 
    5037             : static char *
    5038         138 : fill_str(char *str, int c, int max)
    5039             : {
    5040         138 :     memset(str, c, max);
    5041         138 :     *(str + max) = '\0';
    5042         138 :     return str;
    5043             : }
    5044             : 
    5045             : #define zeroize_NUM(_n) \
    5046             : do { \
    5047             :     (_n)->flag       = 0;    \
    5048             :     (_n)->lsign      = 0;    \
    5049             :     (_n)->pre        = 0;    \
    5050             :     (_n)->post       = 0;    \
    5051             :     (_n)->pre_lsign_num = 0; \
    5052             :     (_n)->need_locale    = 0;    \
    5053             :     (_n)->multi      = 0;    \
    5054             :     (_n)->zero_start = 0;    \
    5055             :     (_n)->zero_end       = 0;    \
    5056             : } while(0)
    5057             : 
    5058             : /* This works the same as DCH_prevent_counter_overflow */
    5059             : static inline void
    5060      996262 : NUM_prevent_counter_overflow(void)
    5061             : {
    5062      996262 :     if (NUMCounter >= (INT_MAX - 1))
    5063             :     {
    5064           0 :         for (int i = 0; i < n_NUMCache; i++)
    5065           0 :             NUMCache[i]->age >>= 1;
    5066           0 :         NUMCounter >>= 1;
    5067             :     }
    5068      996262 : }
    5069             : 
    5070             : /* select a NUMCacheEntry to hold the given format picture */
    5071             : static NUMCacheEntry *
    5072         532 : NUM_cache_getnew(const char *str)
    5073             : {
    5074             :     NUMCacheEntry *ent;
    5075             : 
    5076             :     /* Ensure we can advance NUMCounter below */
    5077         532 :     NUM_prevent_counter_overflow();
    5078             : 
    5079             :     /*
    5080             :      * If cache is full, remove oldest entry (or recycle first not-valid one)
    5081             :      */
    5082         532 :     if (n_NUMCache >= NUM_CACHE_ENTRIES)
    5083             :     {
    5084         210 :         NUMCacheEntry *old = NUMCache[0];
    5085             : 
    5086             : #ifdef DEBUG_TO_FROM_CHAR
    5087             :         elog(DEBUG_elog_output, "Cache is full (%d)", n_NUMCache);
    5088             : #endif
    5089         210 :         if (old->valid)
    5090             :         {
    5091        4200 :             for (int i = 1; i < NUM_CACHE_ENTRIES; i++)
    5092             :             {
    5093        3990 :                 ent = NUMCache[i];
    5094        3990 :                 if (!ent->valid)
    5095             :                 {
    5096           0 :                     old = ent;
    5097           0 :                     break;
    5098             :                 }
    5099        3990 :                 if (ent->age < old->age)
    5100         198 :                     old = ent;
    5101             :             }
    5102             :         }
    5103             : #ifdef DEBUG_TO_FROM_CHAR
    5104             :         elog(DEBUG_elog_output, "OLD: \"%s\" AGE: %d", old->str, old->age);
    5105             : #endif
    5106         210 :         old->valid = false;
    5107         210 :         strlcpy(old->str, str, NUM_CACHE_SIZE + 1);
    5108         210 :         old->age = (++NUMCounter);
    5109             :         /* caller is expected to fill format and Num, then set valid */
    5110         210 :         return old;
    5111             :     }
    5112             :     else
    5113             :     {
    5114             : #ifdef DEBUG_TO_FROM_CHAR
    5115             :         elog(DEBUG_elog_output, "NEW (%d)", n_NUMCache);
    5116             : #endif
    5117             :         Assert(NUMCache[n_NUMCache] == NULL);
    5118         322 :         NUMCache[n_NUMCache] = ent = (NUMCacheEntry *)
    5119         322 :             MemoryContextAllocZero(TopMemoryContext, sizeof(NUMCacheEntry));
    5120         322 :         ent->valid = false;
    5121         322 :         strlcpy(ent->str, str, NUM_CACHE_SIZE + 1);
    5122         322 :         ent->age = (++NUMCounter);
    5123             :         /* caller is expected to fill format and Num, then set valid */
    5124         322 :         ++n_NUMCache;
    5125         322 :         return ent;
    5126             :     }
    5127             : }
    5128             : 
    5129             : /* look for an existing NUMCacheEntry matching the given format picture */
    5130             : static NUMCacheEntry *
    5131      995730 : NUM_cache_search(const char *str)
    5132             : {
    5133             :     /* Ensure we can advance NUMCounter below */
    5134      995730 :     NUM_prevent_counter_overflow();
    5135             : 
    5136     1263342 :     for (int i = 0; i < n_NUMCache; i++)
    5137             :     {
    5138     1262810 :         NUMCacheEntry *ent = NUMCache[i];
    5139             : 
    5140     1262810 :         if (ent->valid && strcmp(ent->str, str) == 0)
    5141             :         {
    5142      995198 :             ent->age = (++NUMCounter);
    5143      995198 :             return ent;
    5144             :         }
    5145             :     }
    5146             : 
    5147         532 :     return NULL;
    5148             : }
    5149             : 
    5150             : /* Find or create a NUMCacheEntry for the given format picture */
    5151             : static NUMCacheEntry *
    5152      995730 : NUM_cache_fetch(const char *str)
    5153             : {
    5154             :     NUMCacheEntry *ent;
    5155             : 
    5156      995730 :     if ((ent = NUM_cache_search(str)) == NULL)
    5157             :     {
    5158             :         /*
    5159             :          * Not in the cache, must run parser and save a new format-picture to
    5160             :          * the cache.  Do not mark the cache entry valid until parsing
    5161             :          * succeeds.
    5162             :          */
    5163         532 :         ent = NUM_cache_getnew(str);
    5164             : 
    5165         532 :         zeroize_NUM(&ent->Num);
    5166             : 
    5167         532 :         parse_format(ent->format, str, NUM_keywords,
    5168             :                      NULL, NUM_index, NUM_FLAG, &ent->Num);
    5169             : 
    5170         532 :         ent->valid = true;
    5171             :     }
    5172      995730 :     return ent;
    5173             : }
    5174             : 
    5175             : /* ----------
    5176             :  * Cache routine for NUM to_char version
    5177             :  * ----------
    5178             :  */
    5179             : static FormatNode *
    5180      995940 : NUM_cache(int len, NUMDesc *Num, text *pars_str, bool *shouldFree)
    5181             : {
    5182      995940 :     FormatNode *format = NULL;
    5183             :     char       *str;
    5184             : 
    5185      995940 :     str = text_to_cstring(pars_str);
    5186             : 
    5187      995940 :     if (len > NUM_CACHE_SIZE)
    5188             :     {
    5189             :         /*
    5190             :          * Allocate new memory if format picture is bigger than static cache
    5191             :          * and do not use cache (call parser always)
    5192             :          */
    5193         210 :         format = (FormatNode *) palloc((len + 1) * sizeof(FormatNode));
    5194             : 
    5195         210 :         *shouldFree = true;
    5196             : 
    5197         210 :         zeroize_NUM(Num);
    5198             : 
    5199         210 :         parse_format(format, str, NUM_keywords,
    5200             :                      NULL, NUM_index, NUM_FLAG, Num);
    5201             :     }
    5202             :     else
    5203             :     {
    5204             :         /*
    5205             :          * Use cache buffers
    5206             :          */
    5207      995730 :         NUMCacheEntry *ent = NUM_cache_fetch(str);
    5208             : 
    5209      995730 :         *shouldFree = false;
    5210             : 
    5211      995730 :         format = ent->format;
    5212             : 
    5213             :         /*
    5214             :          * Copy cache to used struct
    5215             :          */
    5216      995730 :         Num->flag = ent->Num.flag;
    5217      995730 :         Num->lsign = ent->Num.lsign;
    5218      995730 :         Num->pre = ent->Num.pre;
    5219      995730 :         Num->post = ent->Num.post;
    5220      995730 :         Num->pre_lsign_num = ent->Num.pre_lsign_num;
    5221      995730 :         Num->need_locale = ent->Num.need_locale;
    5222      995730 :         Num->multi = ent->Num.multi;
    5223      995730 :         Num->zero_start = ent->Num.zero_start;
    5224      995730 :         Num->zero_end = ent->Num.zero_end;
    5225             :     }
    5226             : 
    5227             : #ifdef DEBUG_TO_FROM_CHAR
    5228             :     /* dump_node(format, len); */
    5229             :     dump_index(NUM_keywords, NUM_index);
    5230             : #endif
    5231             : 
    5232      995940 :     pfree(str);
    5233      995940 :     return format;
    5234             : }
    5235             : 
    5236             : 
    5237             : static char *
    5238           0 : int_to_roman(int number)
    5239             : {
    5240             :     int         len,
    5241             :                 num;
    5242             :     char       *p,
    5243             :                *result,
    5244             :                 numstr[12];
    5245             : 
    5246           0 :     result = (char *) palloc(16);
    5247           0 :     *result = '\0';
    5248             : 
    5249           0 :     if (number > 3999 || number < 1)
    5250             :     {
    5251           0 :         fill_str(result, '#', 15);
    5252           0 :         return result;
    5253             :     }
    5254           0 :     len = snprintf(numstr, sizeof(numstr), "%d", number);
    5255             : 
    5256           0 :     for (p = numstr; *p != '\0'; p++, --len)
    5257             :     {
    5258           0 :         num = *p - ('0' + 1);
    5259           0 :         if (num < 0)
    5260           0 :             continue;
    5261             : 
    5262           0 :         if (len > 3)
    5263             :         {
    5264           0 :             while (num-- != -1)
    5265           0 :                 strcat(result, "M");
    5266             :         }
    5267             :         else
    5268             :         {
    5269           0 :             if (len == 3)
    5270           0 :                 strcat(result, rm100[num]);
    5271           0 :             else if (len == 2)
    5272           0 :                 strcat(result, rm10[num]);
    5273           0 :             else if (len == 1)
    5274           0 :                 strcat(result, rm1[num]);
    5275             :         }
    5276             :     }
    5277           0 :     return result;
    5278             : }
    5279             : 
    5280             : 
    5281             : 
    5282             : /* ----------
    5283             :  * Locale
    5284             :  * ----------
    5285             :  */
    5286             : static void
    5287      995622 : NUM_prepare_locale(NUMProc *Np)
    5288             : {
    5289      995622 :     if (Np->Num->need_locale)
    5290             :     {
    5291             :         struct lconv *lconv;
    5292             : 
    5293             :         /*
    5294             :          * Get locales
    5295             :          */
    5296         842 :         lconv = PGLC_localeconv();
    5297             : 
    5298             :         /*
    5299             :          * Positive / Negative number sign
    5300             :          */
    5301         842 :         if (lconv->negative_sign && *lconv->negative_sign)
    5302           0 :             Np->L_negative_sign = lconv->negative_sign;
    5303             :         else
    5304         842 :             Np->L_negative_sign = "-";
    5305             : 
    5306         842 :         if (lconv->positive_sign && *lconv->positive_sign)
    5307           0 :             Np->L_positive_sign = lconv->positive_sign;
    5308             :         else
    5309         842 :             Np->L_positive_sign = "+";
    5310             : 
    5311             :         /*
    5312             :          * Number decimal point
    5313             :          */
    5314         842 :         if (lconv->decimal_point && *lconv->decimal_point)
    5315         842 :             Np->decimal = lconv->decimal_point;
    5316             : 
    5317             :         else
    5318           0 :             Np->decimal = ".";
    5319             : 
    5320         842 :         if (!IS_LDECIMAL(Np->Num))
    5321         708 :             Np->decimal = ".";
    5322             : 
    5323             :         /*
    5324             :          * Number thousands separator
    5325             :          *
    5326             :          * Some locales (e.g. broken glibc pt_BR), have a comma for decimal,
    5327             :          * but "" for thousands_sep, so we set the thousands_sep too.
    5328             :          * http://archives.postgresql.org/pgsql-hackers/2007-11/msg00772.php
    5329             :          */
    5330         842 :         if (lconv->thousands_sep && *lconv->thousands_sep)
    5331           0 :             Np->L_thousands_sep = lconv->thousands_sep;
    5332             :         /* Make sure thousands separator doesn't match decimal point symbol. */
    5333         842 :         else if (strcmp(Np->decimal, ",") != 0)
    5334         842 :             Np->L_thousands_sep = ",";
    5335             :         else
    5336           0 :             Np->L_thousands_sep = ".";
    5337             : 
    5338             :         /*
    5339             :          * Currency symbol
    5340             :          */
    5341         842 :         if (lconv->currency_symbol && *lconv->currency_symbol)
    5342           0 :             Np->L_currency_symbol = lconv->currency_symbol;
    5343             :         else
    5344         842 :             Np->L_currency_symbol = " ";
    5345             :     }
    5346             :     else
    5347             :     {
    5348             :         /*
    5349             :          * Default values
    5350             :          */
    5351      994780 :         Np->L_negative_sign = "-";
    5352      994780 :         Np->L_positive_sign = "+";
    5353      994780 :         Np->decimal = ".";
    5354             : 
    5355      994780 :         Np->L_thousands_sep = ",";
    5356      994780 :         Np->L_currency_symbol = " ";
    5357             :     }
    5358      995622 : }
    5359             : 
    5360             : /* ----------
    5361             :  * Return pointer of last relevant number after decimal point
    5362             :  *  12.0500 --> last relevant is '5'
    5363             :  *  12.0000 --> last relevant is '.'
    5364             :  * If there is no decimal point, return NULL (which will result in same
    5365             :  * behavior as if FM hadn't been specified).
    5366             :  * ----------
    5367             :  */
    5368             : static char *
    5369         678 : get_last_relevant_decnum(char *num)
    5370             : {
    5371             :     char       *result,
    5372         678 :                *p = strchr(num, '.');
    5373             : 
    5374             : #ifdef DEBUG_TO_FROM_CHAR
    5375             :     elog(DEBUG_elog_output, "get_last_relevant_decnum()");
    5376             : #endif
    5377             : 
    5378         678 :     if (!p)
    5379           6 :         return NULL;
    5380             : 
    5381         672 :     result = p;
    5382             : 
    5383        9942 :     while (*(++p))
    5384             :     {
    5385        9270 :         if (*p != '0')
    5386        1944 :             result = p;
    5387             :     }
    5388             : 
    5389         672 :     return result;
    5390             : }
    5391             : 
    5392             : /*
    5393             :  * These macros are used in NUM_processor() and its subsidiary routines.
    5394             :  * OVERLOAD_TEST: true if we've reached end of input string
    5395             :  * AMOUNT_TEST(s): true if at least s bytes remain in string
    5396             :  */
    5397             : #define OVERLOAD_TEST   (Np->inout_p >= Np->inout + input_len)
    5398             : #define AMOUNT_TEST(s)  (Np->inout_p <= Np->inout + (input_len - (s)))
    5399             : 
    5400             : /* ----------
    5401             :  * Number extraction for TO_NUMBER()
    5402             :  * ----------
    5403             :  */
    5404             : static void
    5405         858 : NUM_numpart_from_char(NUMProc *Np, int id, int input_len)
    5406             : {
    5407         858 :     bool        isread = false;
    5408             : 
    5409             : #ifdef DEBUG_TO_FROM_CHAR
    5410             :     elog(DEBUG_elog_output, " --- scan start --- id=%s",
    5411             :          (id == NUM_0 || id == NUM_9) ? "NUM_0/9" : id == NUM_DEC ? "NUM_DEC" : "???");
    5412             : #endif
    5413             : 
    5414         858 :     if (OVERLOAD_TEST)
    5415           0 :         return;
    5416             : 
    5417         858 :     if (*Np->inout_p == ' ')
    5418           0 :         Np->inout_p++;
    5419             : 
    5420         858 :     if (OVERLOAD_TEST)
    5421           0 :         return;
    5422             : 
    5423             :     /*
    5424             :      * read sign before number
    5425             :      */
    5426         858 :     if (*Np->number == ' ' && (id == NUM_0 || id == NUM_9) &&
    5427         570 :         (Np->read_pre + Np->read_post) == 0)
    5428             :     {
    5429             : #ifdef DEBUG_TO_FROM_CHAR
    5430             :         elog(DEBUG_elog_output, "Try read sign (%c), locale positive: %s, negative: %s",
    5431             :              *Np->inout_p, Np->L_positive_sign, Np->L_negative_sign);
    5432             : #endif
    5433             : 
    5434             :         /*
    5435             :          * locale sign
    5436             :          */
    5437         168 :         if (IS_LSIGN(Np->Num) && Np->Num->lsign == NUM_LSIGN_PRE)
    5438          12 :         {
    5439          12 :             int         x = 0;
    5440             : 
    5441             : #ifdef DEBUG_TO_FROM_CHAR
    5442             :             elog(DEBUG_elog_output, "Try read locale pre-sign (%c)", *Np->inout_p);
    5443             : #endif
    5444          12 :             if ((x = strlen(Np->L_negative_sign)) &&
    5445          12 :                 AMOUNT_TEST(x) &&
    5446          12 :                 strncmp(Np->inout_p, Np->L_negative_sign, x) == 0)
    5447             :             {
    5448           6 :                 Np->inout_p += x;
    5449           6 :                 *Np->number = '-';
    5450             :             }
    5451           6 :             else if ((x = strlen(Np->L_positive_sign)) &&
    5452           6 :                      AMOUNT_TEST(x) &&
    5453           6 :                      strncmp(Np->inout_p, Np->L_positive_sign, x) == 0)
    5454             :             {
    5455           0 :                 Np->inout_p += x;
    5456           0 :                 *Np->number = '+';
    5457             :             }
    5458             :         }
    5459             :         else
    5460             :         {
    5461             : #ifdef DEBUG_TO_FROM_CHAR
    5462             :             elog(DEBUG_elog_output, "Try read simple sign (%c)", *Np->inout_p);
    5463             : #endif
    5464             : 
    5465             :             /*
    5466             :              * simple + - < >
    5467             :              */
    5468         156 :             if (*Np->inout_p == '-' || (IS_BRACKET(Np->Num) &&
    5469           6 :                                         *Np->inout_p == '<'))
    5470             :             {
    5471          18 :                 *Np->number = '-';   /* set - */
    5472          18 :                 Np->inout_p++;
    5473             :             }
    5474         138 :             else if (*Np->inout_p == '+')
    5475             :             {
    5476           0 :                 *Np->number = '+';   /* set + */
    5477           0 :                 Np->inout_p++;
    5478             :             }
    5479             :         }
    5480             :     }
    5481             : 
    5482         858 :     if (OVERLOAD_TEST)
    5483           0 :         return;
    5484             : 
    5485             : #ifdef DEBUG_TO_FROM_CHAR
    5486             :     elog(DEBUG_elog_output, "Scan for numbers (%c), current number: '%s'", *Np->inout_p, Np->number);
    5487             : #endif
    5488             : 
    5489             :     /*
    5490             :      * read digit or decimal point
    5491             :      */
    5492         858 :     if (isdigit((unsigned char) *Np->inout_p))
    5493             :     {
    5494         726 :         if (Np->read_dec && Np->read_post == Np->Num->post)
    5495           0 :             return;
    5496             : 
    5497         726 :         *Np->number_p = *Np->inout_p;
    5498         726 :         Np->number_p++;
    5499             : 
    5500         726 :         if (Np->read_dec)
    5501         264 :             Np->read_post++;
    5502             :         else
    5503         462 :             Np->read_pre++;
    5504             : 
    5505         726 :         isread = true;
    5506             : 
    5507             : #ifdef DEBUG_TO_FROM_CHAR
    5508             :         elog(DEBUG_elog_output, "Read digit (%c)", *Np->inout_p);
    5509             : #endif
    5510             :     }
    5511         132 :     else if (IS_DECIMAL(Np->Num) && Np->read_dec == false)
    5512             :     {
    5513             :         /*
    5514             :          * We need not test IS_LDECIMAL(Np->Num) explicitly here, because
    5515             :          * Np->decimal is always just "." if we don't have a D format token.
    5516             :          * So we just unconditionally match to Np->decimal.
    5517             :          */
    5518         120 :         int         x = strlen(Np->decimal);
    5519             : 
    5520             : #ifdef DEBUG_TO_FROM_CHAR
    5521             :         elog(DEBUG_elog_output, "Try read decimal point (%c)",
    5522             :              *Np->inout_p);
    5523             : #endif
    5524         120 :         if (x && AMOUNT_TEST(x) && strncmp(Np->inout_p, Np->decimal, x) == 0)
    5525             :         {
    5526         108 :             Np->inout_p += x - 1;
    5527         108 :             *Np->number_p = '.';
    5528         108 :             Np->number_p++;
    5529         108 :             Np->read_dec = true;
    5530         108 :             isread = true;
    5531             :         }
    5532             :     }
    5533             : 
    5534         858 :     if (OVERLOAD_TEST)
    5535           0 :         return;
    5536             : 
    5537             :     /*
    5538             :      * Read sign behind "last" number
    5539             :      *
    5540             :      * We need sign detection because determine exact position of post-sign is
    5541             :      * difficult:
    5542             :      *
    5543             :      * FM9999.9999999S     -> 123.001- 9.9S             -> .5- FM9.999999MI ->
    5544             :      * 5.01-
    5545             :      */
    5546         858 :     if (*Np->number == ' ' && Np->read_pre + Np->read_post > 0)
    5547             :     {
    5548             :         /*
    5549             :          * locale sign (NUM_S) is always anchored behind a last number, if: -
    5550             :          * locale sign expected - last read char was NUM_0/9 or NUM_DEC - and
    5551             :          * next char is not digit
    5552             :          */
    5553         600 :         if (IS_LSIGN(Np->Num) && isread &&
    5554         174 :             (Np->inout_p + 1) < Np->inout + input_len &&
    5555         174 :             !isdigit((unsigned char) *(Np->inout_p + 1)))
    5556          78 :         {
    5557             :             int         x;
    5558          78 :             char       *tmp = Np->inout_p++;
    5559             : 
    5560             : #ifdef DEBUG_TO_FROM_CHAR
    5561             :             elog(DEBUG_elog_output, "Try read locale post-sign (%c)", *Np->inout_p);
    5562             : #endif
    5563          78 :             if ((x = strlen(Np->L_negative_sign)) &&
    5564          78 :                 AMOUNT_TEST(x) &&
    5565          78 :                 strncmp(Np->inout_p, Np->L_negative_sign, x) == 0)
    5566             :             {
    5567          36 :                 Np->inout_p += x - 1;    /* -1 .. NUM_processor() do inout_p++ */
    5568          36 :                 *Np->number = '-';
    5569             :             }
    5570          42 :             else if ((x = strlen(Np->L_positive_sign)) &&
    5571          42 :                      AMOUNT_TEST(x) &&
    5572          42 :                      strncmp(Np->inout_p, Np->L_positive_sign, x) == 0)
    5573             :             {
    5574           0 :                 Np->inout_p += x - 1;    /* -1 .. NUM_processor() do inout_p++ */
    5575           0 :                 *Np->number = '+';
    5576             :             }
    5577          78 :             if (*Np->number == ' ')
    5578             :                 /* no sign read */
    5579          42 :                 Np->inout_p = tmp;
    5580             :         }
    5581             : 
    5582             :         /*
    5583             :          * try read non-locale sign, it's happen only if format is not exact
    5584             :          * and we cannot determine sign position of MI/PL/SG, an example:
    5585             :          *
    5586             :          * FM9.999999MI            -> 5.01-
    5587             :          *
    5588             :          * if (.... && IS_LSIGN(Np->Num)==false) prevents read wrong formats
    5589             :          * like to_number('1 -', '9S') where sign is not anchored to last
    5590             :          * number.
    5591             :          */
    5592         522 :         else if (isread == false && IS_LSIGN(Np->Num) == false &&
    5593          24 :                  (IS_PLUS(Np->Num) || IS_MINUS(Np->Num)))
    5594             :         {
    5595             : #ifdef DEBUG_TO_FROM_CHAR
    5596             :             elog(DEBUG_elog_output, "Try read simple post-sign (%c)", *Np->inout_p);
    5597             : #endif
    5598             : 
    5599             :             /*
    5600             :              * simple + -
    5601             :              */
    5602           6 :             if (*Np->inout_p == '-' || *Np->inout_p == '+')
    5603             :                 /* NUM_processor() do inout_p++ */
    5604           6 :                 *Np->number = *Np->inout_p;
    5605             :         }
    5606             :     }
    5607             : }
    5608             : 
    5609             : #define IS_PREDEC_SPACE(_n) \
    5610             :         (IS_ZERO((_n)->Num)==false && \
    5611             :          (_n)->number == (_n)->number_p && \
    5612             :          *(_n)->number == '0' && \
    5613             :                  (_n)->Num->post != 0)
    5614             : 
    5615             : /* ----------
    5616             :  * Add digit or sign to number-string
    5617             :  * ----------
    5618             :  */
    5619             : static void
    5620     8827970 : NUM_numpart_to_char(NUMProc *Np, int id)
    5621             : {
    5622             :     int         end;
    5623             : 
    5624     8827970 :     if (IS_ROMAN(Np->Num))
    5625           0 :         return;
    5626             : 
    5627             :     /* Note: in this elog() output not set '\0' in 'inout' */
    5628             : 
    5629             : #ifdef DEBUG_TO_FROM_CHAR
    5630             : 
    5631             :     /*
    5632             :      * Np->num_curr is number of current item in format-picture, it is not
    5633             :      * current position in inout!
    5634             :      */
    5635             :     elog(DEBUG_elog_output,
    5636             :          "SIGN_WROTE: %d, CURRENT: %d, NUMBER_P: \"%s\", INOUT: \"%s\"",
    5637             :          Np->sign_wrote,
    5638             :          Np->num_curr,
    5639             :          Np->number_p,
    5640             :          Np->inout);
    5641             : #endif
    5642     8827970 :     Np->num_in = false;
    5643             : 
    5644             :     /*
    5645             :      * Write sign if real number will write to output Note: IS_PREDEC_SPACE()
    5646             :      * handle "9.9" --> " .1"
    5647             :      */
    5648     8827970 :     if (Np->sign_wrote == false &&
    5649       14646 :         (Np->num_curr >= Np->out_pre_spaces || (IS_ZERO(Np->Num) && Np->Num->zero_start == Np->num_curr)) &&
    5650        2982 :         (IS_PREDEC_SPACE(Np) == false || (Np->last_relevant && *Np->last_relevant == '.')))
    5651             :     {
    5652        2838 :         if (IS_LSIGN(Np->Num))
    5653             :         {
    5654        1938 :             if (Np->Num->lsign == NUM_LSIGN_PRE)
    5655             :             {
    5656         360 :                 if (Np->sign == '-')
    5657         114 :                     strcpy(Np->inout_p, Np->L_negative_sign);
    5658             :                 else
    5659         246 :                     strcpy(Np->inout_p, Np->L_positive_sign);
    5660         360 :                 Np->inout_p += strlen(Np->inout_p);
    5661         360 :                 Np->sign_wrote = true;
    5662             :             }
    5663             :         }
    5664         900 :         else if (IS_BRACKET(Np->Num))
    5665             :         {
    5666         144 :             *Np->inout_p = Np->sign == '+' ? ' ' : '<';
    5667         144 :             ++Np->inout_p;
    5668         144 :             Np->sign_wrote = true;
    5669             :         }
    5670         756 :         else if (Np->sign == '+')
    5671             :         {
    5672         492 :             if (!IS_FILLMODE(Np->Num))
    5673             :             {
    5674         492 :                 *Np->inout_p = ' '; /* Write + */
    5675         492 :                 ++Np->inout_p;
    5676             :             }
    5677         492 :             Np->sign_wrote = true;
    5678             :         }
    5679         264 :         else if (Np->sign == '-')
    5680             :         {                       /* Write - */
    5681         264 :             *Np->inout_p = '-';
    5682         264 :             ++Np->inout_p;
    5683         264 :             Np->sign_wrote = true;
    5684             :         }
    5685             :     }
    5686             : 
    5687             : 
    5688             :     /*
    5689             :      * digits / FM / Zero / Dec. point
    5690             :      */
    5691     8827970 :     if (id == NUM_9 || id == NUM_0 || id == NUM_D || id == NUM_DEC)
    5692             :     {
    5693     8827970 :         if (Np->num_curr < Np->out_pre_spaces &&
    5694     5348294 :             (Np->Num->zero_start > Np->num_curr || !IS_ZERO(Np->Num)))
    5695             :         {
    5696             :             /*
    5697             :              * Write blank space
    5698             :              */
    5699       15456 :             if (!IS_FILLMODE(Np->Num))
    5700             :             {
    5701        9702 :                 *Np->inout_p = ' '; /* Write ' ' */
    5702        9702 :                 ++Np->inout_p;
    5703             :             }
    5704             :         }
    5705     8812514 :         else if (IS_ZERO(Np->Num) &&
    5706     8786054 :                  Np->num_curr < Np->out_pre_spaces &&
    5707     5332838 :                  Np->Num->zero_start <= Np->num_curr)
    5708             :         {
    5709             :             /*
    5710             :              * Write ZERO
    5711             :              */
    5712     5332838 :             *Np->inout_p = '0'; /* Write '0' */
    5713     5332838 :             ++Np->inout_p;
    5714     5332838 :             Np->num_in = true;
    5715             :         }
    5716             :         else
    5717             :         {
    5718             :             /*
    5719             :              * Write Decimal point
    5720             :              */
    5721     3479676 :             if (*Np->number_p == '.')
    5722             :             {
    5723        1568 :                 if (!Np->last_relevant || *Np->last_relevant != '.')
    5724             :                 {
    5725        1388 :                     strcpy(Np->inout_p, Np->decimal); /* Write DEC/D */
    5726        1388 :                     Np->inout_p += strlen(Np->inout_p);
    5727             :                 }
    5728             : 
    5729             :                 /*
    5730             :                  * Ora 'n' -- FM9.9 --> 'n.'
    5731             :                  */
    5732         180 :                 else if (IS_FILLMODE(Np->Num) &&
    5733         180 :                          Np->last_relevant && *Np->last_relevant == '.')
    5734             :                 {
    5735         180 :                     strcpy(Np->inout_p, Np->decimal); /* Write DEC/D */
    5736         180 :                     Np->inout_p += strlen(Np->inout_p);
    5737             :                 }
    5738             :             }
    5739             :             else
    5740             :             {
    5741             :                 /*
    5742             :                  * Write Digits
    5743             :                  */
    5744     3478108 :                 if (Np->last_relevant && Np->number_p > Np->last_relevant &&
    5745             :                     id != NUM_0)
    5746             :                     ;
    5747             : 
    5748             :                 /*
    5749             :                  * '0.1' -- 9.9 --> '  .1'
    5750             :                  */
    5751     3471436 :                 else if (IS_PREDEC_SPACE(Np))
    5752             :                 {
    5753         228 :                     if (!IS_FILLMODE(Np->Num))
    5754             :                     {
    5755         156 :                         *Np->inout_p = ' ';
    5756         156 :                         ++Np->inout_p;
    5757             :                     }
    5758             : 
    5759             :                     /*
    5760             :                      * '0' -- FM9.9 --> '0.'
    5761             :                      */
    5762          72 :                     else if (Np->last_relevant && *Np->last_relevant == '.')
    5763             :                     {
    5764          60 :                         *Np->inout_p = '0';
    5765          60 :                         ++Np->inout_p;
    5766             :                     }
    5767             :                 }
    5768             :                 else
    5769             :                 {
    5770     3471208 :                     *Np->inout_p = *Np->number_p; /* Write DIGIT */
    5771     3471208 :                     ++Np->inout_p;
    5772     3471208 :                     Np->num_in = true;
    5773             :                 }
    5774             :             }
    5775             :             /* do no exceed string length */
    5776     3479676 :             if (*Np->number_p)
    5777     3479334 :                 ++Np->number_p;
    5778             :         }
    5779             : 
    5780     8827970 :         end = Np->num_count + (Np->out_pre_spaces ? 1 : 0) + (IS_DECIMAL(Np->Num) ? 1 : 0);
    5781             : 
    5782     8827970 :         if (Np->last_relevant && Np->last_relevant == Np->number_p)
    5783         672 :             end = Np->num_curr;
    5784             : 
    5785     8827970 :         if (Np->num_curr + 1 == end)
    5786             :         {
    5787      995454 :             if (Np->sign_wrote == true && IS_BRACKET(Np->Num))
    5788             :             {
    5789         144 :                 *Np->inout_p = Np->sign == '+' ? ' ' : '>';
    5790         144 :                 ++Np->inout_p;
    5791             :             }
    5792      995310 :             else if (IS_LSIGN(Np->Num) && Np->Num->lsign == NUM_LSIGN_POST)
    5793             :             {
    5794          92 :                 if (Np->sign == '-')
    5795          50 :                     strcpy(Np->inout_p, Np->L_negative_sign);
    5796             :                 else
    5797          42 :                     strcpy(Np->inout_p, Np->L_positive_sign);
    5798          92 :                 Np->inout_p += strlen(Np->inout_p);
    5799             :             }
    5800             :         }
    5801             :     }
    5802             : 
    5803     8827970 :     ++Np->num_curr;
    5804             : }
    5805             : 
    5806             : /*
    5807             :  * Skip over "n" input characters, but only if they aren't numeric data
    5808             :  */
    5809             : static void
    5810          36 : NUM_eat_non_data_chars(NUMProc *Np, int n, int input_len)
    5811             : {
    5812          66 :     while (n-- > 0)
    5813             :     {
    5814          42 :         if (OVERLOAD_TEST)
    5815           0 :             break;              /* end of input */
    5816          42 :         if (strchr("0123456789.,+-", *Np->inout_p) != NULL)
    5817          12 :             break;              /* it's a data character */
    5818          30 :         Np->inout_p += pg_mblen(Np->inout_p);
    5819             :     }
    5820          36 : }
    5821             : 
    5822             : static char *
    5823      995940 : NUM_processor(FormatNode *node, NUMDesc *Num, char *inout,
    5824             :               char *number, int input_len, int to_char_out_pre_spaces,
    5825             :               int sign, bool is_to_char, Oid collid)
    5826             : {
    5827             :     FormatNode *n;
    5828             :     NUMProc     _Np,
    5829      995940 :                *Np = &_Np;
    5830             :     const char *pattern;
    5831             :     int         pattern_len;
    5832             : 
    5833    17926920 :     MemSet(Np, 0, sizeof(NUMProc));
    5834             : 
    5835      995940 :     Np->Num = Num;
    5836      995940 :     Np->is_to_char = is_to_char;
    5837      995940 :     Np->number = number;
    5838      995940 :     Np->inout = inout;
    5839      995940 :     Np->last_relevant = NULL;
    5840      995940 :     Np->read_post = 0;
    5841      995940 :     Np->read_pre = 0;
    5842      995940 :     Np->read_dec = false;
    5843             : 
    5844      995940 :     if (Np->Num->zero_start)
    5845      993592 :         --Np->Num->zero_start;
    5846             : 
    5847      995940 :     if (IS_EEEE(Np->Num))
    5848             :     {
    5849         318 :         if (!Np->is_to_char)
    5850           0 :             ereport(ERROR,
    5851             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    5852             :                      errmsg("\"EEEE\" not supported for input")));
    5853         318 :         return strcpy(inout, number);
    5854             :     }
    5855             : 
    5856             :     /*
    5857             :      * Roman correction
    5858             :      */
    5859      995622 :     if (IS_ROMAN(Np->Num))
    5860             :     {
    5861           0 :         if (!Np->is_to_char)
    5862           0 :             ereport(ERROR,
    5863             :                     (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
    5864             :                      errmsg("\"RN\" not supported for input")));
    5865             : 
    5866           0 :         Np->Num->lsign = Np->Num->pre_lsign_num = Np->Num->post =
    5867           0 :             Np->Num->pre = Np->out_pre_spaces = Np->sign = 0;
    5868             : 
    5869           0 :         if (IS_FILLMODE(Np->Num))
    5870             :         {
    5871           0 :             Np->Num->flag = 0;
    5872           0 :             Np->Num->flag |= NUM_F_FILLMODE;
    5873             :         }
    5874             :         else
    5875           0 :             Np->Num->flag = 0;
    5876           0 :         Np->Num->flag |= NUM_F_ROMAN;
    5877             :     }
    5878             : 
    5879             :     /*
    5880             :      * Sign
    5881             :      */
    5882      995622 :     if (is_to_char)
    5883             :     {
    5884      995478 :         Np->sign = sign;
    5885             : 
    5886             :         /* MI/PL/SG - write sign itself and not in number */
    5887      995478 :         if (IS_PLUS(Np->Num) || IS_MINUS(Np->Num))
    5888             :         {
    5889         522 :             if (IS_PLUS(Np->Num) && IS_MINUS(Np->Num) == false)
    5890           0 :                 Np->sign_wrote = false; /* need sign */
    5891             :             else
    5892         522 :                 Np->sign_wrote = true;   /* needn't sign */
    5893             :         }
    5894             :         else
    5895             :         {
    5896      994956 :             if (Np->sign != '-')
    5897             :             {
    5898      994432 :                 if (IS_FILLMODE(Np->Num))
    5899      993706 :                     Np->Num->flag &= ~NUM_F_BRACKET;
    5900             :             }
    5901             : 
    5902      994956 :             if (Np->sign == '+' && IS_FILLMODE(Np->Num) && IS_LSIGN(Np->Num) == false)
    5903      993598 :                 Np->sign_wrote = true;   /* needn't sign */
    5904             :             else
    5905        1358 :                 Np->sign_wrote = false; /* need sign */
    5906             : 
    5907      994956 :             if (Np->Num->lsign == NUM_LSIGN_PRE && Np->Num->pre == Np->Num->pre_lsign_num)
    5908          30 :                 Np->Num->lsign = NUM_LSIGN_POST;
    5909             :         }
    5910             :     }
    5911             :     else
    5912         144 :         Np->sign = false;
    5913             : 
    5914             :     /*
    5915             :      * Count
    5916             :      */
    5917      995622 :     Np->num_count = Np->Num->post + Np->Num->pre - 1;
    5918             : 
    5919      995622 :     if (is_to_char)
    5920             :     {
    5921      995478 :         Np->out_pre_spaces = to_char_out_pre_spaces;
    5922             : 
    5923      995478 :         if (IS_FILLMODE(Np->Num) && IS_DECIMAL(Np->Num))
    5924             :         {
    5925         678 :             Np->last_relevant = get_last_relevant_decnum(Np->number);
    5926             : 
    5927             :             /*
    5928             :              * If any '0' specifiers are present, make sure we don't strip
    5929             :              * those digits.  But don't advance last_relevant beyond the last
    5930             :              * character of the Np->number string, which is a hazard if the
    5931             :              * number got shortened due to precision limitations.
    5932             :              */
    5933         678 :             if (Np->last_relevant && Np->Num->zero_end > Np->out_pre_spaces)
    5934             :             {
    5935             :                 int         last_zero_pos;
    5936             :                 char       *last_zero;
    5937             : 
    5938             :                 /* note that Np->number cannot be zero-length here */
    5939         276 :                 last_zero_pos = strlen(Np->number) - 1;
    5940         276 :                 last_zero_pos = Min(last_zero_pos,
    5941             :                                     Np->Num->zero_end - Np->out_pre_spaces);
    5942         276 :                 last_zero = Np->number + last_zero_pos;
    5943         276 :                 if (Np->last_relevant < last_zero)
    5944         144 :                     Np->last_relevant = last_zero;
    5945             :             }
    5946             :         }
    5947             : 
    5948      995478 :         if (Np->sign_wrote == false && Np->out_pre_spaces == 0)
    5949         380 :             ++Np->num_count;
    5950             :     }
    5951             :     else
    5952             :     {
    5953         144 :         Np->out_pre_spaces = 0;
    5954         144 :         *Np->number = ' ';       /* sign space */
    5955         144 :         *(Np->number + 1) = '\0';
    5956             :     }
    5957             : 
    5958      995622 :     Np->num_in = 0;
    5959      995622 :     Np->num_curr = 0;
    5960             : 
    5961             : #ifdef DEBUG_TO_FROM_CHAR
    5962             :     elog(DEBUG_elog_output,
    5963             :          "\n\tSIGN: '%c'\n\tNUM: '%s'\n\tPRE: %d\n\tPOST: %d\n\tNUM_COUNT: %d\n\tNUM_PRE: %d\n\tSIGN_WROTE: %s\n\tZERO: %s\n\tZERO_START: %d\n\tZERO_END: %d\n\tLAST_RELEVANT: %s\n\tBRACKET: %s\n\tPLUS: %s\n\tMINUS: %s\n\tFILLMODE: %s\n\tROMAN: %s\n\tEEEE: %s",
    5964             :          Np->sign,
    5965             :          Np->number,
    5966             :          Np->Num->pre,
    5967             :          Np->Num->post,
    5968             :          Np->num_count,
    5969             :          Np->out_pre_spaces,
    5970             :          Np->sign_wrote ? "Yes" : "No",
    5971             :          IS_ZERO(Np->Num) ? "Yes" : "No",
    5972             :          Np->Num->zero_start,
    5973             :          Np->Num->zero_end,
    5974             :          Np->last_relevant ? Np->last_relevant : "<not set>",
    5975             :          IS_BRACKET(Np->Num) ? "Yes" : "No",
    5976             :          IS_PLUS(Np->Num) ? "Yes" : "No",
    5977             :          IS_MINUS(Np->Num) ? "Yes" : "No",
    5978             :          IS_FILLMODE(Np->Num) ? "Yes" : "No",
    5979             :          IS_ROMAN(Np->Num) ? "Yes" : "No",
    5980             :          IS_EEEE(Np->Num) ? "Yes" : "No"
    5981             :         );
    5982             : #endif
    5983             : 
    5984             :     /*
    5985             :      * Locale
    5986             :      */
    5987      995622 :     NUM_prepare_locale(Np);
    5988             : 
    5989             :     /*
    5990             :      * Processor direct cycle
    5991             :      */
    5992      995622 :     if (Np->is_to_char)
    5993      995478 :         Np->number_p = Np->number;
    5994             :     else
    5995         144 :         Np->number_p = Np->number + 1;    /* first char is space for sign */
    5996             : 
    5997    10830104 :     for (n = node, Np->inout_p = Np->inout; n->type != NODE_TYPE_END; n++)
    5998             :     {
    5999     9834560 :         if (!Np->is_to_char)
    6000             :         {
    6001             :             /*
    6002             :              * Check at least one byte remains to be scanned.  (In actions
    6003             :              * below, must use AMOUNT_TEST if we want to read more bytes than
    6004             :              * that.)
    6005             :              */
    6006        1158 :             if (OVERLOAD_TEST)
    6007          78 :                 break;
    6008             :         }
    6009             : 
    6010             :         /*
    6011             :          * Format pictures actions
    6012             :          */
    6013     9834482 :         if (n->type == NODE_TYPE_ACTION)
    6014             :         {
    6015             :             /*
    6016             :              * Create/read digit/zero/blank/sign/special-case
    6017             :              *
    6018             :              * 'NUM_S' note: The locale sign is anchored to number and we
    6019             :              * read/write it when we work with first or last number
    6020             :              * (NUM_0/NUM_9).  This is why NUM_S is missing in switch().
    6021             :              *
    6022             :              * Notice the "Np->inout_p++" at the bottom of the loop.  This is
    6023             :              * why most of the actions advance inout_p one less than you might
    6024             :              * expect.  In cases where we don't want that increment to happen,
    6025             :              * a switch case ends with "continue" not "break".
    6026             :              */
    6027     9825854 :             switch (n->key->id)
    6028             :             {
    6029     8828828 :                 case NUM_9:
    6030             :                 case NUM_0:
    6031             :                 case NUM_DEC:
    6032             :                 case NUM_D:
    6033     8828828 :                     if (Np->is_to_char)
    6034             :                     {
    6035     8827970 :                         NUM_numpart_to_char(Np, n->key->id);
    6036     8827970 :                         continue;   /* for() */
    6037             :                     }
    6038             :                     else
    6039             :                     {
    6040         858 :                         NUM_numpart_from_char(Np, n->key->id, input_len);
    6041         858 :                         break;  /* switch() case: */
    6042             :                     }
    6043             : 
    6044         366 :                 case NUM_COMMA:
    6045         366 :                     if (Np->is_to_char)
    6046             :                     {
    6047         330 :                         if (!Np->num_in)
    6048             :                         {
    6049         120 :                             if (IS_FILLMODE(Np->Num))
    6050           0 :                                 continue;
    6051             :                             else
    6052         120 :                                 *Np->inout_p = ' ';
    6053             :                         }
    6054             :                         else
    6055         210 :                             *Np->inout_p = ',';
    6056             :                     }
    6057             :                     else
    6058             :                     {
    6059          36 :                         if (!Np->num_in)
    6060             :                         {
    6061          36 :                             if (IS_FILLMODE(Np->Num))
    6062           0 :                                 continue;
    6063             :                         }
    6064          36 :                         if (*Np->inout_p != ',')
    6065          36 :                             continue;
    6066             :                     }
    6067         330 :                     break;
    6068             : 
    6069        1224 :                 case NUM_G:
    6070        1224 :                     pattern = Np->L_thousands_sep;
    6071        1224 :                     pattern_len = strlen(pattern);
    6072        1224 :                     if (Np->is_to_char)
    6073             :                     {
    6074        1170 :                         if (!Np->num_in)
    6075             :                         {
    6076         588 :                             if (IS_FILLMODE(Np->Num))
    6077           0 :                                 continue;
    6078             :                             else
    6079             :                             {
    6080             :                                 /* just in case there are MB chars */
    6081         588 :                                 pattern_len = pg_mbstrlen(pattern);
    6082         588 :                                 memset(Np->inout_p, ' ', pattern_len);
    6083         588 :                                 Np->inout_p += pattern_len - 1;
    6084             :                             }
    6085             :                         }
    6086             :                         else
    6087             :                         {
    6088         582 :                             strcpy(Np->inout_p, pattern);
    6089         582 :                             Np->inout_p += pattern_len - 1;
    6090             :                         }
    6091             :                     }
    6092             :                     else
    6093             :                     {
    6094          54 :                         if (!Np->num_in)
    6095             :                         {
    6096          54 :                             if (IS_FILLMODE(Np->Num))
    6097           0 :                                 continue;
    6098             :                         }
    6099             : 
    6100             :                         /*
    6101             :                          * Because L_thousands_sep typically contains data
    6102             :                          * characters (either '.' or ','), we can't use
    6103             :                          * NUM_eat_non_data_chars here.  Instead skip only if
    6104             :                          * the input matches L_thousands_sep.
    6105             :                          */
    6106          54 :                         if (AMOUNT_TEST(pattern_len) &&
    6107          54 :                             strncmp(Np->inout_p, pattern, pattern_len) == 0)
    6108          48 :                             Np->inout_p += pattern_len - 1;
    6109             :                         else
    6110           6 :                             continue;
    6111             :                     }
    6112        1218 :                     break;
    6113             : 
    6114         120 :                 case NUM_L:
    6115         120 :                     pattern = Np->L_currency_symbol;
    6116         120 :                     if (Np->is_to_char)
    6117             :                     {
    6118          90 :                         strcpy(Np->inout_p, pattern);
    6119          90 :                         Np->inout_p += strlen(pattern) - 1;
    6120             :                     }
    6121             :                     else
    6122             :                     {
    6123          30 :                         NUM_eat_non_data_chars(Np, pg_mbstrlen(pattern), input_len);
    6124          30 :                         continue;
    6125             :                     }
    6126          90 :                     break;
    6127             : 
    6128           0 :                 case NUM_RN:
    6129           0 :                     if (IS_FILLMODE(Np->Num))
    6130             :                     {
    6131           0 :                         strcpy(Np->inout_p, Np->number_p);
    6132           0 :                         Np->inout_p += strlen(Np->inout_p) - 1;
    6133             :                     }
    6134             :                     else
    6135             :                     {
    6136           0 :                         sprintf(Np->inout_p, "%15s", Np->number_p);
    6137           0 :                         Np->inout_p += strlen(Np->inout_p) - 1;
    6138             :                     }
    6139           0 :                     break;
    6140             : 
    6141           0 :                 case NUM_rn:
    6142           0 :                     if (IS_FILLMODE(Np->Num))
    6143             :                     {
    6144           0 :                         strcpy(Np->inout_p, asc_tolower_z(Np->number_p));
    6145           0 :                         Np->inout_p += strlen(Np->inout_p) - 1;
    6146             :                     }
    6147             :                     else
    6148             :                     {
    6149           0 :                         sprintf(Np->inout_p, "%15s", asc_tolower_z(Np->number_p));
    6150           0 :                         Np->inout_p += strlen(Np->inout_p) - 1;
    6151             :                     }
    6152           0 :                     break;
    6153             : 
    6154          96 :                 case NUM_th:
    6155          96 :                     if (IS_ROMAN(Np->Num) || *Np->number == '#' ||
    6156          96 :                         Np->sign == '-' || IS_DECIMAL(Np->Num))
    6157          66 :                         continue;
    6158             : 
    6159          30 :                     if (Np->is_to_char)
    6160             :                     {
    6161          24 :                         strcpy(Np->inout_p, get_th(Np->number, TH_LOWER));
    6162          24 :                         Np->inout_p += 1;
    6163             :                     }
    6164             :                     else
    6165             :                     {
    6166             :                         /* All variants of 'th' occupy 2 characters */
    6167           6 :                         NUM_eat_non_data_chars(Np, 2, input_len);
    6168           6 :                         continue;
    6169             :                     }
    6170          24 :                     break;
    6171             : 
    6172          90 :                 case NUM_TH:
    6173          90 :                     if (IS_ROMAN(Np->Num) || *Np->number == '#' ||
    6174          90 :                         Np->sign == '-' || IS_DECIMAL(Np->Num))
    6175          66 :                         continue;
    6176             : 
    6177          24 :                     if (Np->is_to_char)
    6178             :                     {
    6179          24 :                         strcpy(Np->inout_p, get_th(Np->number, TH_UPPER));
    6180          24 :                         Np->inout_p += 1;
    6181             :                     }
    6182             :                     else
    6183             :                     {
    6184             :                         /* All variants of 'TH' occupy 2 characters */
    6185           0 :                         NUM_eat_non_data_chars(Np, 2, input_len);
    6186           0 :                         continue;
    6187             :                     }
    6188          24 :                     break;
    6189             : 
    6190         342 :                 case NUM_MI:
    6191         342 :                     if (Np->is_to_char)
    6192             :                     {
    6193         342 :                         if (Np->sign == '-')
    6194          96 :                             *Np->inout_p = '-';
    6195         246 :                         else if (IS_FILLMODE(Np->Num))
    6196           0 :                             continue;
    6197             :                         else
    6198         246 :                             *Np->inout_p = ' ';
    6199             :                     }
    6200             :                     else
    6201             :                     {
    6202           0 :                         if (*Np->inout_p == '-')
    6203           0 :                             *Np->number = '-';
    6204             :                         else
    6205             :                         {
    6206           0 :                             NUM_eat_non_data_chars(Np, 1, input_len);
    6207           0 :                             continue;
    6208             :                         }
    6209             :                     }
    6210         342 :                     break;
    6211             : 
    6212           0 :                 case NUM_PL:
    6213           0 :                     if (Np->is_to_char)
    6214             :                     {
    6215           0 :                         if (Np->sign == '+')
    6216           0 :                             *Np->inout_p = '+';
    6217           0 :                         else if (IS_FILLMODE(Np->Num))
    6218           0 :                             continue;
    6219             :                         else
    6220           0 :                             *Np->inout_p = ' ';
    6221             :                     }
    6222             :                     else
    6223             :                     {
    6224           0 :                         if (*Np->inout_p == '+')
    6225           0 :                             *Np->number = '+';
    6226             :                         else
    6227             :                         {
    6228           0 :                             NUM_eat_non_data_chars(Np, 1, input_len);
    6229           0 :                             continue;
    6230             :                         }
    6231             :                     }
    6232           0 :                     break;
    6233             : 
    6234         180 :                 case NUM_SG:
    6235         180 :                     if (Np->is_to_char)
    6236         180 :                         *Np->inout_p = Np->sign;
    6237             :                     else
    6238             :                     {
    6239           0 :                         if (*Np->inout_p == '-')
    6240           0 :                             *Np->number = '-';
    6241           0 :                         else if (*Np->inout_p == '+')
    6242           0 :                             *Np->number = '+';
    6243             :                         else
    6244             :                         {
    6245           0 :                             NUM_eat_non_data_chars(Np, 1, input_len);
    6246           0 :                             continue;
    6247             :                         }
    6248             :                     }
    6249         180 :                     break;
    6250             : 
    6251      994608 :                 default:
    6252      994608 :                     continue;
    6253             :                     break;
    6254             :             }
    6255             :         }
    6256             :         else
    6257             :         {
    6258             :             /*
    6259             :              * In TO_CHAR, non-pattern characters in the format are copied to
    6260             :              * the output.  In TO_NUMBER, we skip one input character for each
    6261             :              * non-pattern format character, whether or not it matches the
    6262             :              * format character.
    6263             :              */
    6264        8628 :             if (Np->is_to_char)
    6265             :             {
    6266        8562 :                 strcpy(Np->inout_p, n->character);
    6267        8562 :                 Np->inout_p += strlen(Np->inout_p);
    6268             :             }
    6269             :             else
    6270             :             {
    6271          66 :                 Np->inout_p += pg_mblen(Np->inout_p);
    6272             :             }
    6273        8628 :             continue;
    6274             :         }
    6275        3066 :         Np->inout_p++;
    6276             :     }
    6277             : 
    6278      995622 :     if (Np->is_to_char)
    6279             :     {
    6280      995478 :         *Np->inout_p = '\0';
    6281      995478 :         return Np->inout;
    6282             :     }
    6283             :     else
    6284             :     {
    6285         144 :         if (*(Np->number_p - 1) == '.')
    6286           0 :             *(Np->number_p - 1) = '\0';
    6287             :         else
    6288         144 :             *Np->number_p = '\0';
    6289             : 
    6290             :         /*
    6291             :          * Correction - precision of dec. number
    6292             :          */
    6293         144 :         Np->Num->post = Np->read_post;
    6294             : 
    6295             : #ifdef DEBUG_TO_FROM_CHAR
    6296             :         elog(DEBUG_elog_output, "TO_NUMBER (number): '%s'", Np->number);
    6297             : #endif
    6298         144 :         return Np->number;
    6299             :     }
    6300             : }
    6301             : 
    6302             : /* ----------
    6303             :  * MACRO: Start part of NUM - for all NUM's to_char variants
    6304             :  *  (sorry, but I hate copy same code - macro is better..)
    6305             :  * ----------
    6306             :  */
    6307             : #define NUM_TOCHAR_prepare \
    6308             : do { \
    6309             :     int len = VARSIZE_ANY_EXHDR(fmt); \
    6310             :     if (len <= 0 || len >= (INT_MAX-VARHDRSZ)/NUM_MAX_ITEM_SIZ)       \
    6311             :         PG_RETURN_TEXT_P(cstring_to_text("")); \
    6312             :     result  = (text *) palloc0((len * NUM_MAX_ITEM_SIZ) + 1 + VARHDRSZ);    \
    6313             :     format  = NUM_cache(len, &Num, fmt, &shouldFree);       \
    6314             : } while (0)
    6315             : 
    6316             : /* ----------
    6317             :  * MACRO: Finish part of NUM
    6318             :  * ----------
    6319             :  */
    6320             : #define NUM_TOCHAR_finish \
    6321             : do { \
    6322             :     int     len; \
    6323             :                                     \
    6324             :     NUM_processor(format, &Num, VARDATA(result), numstr, 0, out_pre_spaces, sign, true, PG_GET_COLLATION()); \
    6325             :                                     \
    6326             :     if (shouldFree)                 \
    6327             :         pfree(format);              \
    6328             :                                     \
    6329             :     /*                              \
    6330             :      * Convert null-terminated representation of result to standard text. \
    6331             :      * The result is usually much bigger than it needs to be, but there \
    6332             :      * seems little point in realloc'ing it smaller. \
    6333             :      */                             \
    6334             :     len = strlen(VARDATA(result));  \
    6335             :     SET_VARSIZE(result, len + VARHDRSZ); \
    6336             : } while (0)
    6337             : 
    6338             : /* -------------------
    6339             :  * NUMERIC to_number() (convert string to numeric)
    6340             :  * -------------------
    6341             :  */
    6342             : Datum
    6343         144 : numeric_to_number(PG_FUNCTION_ARGS)
    6344             : {
    6345         144 :     text       *value = PG_GETARG_TEXT_PP(0);
    6346         144 :     text       *fmt = PG_GETARG_TEXT_PP(1);
    6347             :     NUMDesc     Num;
    6348             :     Datum       result;
    6349             :     FormatNode *format;
    6350             :     char       *numstr;
    6351             :     bool        shouldFree;
    6352         144 :     int         len = 0;
    6353             :     int         scale,
    6354             :                 precision;
    6355             : 
    6356         144 :     len = VARSIZE_ANY_EXHDR(fmt);
    6357             : 
    6358         144 :     if (len <= 0 || len >= INT_MAX / NUM_MAX_ITEM_SIZ)
    6359           0 :         PG_RETURN_NULL();
    6360             : 
    6361         144 :     format = NUM_cache(len, &Num, fmt, &shouldFree);
    6362             : 
    6363         144 :     numstr = (char *) palloc((len * NUM_MAX_ITEM_SIZ) + 1);
    6364             : 
    6365         144 :     NUM_processor(format, &Num, VARDATA_ANY(value), numstr,
    6366         144 :                   VARSIZE_ANY_EXHDR(value), 0, 0, false, PG_GET_COLLATION());
    6367             : 
    6368         144 :     scale = Num.post;
    6369         144 :     precision = Num.pre + Num.multi + scale;
    6370             : 
    6371         144 :     if (shouldFree)
    6372           0 :         pfree(format);
    6373             : 
    6374         144 :     result = DirectFunctionCall3(numeric_in,
    6375             :                                  CStringGetDatum(numstr),
    6376             :                                  ObjectIdGetDatum(InvalidOid),
    6377             :                                  Int32GetDatum(((precision << 16) | scale) + VARHDRSZ));
    6378             : 
    6379         144 :     if (IS_MULTI(&Num))
    6380             :     {
    6381             :         Numeric     x;
    6382           0 :         Numeric     a = int64_to_numeric(10);
    6383           0 :         Numeric     b = int64_to_numeric(-Num.multi);
    6384             : 
    6385           0 :         x = DatumGetNumeric(DirectFunctionCall2(numeric_power,
    6386             :                                                 NumericGetDatum(a),
    6387             :                                                 NumericGetDatum(b)));
    6388           0 :         result = DirectFunctionCall2(numeric_mul,
    6389             :                                      result,
    6390             :                                      NumericGetDatum(x));
    6391             :     }
    6392             : 
    6393         144 :     pfree(numstr);
    6394         144 :     return result;
    6395             : }
    6396             : 
    6397             : /* ------------------
    6398             :  * NUMERIC to_char()
    6399             :  * ------------------
    6400             :  */
    6401             : Datum
    6402        1718 : numeric_to_char(PG_FUNCTION_ARGS)
    6403             : {
    6404        1718 :     Numeric     value = PG_GETARG_NUMERIC(0);
    6405        1718 :     text       *fmt = PG_GETARG_TEXT_PP(1);
    6406             :     NUMDesc     Num;
    6407             :     FormatNode *format;
    6408             :     text       *result;
    6409             :     bool        shouldFree;
    6410        1718 :     int         out_pre_spaces = 0,
    6411        1718 :                 sign = 0;
    6412             :     char       *numstr,
    6413             :                *orgnum,
    6414             :                *p;
    6415             :     Numeric     x;
    6416             : 
    6417        1718 :     NUM_TOCHAR_prepare;
    6418             : 
    6419             :     /*
    6420             :      * On DateType depend part (numeric)
    6421             :      */
    6422        1718 :     if (IS_ROMAN(&Num))
    6423             :     {
    6424           0 :         x = DatumGetNumeric(DirectFunctionCall2(numeric_round,
    6425             :                                                 NumericGetDatum(value),
    6426             :                                                 Int32GetDatum(0)));
    6427             :         numstr =
    6428           0 :             int_to_roman(DatumGetInt32(DirectFunctionCall1(numeric_int4,
    6429             :                                                            NumericGetDatum(x))));
    6430             :     }
    6431        1718 :     else if (IS_EEEE(&Num))
    6432             :     {
    6433         234 :         orgnum = numeric_out_sci(value, Num.post);
    6434             : 
    6435             :         /*
    6436             :          * numeric_out_sci() does not emit a sign for positive numbers.  We
    6437             :          * need to add a space in this case so that positive and negative
    6438             :          * numbers are aligned.  Also must check for NaN/infinity cases, which
    6439             :          * we handle the same way as in float8_to_char.
    6440             :          */
    6441         234 :         if (strcmp(orgnum, "NaN") == 0 ||
    6442         228 :             strcmp(orgnum, "Infinity") == 0 ||
    6443         222 :             strcmp(orgnum, "-Infinity") == 0)
    6444             :         {
    6445             :             /*
    6446             :              * Allow 6 characters for the leading sign, the decimal point,
    6447             :              * "e", the exponent's sign and two exponent digits.
    6448             :              */
    6449          18 :             numstr = (char *) palloc(Num.pre + Num.post + 7);
    6450          18 :             fill_str(numstr, '#', Num.pre + Num.post + 6);
    6451          18 :             *numstr = ' ';
    6452          18 :             *(numstr + Num.pre + 1) = '.';
    6453             :         }
    6454         216 :         else if (*orgnum != '-')
    6455             :         {
    6456         192 :             numstr = (char *) palloc(strlen(orgnum) + 2);
    6457         192 :             *numstr = ' ';
    6458         192 :             strcpy(numstr + 1, orgnum);
    6459             :         }
    6460             :         else
    6461             :         {
    6462          24 :             numstr = orgnum;
    6463             :         }
    6464             :     }
    6465             :     else
    6466             :     {
    6467             :         int         numstr_pre_len;
    6468        1484 :         Numeric     val = value;
    6469             : 
    6470        1484 :         if (IS_MULTI(&Num))
    6471             :         {
    6472           0 :             Numeric     a = int64_to_numeric(10);
    6473           0 :             Numeric     b = int64_to_numeric(Num.multi);
    6474             : 
    6475           0 :             x = DatumGetNumeric(DirectFunctionCall2(numeric_power,
    6476             :                                                     NumericGetDatum(a),
    6477             :                                                     NumericGetDatum(b)));
    6478           0 :             val = DatumGetNumeric(DirectFunctionCall2(numeric_mul,
    6479             :                                                       NumericGetDatum(value),
    6480             :                                                       NumericGetDatum(x)));
    6481           0 :             Num.pre += Num.multi;
    6482             :         }
    6483             : 
    6484        1484 :         x = DatumGetNumeric(DirectFunctionCall2(numeric_round,
    6485             :                                                 NumericGetDatum(val),
    6486             :                                                 Int32GetDatum(Num.post)));
    6487        1484 :         orgnum = DatumGetCString(DirectFunctionCall1(numeric_out,
    6488             :                                                      NumericGetDatum(x)));
    6489             : 
    6490        1484 :         if (*orgnum == '-')
    6491             :         {
    6492         422 :             sign = '-';
    6493         422 :             numstr = orgnum + 1;
    6494             :         }
    6495             :         else
    6496             :         {
    6497        1062 :             sign = '+';
    6498        1062 :             numstr = orgnum;
    6499             :         }
    6500             : 
    6501        1484 :         if ((p = strchr(numstr, '.')))
    6502        1196 :             numstr_pre_len = p - numstr;
    6503             :         else
    6504         288 :             numstr_pre_len = strlen(numstr);
    6505             : 
    6506             :         /* needs padding? */
    6507        1484 :         if (numstr_pre_len < Num.pre)
    6508        1374 :             out_pre_spaces = Num.pre - numstr_pre_len;
    6509             :         /* overflowed prefix digit format? */
    6510         110 :         else if (numstr_pre_len > Num.pre)
    6511             :         {
    6512          30 :             numstr = (char *) palloc(Num.pre + Num.post + 2);
    6513          30 :             fill_str(numstr, '#', Num.pre + Num.post + 1);
    6514          30 :             *(numstr + Num.pre) = '.';
    6515             :         }
    6516             :     }
    6517             : 
    6518        1718 :     NUM_TOCHAR_finish;
    6519        1718 :     PG_RETURN_TEXT_P(result);
    6520             : }
    6521             : 
    6522             : /* ---------------
    6523             :  * INT4 to_char()
    6524             :  * ---------------
    6525             :  */
    6526             : Datum
    6527      993170 : int4_to_char(PG_FUNCTION_ARGS)
    6528             : {
    6529      993170 :     int32       value = PG_GETARG_INT32(0);
    6530      993170 :     text       *fmt = PG_GETARG_TEXT_PP(1);
    6531             :     NUMDesc     Num;
    6532             :     FormatNode *format;
    6533             :     text       *result;
    6534             :     bool        shouldFree;
    6535      993170 :     int         out_pre_spaces = 0,
    6536      993170 :                 sign = 0;
    6537             :     char       *numstr,
    6538             :                *orgnum;
    6539             : 
    6540      993170 :     NUM_TOCHAR_prepare;
    6541             : 
    6542             :     /*
    6543             :      * On DateType depend part (int32)
    6544             :      */
    6545      993170 :     if (IS_ROMAN(&Num))
    6546           0 :         numstr = int_to_roman(value);
    6547      993170 :     else if (IS_EEEE(&Num))
    6548             :     {
    6549             :         /* we can do it easily because float8 won't lose any precision */
    6550           0 :         float8      val = (float8) value;
    6551             : 
    6552           0 :         orgnum = (char *) psprintf("%+.*e", Num.post, val);
    6553             : 
    6554             :         /*
    6555             :          * Swap a leading positive sign for a space.
    6556             :          */
    6557           0 :         if (*orgnum == '+')
    6558           0 :             *orgnum = ' ';
    6559             : 
    6560           0 :         numstr = orgnum;
    6561             :     }
    6562             :     else
    6563             :     {
    6564             :         int         numstr_pre_len;
    6565             : 
    6566      993170 :         if (IS_MULTI(&Num))
    6567             :         {
    6568           0 :             orgnum = DatumGetCString(DirectFunctionCall1(int4out,
    6569             :                                                          Int32GetDatum(value * ((int32) pow((double) 10, (double) Num.multi)))));
    6570           0 :             Num.pre += Num.multi;
    6571             :         }
    6572             :         else
    6573             :         {
    6574      993170 :             orgnum = DatumGetCString(DirectFunctionCall1(int4out,
    6575             :                                                          Int32GetDatum(value)));
    6576             :         }
    6577             : 
    6578      993170 :         if (*orgnum == '-')
    6579             :         {
    6580           0 :             sign = '-';
    6581           0 :             orgnum++;
    6582             :         }
    6583             :         else
    6584      993170 :             sign = '+';
    6585             : 
    6586      993170 :         numstr_pre_len = strlen(orgnum);
    6587             : 
    6588             :         /* post-decimal digits?  Pad out with zeros. */
    6589      993170 :         if (Num.post)
    6590             :         {
    6591           0 :             numstr = (char *) palloc(numstr_pre_len + Num.post + 2);
    6592           0 :             strcpy(numstr, orgnum);
    6593           0 :             *(numstr + numstr_pre_len) = '.';
    6594           0 :             memset(numstr + numstr_pre_len + 1, '0', Num.post);
    6595           0 :             *(numstr + numstr_pre_len + Num.post + 1) = '\0';
    6596             :         }
    6597             :         else
    6598      993170 :             numstr = orgnum;
    6599             : 
    6600             :         /* needs padding? */
    6601      993170 :         if (numstr_pre_len < Num.pre)
    6602      978876 :             out_pre_spaces = Num.pre - numstr_pre_len;
    6603             :         /* overflowed prefix digit format? */
    6604       14294 :         else if (numstr_pre_len > Num.pre)
    6605             :         {
    6606           0 :             numstr = (char *) palloc(Num.pre + Num.post + 2);
    6607           0 :             fill_str(numstr, '#', Num.pre + Num.post + 1);
    6608           0 :             *(numstr + Num.pre) = '.';
    6609             :         }
    6610             :     }
    6611             : 
    6612      993170 :     NUM_TOCHAR_finish;
    6613      993170 :     PG_RETURN_TEXT_P(result);
    6614             : }
    6615             : 
    6616             : /* ---------------
    6617             :  * INT8 to_char()
    6618             :  * ---------------
    6619             :  */
    6620             : Datum
    6621         632 : int8_to_char(PG_FUNCTION_ARGS)
    6622             : {
    6623         632 :     int64       value = PG_GETARG_INT64(0);
    6624         632 :     text       *fmt = PG_GETARG_TEXT_PP(1);
    6625             :     NUMDesc     Num;
    6626             :     FormatNode *format;
    6627             :     text       *result;
    6628             :     bool        shouldFree;
    6629         632 :     int         out_pre_spaces = 0,
    6630         632 :                 sign = 0;
    6631             :     char       *numstr,
    6632             :                *orgnum;
    6633             : 
    6634         632 :     NUM_TOCHAR_prepare;
    6635             : 
    6636             :     /*
    6637             :      * On DateType depend part (int32)
    6638             :      */
    6639         632 :     if (IS_ROMAN(&Num))
    6640             :     {
    6641             :         /* Currently don't support int8 conversion to roman... */
    6642           0 :         numstr = int_to_roman(DatumGetInt32(DirectFunctionCall1(int84, Int64GetDatum(value))));
    6643             :     }
    6644         632 :     else if (IS_EEEE(&Num))
    6645             :     {
    6646             :         /* to avoid loss of precision, must go via numeric not float8 */
    6647           0 :         orgnum = numeric_out_sci(int64_to_numeric(value),
    6648             :                                  Num.post);
    6649             : 
    6650             :         /*
    6651             :          * numeric_out_sci() does not emit a sign for positive numbers.  We
    6652             :          * need to add a space in this case so that positive and negative
    6653             :          * numbers are aligned.  We don't have to worry about NaN/inf here.
    6654             :          */
    6655           0 :         if (*orgnum != '-')
    6656             :         {
    6657           0 :             numstr = (char *) palloc(strlen(orgnum) + 2);
    6658           0 :             *numstr = ' ';
    6659           0 :             strcpy(numstr + 1, orgnum);
    6660             :         }
    6661             :         else
    6662             :         {
    6663           0 :             numstr = orgnum;
    6664             :         }
    6665             :     }
    6666             :     else
    6667             :     {
    6668             :         int         numstr_pre_len;
    6669             : 
    6670         632 :         if (IS_MULTI(&Num))
    6671             :         {
    6672           0 :             double      multi = pow((double) 10, (double) Num.multi);
    6673             : 
    6674           0 :             value = DatumGetInt64(DirectFunctionCall2(int8mul,
    6675             :                                                       Int64GetDatum(value),
    6676             :                                                       DirectFunctionCall1(dtoi8,
    6677             :                                                                           Float8GetDatum(multi))));
    6678           0 :             Num.pre += Num.multi;
    6679             :         }
    6680             : 
    6681         632 :         orgnum = DatumGetCString(DirectFunctionCall1(int8out,
    6682             :                                                      Int64GetDatum(value)));
    6683             : 
    6684         632 :         if (*orgnum == '-')
    6685             :         {
    6686         198 :             sign = '-';
    6687         198 :             orgnum++;
    6688             :         }
    6689             :         else
    6690         434 :             sign = '+';
    6691             : 
    6692         632 :         numstr_pre_len = strlen(orgnum);
    6693             : 
    6694             :         /* post-decimal digits?  Pad out with zeros. */
    6695         632 :         if (Num.post)
    6696             :         {
    6697         210 :             numstr = (char *) palloc(numstr_pre_len + Num.post + 2);
    6698         210 :             strcpy(numstr, orgnum);
    6699         210 :             *(numstr + numstr_pre_len) = '.';
    6700         210 :             memset(numstr + numstr_pre_len + 1, '0', Num.post);
    6701         210 :             *(numstr + numstr_pre_len + Num.post + 1) = '\0';
    6702             :         }
    6703             :         else
    6704         422 :             numstr = orgnum;
    6705             : 
    6706             :         /* needs padding? */
    6707         632 :         if (numstr_pre_len < Num.pre)
    6708         252 :             out_pre_spaces = Num.pre - numstr_pre_len;
    6709             :         /* overflowed prefix digit format? */
    6710         380 :         else if (numstr_pre_len > Num.pre)
    6711             :         {
    6712           0 :             numstr = (char *) palloc(Num.pre + Num.post + 2);
    6713           0 :             fill_str(numstr, '#', Num.pre + Num.post + 1);
    6714           0 :             *(numstr + Num.pre) = '.';
    6715             :         }
    6716             :     }
    6717             : 
    6718         632 :     NUM_TOCHAR_finish;
    6719         632 :     PG_RETURN_TEXT_P(result);
    6720             : }
    6721             : 
    6722             : /* -----------------
    6723             :  * FLOAT4 to_char()
    6724             :  * -----------------
    6725             :  */
    6726             : Datum
    6727         130 : float4_to_char(PG_FUNCTION_ARGS)
    6728             : {
    6729         130 :     float4      value = PG_GETARG_FLOAT4(0);
    6730         130 :     text       *fmt = PG_GETARG_TEXT_PP(1);
    6731             :     NUMDesc     Num;
    6732             :     FormatNode *format;
    6733             :     text       *result;
    6734             :     bool        shouldFree;
    6735         130 :     int         out_pre_spaces = 0,
    6736         130 :                 sign = 0;
    6737             :     char       *numstr,
    6738             :                *p;
    6739             : 
    6740         130 :     NUM_TOCHAR_prepare;
    6741             : 
    6742         130 :     if (IS_ROMAN(&Num))
    6743           0 :         numstr = int_to_roman((int) rint(value));
    6744         130 :     else if (IS_EEEE(&Num))
    6745             :     {
    6746          42 :         if (isnan(value) || isinf(value))
    6747             :         {
    6748             :             /*
    6749             :              * Allow 6 characters for the leading sign, the decimal point,
    6750             :              * "e", the exponent's sign and two exponent digits.
    6751             :              */
    6752          18 :             numstr = (char *) palloc(Num.pre + Num.post + 7);
    6753          18 :             fill_str(numstr, '#', Num.pre + Num.post + 6);
    6754          18 :             *numstr = ' ';
    6755          18 :             *(numstr + Num.pre + 1) = '.';
    6756             :         }
    6757             :         else
    6758             :         {
    6759          24 :             numstr = psprintf("%+.*e", Num.post, value);
    6760             : 
    6761             :             /*
    6762             :              * Swap a leading positive sign for a space.
    6763             :              */
    6764          24 :             if (*numstr == '+')
    6765          18 :                 *numstr = ' ';
    6766             :         }
    6767             :     }
    6768             :     else
    6769             :     {
    6770          88 :         float4      val = value;
    6771             :         char       *orgnum;
    6772             :         int         numstr_pre_len;
    6773             : 
    6774          88 :         if (IS_MULTI(&Num))
    6775             :         {
    6776           0 :             float       multi = pow((double) 10, (double) Num.multi);
    6777             : 
    6778           0 :             val = value * multi;
    6779           0 :             Num.pre += Num.multi;
    6780             :         }
    6781             : 
    6782          88 :         orgnum = psprintf("%.0f", fabs(val));
    6783          88 :         numstr_pre_len = strlen(orgnum);
    6784             : 
    6785             :         /* adjust post digits to fit max float digits */
    6786          88 :         if (numstr_pre_len >= FLT_DIG)
    6787          36 :             Num.post = 0;
    6788          52 :         else if (numstr_pre_len + Num.post > FLT_DIG)
    6789           0 :             Num.post = FLT_DIG - numstr_pre_len;
    6790          88 :         orgnum = psprintf("%.*f", Num.post, val);
    6791             : 
    6792          88 :         if (*orgnum == '-')
    6793             :         {                       /* < 0 */
    6794          24 :             sign = '-';
    6795          24 :             numstr = orgnum + 1;
    6796             :         }
    6797             :         else
    6798             :         {
    6799          64 :             sign = '+';
    6800          64 :             numstr = orgnum;
    6801             :         }
    6802             : 
    6803          88 :         if ((p = strchr(numstr, '.')))
    6804          40 :             numstr_pre_len = p - numstr;
    6805             :         else
    6806          48 :             numstr_pre_len = strlen(numstr);
    6807             : 
    6808             :         /* needs padding? */
    6809          88 :         if (numstr_pre_len < Num.pre)
    6810          54 :             out_pre_spaces = Num.pre - numstr_pre_len;
    6811             :         /* overflowed prefix digit format? */
    6812          34 :         else if (numstr_pre_len > Num.pre)
    6813             :         {
    6814          24 :             numstr = (char *) palloc(Num.pre + Num.post + 2);
    6815          24 :             fill_str(numstr, '#', Num.pre + Num.post + 1);
    6816          24 :             *(numstr + Num.pre) = '.';
    6817             :         }
    6818             :     }
    6819             : 
    6820         130 :     NUM_TOCHAR_finish;
    6821         130 :     PG_RETURN_TEXT_P(result);
    6822             : }
    6823             : 
    6824             : /* -----------------
    6825             :  * FLOAT8 to_char()
    6826             :  * -----------------
    6827             :  */
    6828             : Datum
    6829         146 : float8_to_char(PG_FUNCTION_ARGS)
    6830             : {
    6831         146 :     float8      value = PG_GETARG_FLOAT8(0);
    6832         146 :     text       *fmt = PG_GETARG_TEXT_PP(1);
    6833             :     NUMDesc     Num;
    6834             :     FormatNode *format;
    6835             :     text       *result;
    6836             :     bool        shouldFree;
    6837         146 :     int         out_pre_spaces = 0,
    6838         146 :                 sign = 0;
    6839             :     char       *numstr,
    6840             :                *p;
    6841             : 
    6842         146 :     NUM_TOCHAR_prepare;
    6843             : 
    6844         146 :     if (IS_ROMAN(&Num))
    6845           0 :         numstr = int_to_roman((int) rint(value));
    6846         146 :     else if (IS_EEEE(&Num))
    6847             :     {
    6848          42 :         if (isnan(value) || isinf(value))
    6849             :         {
    6850             :             /*
    6851             :              * Allow 6 characters for the leading sign, the decimal point,
    6852             :              * "e", the exponent's sign and two exponent digits.
    6853             :              */
    6854          18 :             numstr = (char *) palloc(Num.pre + Num.post + 7);
    6855          18 :             fill_str(numstr, '#', Num.pre + Num.post + 6);
    6856          18 :             *numstr = ' ';
    6857          18 :             *(numstr + Num.pre + 1) = '.';
    6858             :         }
    6859             :         else
    6860             :         {
    6861          24 :             numstr = psprintf("%+.*e", Num.post, value);
    6862             : 
    6863             :             /*
    6864             :              * Swap a leading positive sign for a space.
    6865             :              */
    6866          24 :             if (*numstr == '+')
    6867          18 :                 *numstr = ' ';
    6868             :         }
    6869             :     }
    6870             :     else
    6871             :     {
    6872         104 :         float8      val = value;
    6873             :         char       *orgnum;
    6874             :         int         numstr_pre_len;
    6875             : 
    6876         104 :         if (IS_MULTI(&Num))
    6877             :         {
    6878           0 :             double      multi = pow((double) 10, (double) Num.multi);
    6879             : 
    6880           0 :             val = value * multi;
    6881           0 :             Num.pre += Num.multi;
    6882             :         }
    6883             : 
    6884         104 :         orgnum = psprintf("%.0f", fabs(val));
    6885         104 :         numstr_pre_len = strlen(orgnum);
    6886             : 
    6887             :         /* adjust post digits to fit max double digits */
    6888         104 :         if (numstr_pre_len >= DBL_DIG)
    6889           6 :             Num.post = 0;
    6890          98 :         else if (numstr_pre_len + Num.post > DBL_DIG)
    6891           6 :             Num.post = DBL_DIG - numstr_pre_len;
    6892         104 :         orgnum = psprintf("%.*f", Num.post, val);
    6893             : 
    6894         104 :         if (*orgnum == '-')
    6895             :         {                       /* < 0 */
    6896          24 :             sign = '-';
    6897          24 :             numstr = orgnum + 1;
    6898             :         }
    6899             :         else
    6900             :         {
    6901          80 :             sign = '+';
    6902          80 :             numstr = orgnum;
    6903             :         }
    6904             : 
    6905         104 :         if ((p = strchr(numstr, '.')))
    6906          62 :             numstr_pre_len = p - numstr;
    6907             :         else
    6908          42 :             numstr_pre_len = strlen(numstr);
    6909             : 
    6910             :         /* needs padding? */
    6911         104 :         if (numstr_pre_len < Num.pre)
    6912          60 :             out_pre_spaces = Num.pre - numstr_pre_len;
    6913             :         /* overflowed prefix digit format? */
    6914          44 :         else if (numstr_pre_len > Num.pre)
    6915             :         {
    6916          30 :             numstr = (char *) palloc(Num.pre + Num.post + 2);
    6917          30 :             fill_str(numstr, '#', Num.pre + Num.post + 1);
    6918          30 :             *(numstr + Num.pre) = '.';
    6919             :         }
    6920             :     }
    6921             : 
    6922         146 :     NUM_TOCHAR_finish;
    6923         146 :     PG_RETURN_TEXT_P(result);
    6924             : }

Generated by: LCOV version 1.14