dt_common.c File Reference

#include "postgres_fe.h"
#include <time.h>
#include <ctype.h>
#include <math.h>
#include "common/string.h"
#include "dt.h"
#include "pgtypes_timestamp.h"
#include "pgtypeslib_extern.h"

Include dependency graph for dt_common.c:

Go to the source code of this file.

Typedefs

typedef long AbsoluteTime

Functions

static const datetkn * datebsearch (const char *key, const datetkn *base, unsigned int nel)

int DecodeUnits (int field, char *lowtoken, int *val)

int date2j (int y, int m, int d)

void j2date (int jd, int *year, int *month, int *day)

static int DecodeSpecial (int field, char *lowtoken, int *val)

void EncodeDateOnly (struct tm *tm, int style, char *str, bool EuroDates)

void TrimTrailingZeros (char *str)

void EncodeDateTime (struct tm *tm, fsec_t fsec, bool print_tz, int tz, const char *tzn, int style, char *str, bool EuroDates)

int GetEpochTime (struct tm *tm)

static void abstime2tm (AbsoluteTime _time, int *tzp, struct tm *tm, char **tzn)

void GetCurrentDateTime (struct tm *tm)

void dt2time (double jd, int *hour, int *min, int *sec, fsec_t *fsec)

static int DecodeNumberField (int len, char *str, int fmask, int *tmask, struct tm *tm, fsec_t *fsec, bool *is2digits)

static int DecodeNumber (int flen, char *str, int fmask, int *tmask, struct tm *tm, fsec_t *fsec, bool *is2digits, bool EuroDates)

static int DecodeDate (char *str, int fmask, int *tmask, struct tm *tm, bool EuroDates)

int DecodeTime (char *str, int *tmask, struct tm *tm, fsec_t *fsec)

static int DecodeTimezone (char *str, int *tzp)

static int DecodePosixTimezone (char *str, int *tzp)

int ParseDateTime (char *timestr, char *lowstr, char **field, int *ftype, int *numfields, char **endstr)

int DecodeDateTime (char **field, int *ftype, int nf, int *dtype, struct tm *tm, fsec_t *fsec, bool EuroDates)

static char * find_end_token (char *str, char *fmt)

static int pgtypes_defmt_scan (union un_fmt_comb *scan_val, int scan_type, char **pstr, char *pfmt)

int PGTYPEStimestamp_defmt_scan (char **str, char *fmt, timestamp *d, int *year, int *month, int *day, int *hour, int *minute, int *second, int *tz)

Variables

const int day_tab [2][13]

static const datetkn datetktbl []

static const datetkn deltatktbl []

static const unsigned int szdatetktbl = lengthof(datetktbl)

static const unsigned int szdeltatktbl = lengthof(deltatktbl)

static const datetkn * datecache [MAXDATEFIELDS] = {NULL}

static const datetkn * deltacache [MAXDATEFIELDS] = {NULL}

char * months [] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", NULL}

char * days [] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", NULL}

char * pgtypes_date_weekdays_short [] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", NULL}

char * pgtypes_date_months [] = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December", NULL}

Typedef Documentation

◆ AbsoluteTime

typedef long AbsoluteTime

Definition at line 18 of file dt_common.c.

Function Documentation

◆ abstime2tm()

static void abstime2tm ( AbsoluteTime _time,

int * tzp,

struct tm * tm,

char ** tzn

)

static

Definition at line 973 of file dt_common.c.

974{

975 time_t time = (time_t) _time;

976 struct tm *tx;

977 struct tm tmbuf;

978

979 errno = 0;

980 if (tzp != NULL)

981 tx = localtime_r(&time, &tmbuf);

982 else

983 tx = gmtime_r(&time, &tmbuf);

984

985 if (!tx)

986 {

987 errno = PGTYPES_TS_BAD_TIMESTAMP;

988 return;

989 }

990

991 tm->tm_year = tx->tm_year + 1900;

992 tm->tm_mon = tx->tm_mon + 1;

993 tm->tm_mday = tx->tm_mday;

994 tm->tm_hour = tx->tm_hour;

995 tm->tm_min = tx->tm_min;

996 tm->tm_sec = tx->tm_sec;

997 tm->tm_isdst = tx->tm_isdst;

998

999#if defined(HAVE_STRUCT_TM_TM_ZONE)

1000 tm->tm_gmtoff = tx->tm_gmtoff;

1001 tm->tm_zone = tx->tm_zone;

1002

1003 if (tzp != NULL)

1004 {

1005 /*

1006 * We have a brute force time zone per SQL99? Then use it without

1007 * change since we have already rotated to the time zone.

1008 */

1009 *tzp = -tm->tm_gmtoff; /* tm_gmtoff is Sun/DEC-ism */

1010

1011 /*

1012 * FreeBSD man pages indicate that this should work - tgl 97/04/23

1013 */

1014 if (tzn != NULL)

1015 {

1016 /*

1017 * Copy no more than MAXTZLEN bytes of timezone to tzn, in case it

1018 * contains an error message, which doesn't fit in the buffer

1019 */

1020 strlcpy(*tzn, tm->tm_zone, MAXTZLEN + 1);

1021 if (strlen(tm->tm_zone) > MAXTZLEN)

1022 tm->tm_isdst = -1;

1023 }

1024 }

1025 else

1026 tm->tm_isdst = -1;

1027#elif defined(HAVE_INT_TIMEZONE)

1028 if (tzp != NULL)

1029 {

1030 *tzp = (tm->tm_isdst > 0) ? TIMEZONE_GLOBAL - SECS_PER_HOUR : TIMEZONE_GLOBAL;

1031

1032 if (tzn != NULL)

1033 {

1034 /*

1035 * Copy no more than MAXTZLEN bytes of timezone to tzn, in case it

1036 * contains an error message, which doesn't fit in the buffer

1037 */

1038 strlcpy(*tzn, TZNAME_GLOBAL[tm->tm_isdst], MAXTZLEN + 1);

1039 if (strlen(TZNAME_GLOBAL[tm->tm_isdst]) > MAXTZLEN)

1040 tm->tm_isdst = -1;

1041 }

1042 }

1043 else

1044 tm->tm_isdst = -1;

1045#else /* not (HAVE_STRUCT_TM_TM_ZONE ||

1046 * HAVE_INT_TIMEZONE) */

1047 if (tzp != NULL)

1048 {

1049 /* default to UTC */

1050 *tzp = 0;

1051 if (tzn != NULL)

1052 *tzn = NULL;

1053 }

1054 else

1055 tm->tm_isdst = -1;

1056#endif

1057}

SECS_PER_HOUR

#define SECS_PER_HOUR

Definition: timestamp.h:127

tm

static struct pg_tm tm

Definition: localtime.c:104

MAXTZLEN

#define MAXTZLEN

Definition: miscadmin.h:263

PGTYPES_TS_BAD_TIMESTAMP

#define PGTYPES_TS_BAD_TIMESTAMP

Definition: pgtypes_error.h:15

TIMEZONE_GLOBAL

#define TIMEZONE_GLOBAL

Definition: port.h:269

TZNAME_GLOBAL

#define TZNAME_GLOBAL

Definition: port.h:270

strlcpy

size_t strlcpy(char *dst, const char *src, size_t siz)

Definition: strlcpy.c:45

pg_tm::tm_hour

int tm_hour

Definition: pgtime.h:38

pg_tm::tm_mday

int tm_mday

Definition: pgtime.h:39

pg_tm::tm_mon

int tm_mon

Definition: pgtime.h:40

pg_tm::tm_min

int tm_min

Definition: pgtime.h:37

pg_tm::tm_zone

const char * tm_zone

Definition: pgtime.h:46

pg_tm::tm_sec

int tm_sec

Definition: pgtime.h:36

pg_tm::tm_isdst

int tm_isdst

Definition: pgtime.h:44

pg_tm::tm_gmtoff

long int tm_gmtoff

Definition: pgtime.h:45

pg_tm::tm_year

int tm_year

Definition: pgtime.h:41

References MAXTZLEN, PGTYPES_TS_BAD_TIMESTAMP, SECS_PER_HOUR, strlcpy(), TIMEZONE_GLOBAL, tm, pg_tm::tm_gmtoff, pg_tm::tm_hour, pg_tm::tm_isdst, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, pg_tm::tm_zone, and TZNAME_GLOBAL.

Referenced by GetCurrentDateTime().

◆ date2j()

int date2j ( int y,

int m,

int d

)

Definition at line 581 of file dt_common.c.

582{

583 int julian;

584 int century;

585

586 if (m > 2)

587 {

588 m += 1;

589 y += 4800;

590 }

591 else

592 {

593 m += 13;

594 y += 4799;

595 }

596

597 century = y / 100;

598 julian = y * 365 - 32167;

599 julian += y / 4 - century + century / 4;

600 julian += 7834 * m / 256 + d;

601

602 return julian;

603} /* date2j() */

y

int y

Definition: isn.c:76

References y.

Referenced by DecodeDateTime(), DecodeNumber(), and EncodeDateTime().

◆ datebsearch()

static const datetkn * datebsearch ( const char * key,

const datetkn * base,

unsigned int nel

)

static

Definition at line 502 of file dt_common.c.

503{

504 if (nel > 0)

505 {

506 const datetkn *last = base + nel - 1,

507 *position;

508 int result;

509

510 while (last >= base)

511 {

512 position = base + ((last - base) >> 1);

513 /* precheck the first character for a bit of extra speed */

514 result = (int) key[0] - (int) position->token[0];

515 if (result == 0)

516 {

517 /* use strncmp so that we match truncated tokens */

518 result = strncmp(key, position->token, TOKMAXLEN);

519 if (result == 0)

520 return position;

521 }

522 if (result < 0)

523 last = position - 1;

524 else

525 base = position + 1;

526 }

527 }

528 return NULL;

529}

TOKMAXLEN

#define TOKMAXLEN

Definition: datetime.h:204

sort-test.key

key

Definition: sort-test.py:19

datetkn

Definition: datetime.h:208

References sort-test::key, and TOKMAXLEN.

Referenced by DecodeSpecial(), and DecodeUnits().

◆ DecodeDate()

static int DecodeDate ( char * str,

int fmask,

int * tmask,

struct tm * tm,

bool EuroDates

)

static

Definition at line 1308 of file dt_common.c.

1309{

1310 fsec_t fsec;

1311

1312 int nf = 0;

1313 int i,

1314 len;

1315 bool bc = false;

1316 bool is2digits = false;

1317 int type,

1318 val,

1319 dmask = 0;

1320 char *field[MAXDATEFIELDS];

1321

1322 /* parse this string... */

1323 while (*str != '0円' && nf < MAXDATEFIELDS)

1324 {

1325 /* skip field separators */

1326 while (!isalnum((unsigned char) *str))

1327 str++;

1328

1329 field[nf] = str;

1330 if (isdigit((unsigned char) *str))

1331 {

1332 while (isdigit((unsigned char) *str))

1333 str++;

1334 }

1335 else if (isalpha((unsigned char) *str))

1336 {

1337 while (isalpha((unsigned char) *str))

1338 str++;

1339 }

1340

1341 /* Just get rid of any non-digit, non-alpha characters... */

1342 if (*str != '0円')

1343 *str++ = '0円';

1344 nf++;

1345 }

1346

1347#if 0

1348 /* don't allow too many fields */

1349 if (nf > 3)

1350 return -1;

1351#endif

1352

1353 *tmask = 0;

1354

1355 /* look first for text fields, since that will be unambiguous month */

1356 for (i = 0; i < nf; i++)

1357 {

1358 if (isalpha((unsigned char) *field[i]))

1359 {

1360 type = DecodeSpecial(i, field[i], &val);

1361 if (type == IGNORE_DTF)

1362 continue;

1363

1364 dmask = DTK_M(type);

1365 switch (type)

1366 {

1367 case MONTH:

1368 tm->tm_mon = val;

1369 break;

1370

1371 case ADBC:

1372 bc = (val == BC);

1373 break;

1374

1375 default:

1376 return -1;

1377 }

1378 if (fmask & dmask)

1379 return -1;

1380

1381 fmask |= dmask;

1382 *tmask |= dmask;

1383

1384 /* mark this field as being completed */

1385 field[i] = NULL;

1386 }

1387 }

1388

1389 /* now pick up remaining numeric fields */

1390 for (i = 0; i < nf; i++)

1391 {

1392 if (field[i] == NULL)

1393 continue;

1394

1395 if ((len = strlen(field[i])) <= 0)

1396 return -1;

1397

1398 if (DecodeNumber(len, field[i], fmask, &dmask, tm, &fsec, &is2digits, EuroDates) != 0)

1399 return -1;

1400

1401 if (fmask & dmask)

1402 return -1;

1403

1404 fmask |= dmask;

1405 *tmask |= dmask;

1406 }

1407

1408 if ((fmask & ~(DTK_M(DOY) | DTK_M(TZ))) != DTK_DATE_M)

1409 return -1;

1410

1411 /* there is no year zero in AD/BC notation; i.e. "1 BC" == year 0 */

1412 if (bc)

1413 {

1414 if (tm->tm_year > 0)

1415 tm->tm_year = -(tm->tm_year - 1);

1416 else

1417 return -1;

1418 }

1419 else if (is2digits)

1420 {

1421 if (tm->tm_year < 70)

1422 tm->tm_year += 2000;

1423 else if (tm->tm_year < 100)

1424 tm->tm_year += 1900;

1425 }

1426

1427 return 0;

1428} /* DecodeDate() */

fsec_t

int32 fsec_t

Definition: timestamp.h:41

DecodeNumber

static int DecodeNumber(int flen, char *str, int fmask, int *tmask, struct tm *tm, fsec_t *fsec, bool *is2digits, bool EuroDates)

Definition: dt_common.c:1199

DecodeSpecial

static int DecodeSpecial(int field, char *lowtoken, int *val)

Definition: dt_common.c:635

str

const char * str

Definition: hashfn_unstable.h:254

MAXDATEFIELDS

#define MAXDATEFIELDS

Definition: datetime.h:202

MONTH

#define MONTH

Definition: datetime.h:91

IGNORE_DTF

#define IGNORE_DTF

Definition: datetime.h:98

DTK_M

#define DTK_M(t)

Definition: datetime.h:187

ADBC

#define ADBC

Definition: datetime.h:108

TZ

#define TZ

Definition: datetime.h:95

BC

#define BC

Definition: datetime.h:76

DTK_DATE_M

#define DTK_DATE_M

Definition: datetime.h:191

DOY

#define DOY

Definition: datetime.h:105

val

long val

Definition: informix.c:689

i

int i

Definition: isn.c:77

len

const void size_t len

Definition: pg_crc32c_sse42.c:28

type

const char * type

Definition: wait_event_funcs.c:27

References ADBC, BC, DecodeNumber(), DecodeSpecial(), DOY, DTK_DATE_M, DTK_M, i, IGNORE_DTF, len, MAXDATEFIELDS, MONTH, str, tm, pg_tm::tm_mon, pg_tm::tm_year, type, TZ, and val.

Referenced by DecodeDateTime().

◆ DecodeDateTime()

int DecodeDateTime ( char ** field,

int * ftype,

int nf,

int * dtype,

struct tm * tm,

fsec_t * fsec,

bool EuroDates

)

Definition at line 1782 of file dt_common.c.

1784{

1785 int fmask = 0,

1786 tmask,

1787 type;

1788 int ptype = 0; /* "prefix type" for ISO y2001m02d04 format */

1789 int i;

1790 int val;

1791 int mer = HR24;

1792 bool haveTextMonth = false;

1793 bool is2digits = false;

1794 bool bc = false;

1795 int t = 0;

1796 int *tzp = &t;

1797

1798 /***

1799 * We'll insist on at least all of the date fields, but initialize the

1800 * remaining fields in case they are not set later...

1801 ***/

1802 *dtype = DTK_DATE;

1803 tm->tm_hour = 0;

1804 tm->tm_min = 0;

1805 tm->tm_sec = 0;

1806 *fsec = 0;

1807 /* don't know daylight savings time status apriori */

1808 tm->tm_isdst = -1;

1809 if (tzp != NULL)

1810 *tzp = 0;

1811

1812 for (i = 0; i < nf; i++)

1813 {

1814 switch (ftype[i])

1815 {

1816 case DTK_DATE:

1817 /***

1818 * Integral julian day with attached time zone?

1819 * All other forms with JD will be separated into

1820 * distinct fields, so we handle just this case here.

1821 ***/

1822 if (ptype == DTK_JULIAN)

1823 {

1824 char *cp;

1825 int jday;

1826

1827 if (tzp == NULL)

1828 return -1;

1829

1830 jday = strtoint(field[i], &cp, 10);

1831 if (*cp != '-')

1832 return -1;

1833

1834 j2date(jday, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);

1835 /* Get the time zone from the end of the string */

1836 if (DecodeTimezone(cp, tzp) != 0)

1837 return -1;

1838

1839 tmask = DTK_DATE_M | DTK_TIME_M | DTK_M(TZ);

1840 ptype = 0;

1841 break;

1842 }

1843 /***

1844 * Already have a date? Then this might be a POSIX time

1845 * zone with an embedded dash (e.g. "PST-3" == "EST") or

1846 * a run-together time with trailing time zone (e.g. hhmmss-zz).

1847 * - thomas 2001年12月25日

1848 ***/

1849 else if (((fmask & DTK_DATE_M) == DTK_DATE_M)

1850 || (ptype != 0))

1851 {

1852 /* No time zone accepted? Then quit... */

1853 if (tzp == NULL)

1854 return -1;

1855

1856 if (isdigit((unsigned char) *field[i]) || ptype != 0)

1857 {

1858 char *cp;

1859

1860 if (ptype != 0)

1861 {

1862 /* Sanity check; should not fail this test */

1863 if (ptype != DTK_TIME)

1864 return -1;

1865 ptype = 0;

1866 }

1867

1868 /*

1869 * Starts with a digit but we already have a time

1870 * field? Then we are in trouble with a date and time

1871 * already...

1872 */

1873 if ((fmask & DTK_TIME_M) == DTK_TIME_M)

1874 return -1;

1875

1876 if ((cp = strchr(field[i], '-')) == NULL)

1877 return -1;

1878

1879 /* Get the time zone from the end of the string */

1880 if (DecodeTimezone(cp, tzp) != 0)

1881 return -1;

1882 *cp = '0円';

1883

1884 /*

1885 * Then read the rest of the field as a concatenated

1886 * time

1887 */

1888 if ((ftype[i] = DecodeNumberField(strlen(field[i]), field[i], fmask,

1889 &tmask, tm, fsec, &is2digits)) < 0)

1890 return -1;

1891

1892 /*

1893 * modify tmask after returning from

1894 * DecodeNumberField()

1895 */

1896 tmask |= DTK_M(TZ);

1897 }

1898 else

1899 {

1900 if (DecodePosixTimezone(field[i], tzp) != 0)

1901 return -1;

1902

1903 ftype[i] = DTK_TZ;

1904 tmask = DTK_M(TZ);

1905 }

1906 }

1907 else if (DecodeDate(field[i], fmask, &tmask, tm, EuroDates) != 0)

1908 return -1;

1909 break;

1910

1911 case DTK_TIME:

1912 if (DecodeTime(field[i], &tmask, tm, fsec) != 0)

1913 return -1;

1914

1915 /*

1916 * Check upper limit on hours; other limits checked in

1917 * DecodeTime()

1918 */

1919 /* test for > 24:00:00 */

1920 if (tm->tm_hour > 24 ||

1921 (tm->tm_hour == 24 && (tm->tm_min > 0 || tm->tm_sec > 0)))

1922 return -1;

1923 break;

1924

1925 case DTK_TZ:

1926 {

1927 int tz;

1928

1929 if (tzp == NULL)

1930 return -1;

1931

1932 if (DecodeTimezone(field[i], &tz) != 0)

1933 return -1;

1934

1935 /*

1936 * Already have a time zone? Then maybe this is the second

1937 * field of a POSIX time: EST+3 (equivalent to PST)

1938 */

1939 if (i > 0 && (fmask & DTK_M(TZ)) != 0 &&

1940 ftype[i - 1] == DTK_TZ &&

1941 isalpha((unsigned char) *field[i - 1]))

1942 {

1943 *tzp -= tz;

1944 tmask = 0;

1945 }

1946 else

1947 {

1948 *tzp = tz;

1949 tmask = DTK_M(TZ);

1950 }

1951 }

1952 break;

1953

1954 case DTK_NUMBER:

1955

1956 /*

1957 * Was this an "ISO date" with embedded field labels? An

1958 * example is "y2001m02d04" - thomas 2001年02月04日

1959 */

1960 if (ptype != 0)

1961 {

1962 char *cp;

1963 int value;

1964

1965 value = strtoint(field[i], &cp, 10);

1966

1967 /*

1968 * only a few kinds are allowed to have an embedded

1969 * decimal

1970 */

1971 if (*cp == '.')

1972 switch (ptype)

1973 {

1974 case DTK_JULIAN:

1975 case DTK_TIME:

1976 case DTK_SECOND:

1977 break;

1978 default:

1979 return 1;

1980 break;

1981 }

1982 else if (*cp != '0円')

1983 return -1;

1984

1985 switch (ptype)

1986 {

1987 case DTK_YEAR:

1988 tm->tm_year = value;

1989 tmask = DTK_M(YEAR);

1990 break;

1991

1992 case DTK_MONTH:

1993

1994 /*

1995 * already have a month and hour? then assume

1996 * minutes

1997 */

1998 if ((fmask & DTK_M(MONTH)) != 0 &&

1999 (fmask & DTK_M(HOUR)) != 0)

2000 {

2001 tm->tm_min = value;

2002 tmask = DTK_M(MINUTE);

2003 }

2004 else

2005 {

2006 tm->tm_mon = value;

2007 tmask = DTK_M(MONTH);

2008 }

2009 break;

2010

2011 case DTK_DAY:

2012 tm->tm_mday = value;

2013 tmask = DTK_M(DAY);

2014 break;

2015

2016 case DTK_HOUR:

2017 tm->tm_hour = value;

2018 tmask = DTK_M(HOUR);

2019 break;

2020

2021 case DTK_MINUTE:

2022 tm->tm_min = value;

2023 tmask = DTK_M(MINUTE);

2024 break;

2025

2026 case DTK_SECOND:

2027 tm->tm_sec = value;

2028 tmask = DTK_M(SECOND);

2029 if (*cp == '.')

2030 {

2031 double frac;

2032

2033 frac = strtod(cp, &cp);

2034 if (*cp != '0円')

2035 return -1;

2036 *fsec = frac * 1000000;

2037 }

2038 break;

2039

2040 case DTK_TZ:

2041 tmask = DTK_M(TZ);

2042 if (DecodeTimezone(field[i], tzp) != 0)

2043 return -1;

2044 break;

2045

2046 case DTK_JULIAN:

2047 /***

2048 * previous field was a label for "julian date"?

2049 ***/

2050 tmask = DTK_DATE_M;

2051 j2date(value, &tm->tm_year, &tm->tm_mon, &tm->tm_mday);

2052 /* fractional Julian Day? */

2053 if (*cp == '.')

2054 {

2055 double time;

2056

2057 time = strtod(cp, &cp);

2058 if (*cp != '0円')

2059 return -1;

2060

2061 tmask |= DTK_TIME_M;

2062 dt2time((time * USECS_PER_DAY), &tm->tm_hour, &tm->tm_min, &tm->tm_sec, fsec);

2063 }

2064 break;

2065

2066 case DTK_TIME:

2067 /* previous field was "t" for ISO time */

2068 if ((ftype[i] = DecodeNumberField(strlen(field[i]), field[i], (fmask | DTK_DATE_M),

2069 &tmask, tm, fsec, &is2digits)) < 0)

2070 return -1;

2071

2072 if (tmask != DTK_TIME_M)

2073 return -1;

2074 break;

2075

2076 default:

2077 return -1;

2078 break;

2079 }

2080

2081 ptype = 0;

2082 *dtype = DTK_DATE;

2083 }

2084 else

2085 {

2086 char *cp;

2087 int flen;

2088

2089 flen = strlen(field[i]);

2090 cp = strchr(field[i], '.');

2091

2092 /* Embedded decimal and no date yet? */

2093 if (cp != NULL && !(fmask & DTK_DATE_M))

2094 {

2095 if (DecodeDate(field[i], fmask, &tmask, tm, EuroDates) != 0)

2096 return -1;

2097 }

2098 /* embedded decimal and several digits before? */

2099 else if (cp != NULL && flen - strlen(cp) > 2)

2100 {

2101 /*

2102 * Interpret as a concatenated date or time Set the

2103 * type field to allow decoding other fields later.

2104 * Example: 20011223 or 040506

2105 */

2106 if ((ftype[i] = DecodeNumberField(flen, field[i], fmask,

2107 &tmask, tm, fsec, &is2digits)) < 0)

2108 return -1;

2109 }

2110 else if (flen > 4)

2111 {

2112 if ((ftype[i] = DecodeNumberField(flen, field[i], fmask,

2113 &tmask, tm, fsec, &is2digits)) < 0)

2114 return -1;

2115 }

2116 /* otherwise it is a single date/time field... */

2117 else if (DecodeNumber(flen, field[i], fmask,

2118 &tmask, tm, fsec, &is2digits, EuroDates) != 0)

2119 return -1;

2120 }

2121 break;

2122

2123 case DTK_STRING:

2124 case DTK_SPECIAL:

2125 type = DecodeSpecial(i, field[i], &val);

2126 if (type == IGNORE_DTF)

2127 continue;

2128

2129 tmask = DTK_M(type);

2130 switch (type)

2131 {

2132 case RESERV:

2133 switch (val)

2134 {

2135 case DTK_NOW:

2136 tmask = (DTK_DATE_M | DTK_TIME_M | DTK_M(TZ));

2137 *dtype = DTK_DATE;

2138 GetCurrentDateTime(tm);

2139 break;

2140

2141 case DTK_YESTERDAY:

2142 tmask = DTK_DATE_M;

2143 *dtype = DTK_DATE;

2144 GetCurrentDateTime(tm);

2145 j2date(date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) - 1,

2146 &tm->tm_year, &tm->tm_mon, &tm->tm_mday);

2147 tm->tm_hour = 0;

2148 tm->tm_min = 0;

2149 tm->tm_sec = 0;

2150 break;

2151

2152 case DTK_TODAY:

2153 tmask = DTK_DATE_M;

2154 *dtype = DTK_DATE;

2155 GetCurrentDateTime(tm);

2156 tm->tm_hour = 0;

2157 tm->tm_min = 0;

2158 tm->tm_sec = 0;

2159 break;

2160

2161 case DTK_TOMORROW:

2162 tmask = DTK_DATE_M;

2163 *dtype = DTK_DATE;

2164 GetCurrentDateTime(tm);

2165 j2date(date2j(tm->tm_year, tm->tm_mon, tm->tm_mday) + 1,

2166 &tm->tm_year, &tm->tm_mon, &tm->tm_mday);

2167 tm->tm_hour = 0;

2168 tm->tm_min = 0;

2169 tm->tm_sec = 0;

2170 break;

2171

2172 case DTK_ZULU:

2173 tmask = (DTK_TIME_M | DTK_M(TZ));

2174 *dtype = DTK_DATE;

2175 tm->tm_hour = 0;

2176 tm->tm_min = 0;

2177 tm->tm_sec = 0;

2178 if (tzp != NULL)

2179 *tzp = 0;

2180 break;

2181

2182 default:

2183 *dtype = val;

2184 }

2185

2186 break;

2187

2188 case MONTH:

2189

2190 /*

2191 * already have a (numeric) month? then see if we can

2192 * substitute...

2193 */

2194 if ((fmask & DTK_M(MONTH)) && !haveTextMonth &&

2195 !(fmask & DTK_M(DAY)) && tm->tm_mon >= 1 && tm->tm_mon <= 31)

2196 {

2197 tm->tm_mday = tm->tm_mon;

2198 tmask = DTK_M(DAY);

2199 }

2200 haveTextMonth = true;

2201 tm->tm_mon = val;

2202 break;

2203

2204 case DTZMOD:

2205

2206 /*

2207 * daylight savings time modifier (solves "MET DST"

2208 * syntax)

2209 */

2210 tmask |= DTK_M(DTZ);

2211 tm->tm_isdst = 1;

2212 if (tzp == NULL)

2213 return -1;

2214 *tzp -= val;

2215 break;

2216

2217 case DTZ:

2218

2219 /*

2220 * set mask for TZ here _or_ check for DTZ later when

2221 * getting default timezone

2222 */

2223 tmask |= DTK_M(TZ);

2224 tm->tm_isdst = 1;

2225 if (tzp == NULL)

2226 return -1;

2227 *tzp = -val;

2228 ftype[i] = DTK_TZ;

2229 break;

2230

2231 case TZ:

2232 tm->tm_isdst = 0;

2233 if (tzp == NULL)

2234 return -1;

2235 *tzp = -val;

2236 ftype[i] = DTK_TZ;

2237 break;

2238

2239 case IGNORE_DTF:

2240 break;

2241

2242 case AMPM:

2243 mer = val;

2244 break;

2245

2246 case ADBC:

2247 bc = (val == BC);

2248 break;

2249

2250 case DOW:

2251 tm->tm_wday = val;

2252 break;

2253

2254 case UNITS:

2255 tmask = 0;

2256 ptype = val;

2257 break;

2258

2259 case ISOTIME:

2260

2261 /*

2262 * This is a filler field "t" indicating that the next

2263 * field is time. Try to verify that this is sensible.

2264 */

2265 tmask = 0;

2266

2267 /* No preceding date? Then quit... */

2268 if ((fmask & DTK_DATE_M) != DTK_DATE_M)

2269 return -1;

2270

2271 /***

2272 * We will need one of the following fields:

2273 * DTK_NUMBER should be hhmmss.fff

2274 * DTK_TIME should be hh:mm:ss.fff

2275 * DTK_DATE should be hhmmss-zz

2276 ***/

2277 if (i >= nf - 1 ||

2278 (ftype[i + 1] != DTK_NUMBER &&

2279 ftype[i + 1] != DTK_TIME &&

2280 ftype[i + 1] != DTK_DATE))

2281 return -1;

2282

2283 ptype = val;

2284 break;

2285

2286 default:

2287 return -1;

2288 }

2289 break;

2290

2291 default:

2292 return -1;

2293 }

2294

2295 if (tmask & fmask)

2296 return -1;

2297 fmask |= tmask;

2298 }

2299

2300 /* there is no year zero in AD/BC notation; i.e. "1 BC" == year 0 */

2301 if (bc)

2302 {

2303 if (tm->tm_year > 0)

2304 tm->tm_year = -(tm->tm_year - 1);

2305 else

2306 return -1;

2307 }

2308 else if (is2digits)

2309 {

2310 if (tm->tm_year < 70)

2311 tm->tm_year += 2000;

2312 else if (tm->tm_year < 100)

2313 tm->tm_year += 1900;

2314 }

2315

2316 if (mer != HR24 && tm->tm_hour > 12)

2317 return -1;

2318 if (mer == AM && tm->tm_hour == 12)

2319 tm->tm_hour = 0;

2320 else if (mer == PM && tm->tm_hour != 12)

2321 tm->tm_hour += 12;

2322

2323 /* do additional checking for full date specs... */

2324 if (*dtype == DTK_DATE)

2325 {

2326 if ((fmask & DTK_DATE_M) != DTK_DATE_M)

2327 return ((fmask & DTK_TIME_M) == DTK_TIME_M) ? 1 : -1;

2328

2329 /*

2330 * check for valid day of month and month, now that we know for sure

2331 * the month and year...

2332 */

2333 if (tm->tm_mon < 1 || tm->tm_mday < 1 || tm->tm_mday > day_tab[isleap(tm->tm_year)][tm->tm_mon - 1])

2334 return -1;

2335

2336 /*

2337 * backend tried to find local timezone here but we don't use the

2338 * result afterwards anyway so we only check for this error: daylight

2339 * savings time modifier but no standard timezone?

2340 */

2341 if ((fmask & DTK_DATE_M) == DTK_DATE_M && tzp != NULL && !(fmask & DTK_M(TZ)) && (fmask & DTK_M(DTZMOD)))

2342 return -1;

2343 }

2344

2345 return 0;

2346} /* DecodeDateTime() */

USECS_PER_DAY

#define USECS_PER_DAY

Definition: timestamp.h:131

day_tab

const int day_tab[2][13]

Definition: dt_common.c:14

GetCurrentDateTime

void GetCurrentDateTime(struct tm *tm)

Definition: dt_common.c:1060

DecodeTimezone

static int DecodeTimezone(char *str, int *tzp)

Definition: dt_common.c:1502

DecodePosixTimezone

static int DecodePosixTimezone(char *str, int *tzp)

Definition: dt_common.c:1547

DecodeTime

int DecodeTime(char *str, int *tmask, struct tm *tm, fsec_t *fsec)

Definition: dt_common.c:1437

date2j

int date2j(int y, int m, int d)

Definition: dt_common.c:581

j2date

void j2date(int jd, int *year, int *month, int *day)

Definition: dt_common.c:606

DecodeNumberField

static int DecodeNumberField(int len, char *str, int fmask, int *tmask, struct tm *tm, fsec_t *fsec, bool *is2digits)

Definition: dt_common.c:1089

dt2time

void dt2time(double jd, int *hour, int *min, int *sec, fsec_t *fsec)

Definition: dt_common.c:1068

DecodeDate

static int DecodeDate(char *str, int fmask, int *tmask, struct tm *tm, bool EuroDates)

Definition: dt_common.c:1308

DTK_TOMORROW

#define DTK_TOMORROW

Definition: datetime.h:156

DTK_SPECIAL

#define DTK_SPECIAL

Definition: datetime.h:149

AMPM

#define AMPM

Definition: datetime.h:99

DTK_TIME

#define DTK_TIME

Definition: datetime.h:145

DTK_SECOND

#define DTK_SECOND

Definition: datetime.h:160

PM

#define PM

Definition: datetime.h:72

DTK_NUMBER

#define DTK_NUMBER

Definition: datetime.h:141

DTK_STRING

#define DTK_STRING

Definition: datetime.h:142

DTK_JULIAN

#define DTK_JULIAN

Definition: datetime.h:173

DTK_TIME_M

#define DTK_TIME_M

Definition: datetime.h:192

HOUR

#define HOUR

Definition: datetime.h:100

DAY

#define DAY

Definition: datetime.h:93

YEAR

#define YEAR

Definition: datetime.h:92

DTK_DATE

#define DTK_DATE

Definition: datetime.h:144

DTK_DAY

#define DTK_DAY

Definition: datetime.h:163

RESERV

#define RESERV

Definition: datetime.h:90

HR24

#define HR24

Definition: datetime.h:73

SECOND

#define SECOND

Definition: datetime.h:102

isleap

#define isleap(y)

Definition: datetime.h:271

DTZMOD

#define DTZMOD

Definition: datetime.h:122

DTK_TZ

#define DTK_TZ

Definition: datetime.h:146

DOW

#define DOW

Definition: datetime.h:106

ISOTIME

#define ISOTIME

Definition: datetime.h:115

DTK_HOUR

#define DTK_HOUR

Definition: datetime.h:162

MINUTE

#define MINUTE

Definition: datetime.h:101

DTZ

#define DTZ

Definition: datetime.h:96

DTK_YEAR

#define DTK_YEAR

Definition: datetime.h:167

AM

#define AM

Definition: datetime.h:71

DTK_MONTH

#define DTK_MONTH

Definition: datetime.h:165

DTK_YESTERDAY

#define DTK_YESTERDAY

Definition: datetime.h:154

DTK_ZULU

#define DTK_ZULU

Definition: datetime.h:157

DTK_MINUTE

#define DTK_MINUTE

Definition: datetime.h:161

UNITS

#define UNITS

Definition: datetime.h:107

DTK_TODAY

#define DTK_TODAY

Definition: datetime.h:155

DTK_NOW

#define DTK_NOW

Definition: datetime.h:153

value

static struct @169 value

strtoint

int strtoint(const char *pg_restrict str, char **pg_restrict endptr, int base)

Definition: string.c:50

pg_tm::tm_wday

int tm_wday

Definition: pgtime.h:42

References ADBC, AM, AMPM, BC, date2j(), DAY, day_tab, DecodeDate(), DecodeNumber(), DecodeNumberField(), DecodePosixTimezone(), DecodeSpecial(), DecodeTime(), DecodeTimezone(), DOW, dt2time(), DTK_DATE, DTK_DATE_M, DTK_DAY, DTK_HOUR, DTK_JULIAN, DTK_M, DTK_MINUTE, DTK_MONTH, DTK_NOW, DTK_NUMBER, DTK_SECOND, DTK_SPECIAL, DTK_STRING, DTK_TIME, DTK_TIME_M, DTK_TODAY, DTK_TOMORROW, DTK_TZ, DTK_YEAR, DTK_YESTERDAY, DTK_ZULU, DTZ, DTZMOD, GetCurrentDateTime(), HOUR, HR24, i, IGNORE_DTF, isleap, ISOTIME, j2date(), MINUTE, MONTH, PM, RESERV, SECOND, strtoint(), tm, pg_tm::tm_hour, pg_tm::tm_isdst, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_wday, pg_tm::tm_year, type, TZ, UNITS, USECS_PER_DAY, val, value, and YEAR.

◆ DecodeNumber()

static int DecodeNumber ( int flen,

char * str,

int fmask,

int * tmask,

struct tm * tm,

fsec_t * fsec,

bool * is2digits,

bool EuroDates

)

static

Definition at line 1199 of file dt_common.c.

1201{

1202 int val;

1203 char *cp;

1204

1205 *tmask = 0;

1206

1207 val = strtoint(str, &cp, 10);

1208 if (cp == str)

1209 return -1;

1210

1211 if (*cp == '.')

1212 {

1213 /*

1214 * More than two digits? Then could be a date or a run-together time:

1215 * 2001.360 20011225 040506.789

1216 */

1217 if (cp - str > 2)

1218 return DecodeNumberField(flen, str, (fmask | DTK_DATE_M),

1219 tmask, tm, fsec, is2digits);

1220

1221 *fsec = strtod(cp, &cp);

1222 if (*cp != '0円')

1223 return -1;

1224 }

1225 else if (*cp != '0円')

1226 return -1;

1227

1228 /* Special case day of year? */

1229 if (flen == 3 && (fmask & DTK_M(YEAR)) && val >= 1 && val <= 366)

1230 {

1231 *tmask = (DTK_M(DOY) | DTK_M(MONTH) | DTK_M(DAY));

1232 tm->tm_yday = val;

1233 j2date(date2j(tm->tm_year, 1, 1) + tm->tm_yday - 1,

1234 &tm->tm_year, &tm->tm_mon, &tm->tm_mday);

1235 }

1236

1237 /***

1238 * Enough digits to be unequivocal year? Used to test for 4 digits or

1239 * more, but we now test first for a three-digit doy so anything

1240 * bigger than two digits had better be an explicit year.

1241 * - thomas 1999年01月09日

1242 * Back to requiring a 4 digit year. We accept a two digit

1243 * year farther down. - thomas 2000年03月28日

1244 ***/

1245 else if (flen >= 4)

1246 {

1247 *tmask = DTK_M(YEAR);

1248

1249 /* already have a year? then see if we can substitute... */

1250 if ((fmask & DTK_M(YEAR)) && !(fmask & DTK_M(DAY)) &&

1251 tm->tm_year >= 1 && tm->tm_year <= 31)

1252 {

1253 tm->tm_mday = tm->tm_year;

1254 *tmask = DTK_M(DAY);

1255 }

1256

1257 tm->tm_year = val;

1258 }

1259

1260 /* already have year? then could be month */

1261 else if ((fmask & DTK_M(YEAR)) && !(fmask & DTK_M(MONTH)) && val >= 1 && val <= MONTHS_PER_YEAR)

1262 {

1263 *tmask = DTK_M(MONTH);

1264 tm->tm_mon = val;

1265 }

1266 /* no year and EuroDates enabled? then could be day */

1267 else if ((EuroDates || (fmask & DTK_M(MONTH))) &&

1268 !(fmask & DTK_M(YEAR)) && !(fmask & DTK_M(DAY)) &&

1269 val >= 1 && val <= 31)

1270 {

1271 *tmask = DTK_M(DAY);

1272 tm->tm_mday = val;

1273 }

1274 else if (!(fmask & DTK_M(MONTH)) && val >= 1 && val <= MONTHS_PER_YEAR)

1275 {

1276 *tmask = DTK_M(MONTH);

1277 tm->tm_mon = val;

1278 }

1279 else if (!(fmask & DTK_M(DAY)) && val >= 1 && val <= 31)

1280 {

1281 *tmask = DTK_M(DAY);

1282 tm->tm_mday = val;

1283 }

1284

1285 /*

1286 * Check for 2 or 4 or more digits, but currently we reach here only if

1287 * two digits. - thomas 2000年03月28日

1288 */

1289 else if (!(fmask & DTK_M(YEAR)) && (flen >= 4 || flen == 2))

1290 {

1291 *tmask = DTK_M(YEAR);

1292 tm->tm_year = val;

1293

1294 /* adjust ONLY if exactly two digits... */

1295 *is2digits = (flen == 2);

1296 }

1297 else

1298 return -1;

1299

1300 return 0;

1301} /* DecodeNumber() */

MONTHS_PER_YEAR

#define MONTHS_PER_YEAR

Definition: timestamp.h:108

pg_tm::tm_yday

int tm_yday

Definition: pgtime.h:43

References date2j(), DAY, DecodeNumberField(), DOY, DTK_DATE_M, DTK_M, j2date(), MONTH, MONTHS_PER_YEAR, str, strtoint(), tm, pg_tm::tm_mday, pg_tm::tm_mon, pg_tm::tm_yday, pg_tm::tm_year, val, and YEAR.

Referenced by DecodeDate(), and DecodeDateTime().

◆ DecodeNumberField()

static int DecodeNumberField ( int len,

char * str,

int fmask,

int * tmask,

struct tm * tm,

fsec_t * fsec,

bool * is2digits

)

static

Definition at line 1089 of file dt_common.c.

1091{

1092 char *cp;

1093

1094 /*

1095 * Have a decimal point? Then this is a date or something with a seconds

1096 * field...

1097 */

1098 if ((cp = strchr(str, '.')) != NULL)

1099 {

1100 char fstr[7];

1101 int i;

1102

1103 cp++;

1104

1105 /*

1106 * OK, we have at most six digits to care about. Let's construct a

1107 * string with those digits, zero-padded on the right, and then do the

1108 * conversion to an integer.

1109 *

1110 * XXX This truncates the seventh digit, unlike rounding it as the

1111 * backend does.

1112 */

1113 for (i = 0; i < 6; i++)

1114 fstr[i] = *cp != '0円' ? *cp++ : '0';

1115 fstr[i] = '0円';

1116 *fsec = strtoint(fstr, NULL, 10);

1117 *cp = '0円';

1118 len = strlen(str);

1119 }

1120 /* No decimal point and no complete date yet? */

1121 else if ((fmask & DTK_DATE_M) != DTK_DATE_M)

1122 {

1123 /* yyyymmdd? */

1124 if (len == 8)

1125 {

1126 *tmask = DTK_DATE_M;

1127

1128 tm->tm_mday = atoi(str + 6);

1129 *(str + 6) = '0円';

1130 tm->tm_mon = atoi(str + 4);

1131 *(str + 4) = '0円';

1132 tm->tm_year = atoi(str + 0);

1133

1134 return DTK_DATE;

1135 }

1136 /* yymmdd? */

1137 else if (len == 6)

1138 {

1139 *tmask = DTK_DATE_M;

1140 tm->tm_mday = atoi(str + 4);

1141 *(str + 4) = '0円';

1142 tm->tm_mon = atoi(str + 2);

1143 *(str + 2) = '0円';

1144 tm->tm_year = atoi(str + 0);

1145 *is2digits = true;

1146

1147 return DTK_DATE;

1148 }

1149 /* yyddd? */

1150 else if (len == 5)

1151 {

1152 *tmask = DTK_DATE_M;

1153 tm->tm_mday = atoi(str + 2);

1154 *(str + 2) = '0円';

1155 tm->tm_mon = 1;

1156 tm->tm_year = atoi(str + 0);

1157 *is2digits = true;

1158

1159 return DTK_DATE;

1160 }

1161 }

1162

1163 /* not all time fields are specified? */

1164 if ((fmask & DTK_TIME_M) != DTK_TIME_M)

1165 {

1166 /* hhmmss */

1167 if (len == 6)

1168 {

1169 *tmask = DTK_TIME_M;

1170 tm->tm_sec = atoi(str + 4);

1171 *(str + 4) = '0円';

1172 tm->tm_min = atoi(str + 2);

1173 *(str + 2) = '0円';

1174 tm->tm_hour = atoi(str + 0);

1175

1176 return DTK_TIME;

1177 }

1178 /* hhmm? */

1179 else if (len == 4)

1180 {

1181 *tmask = DTK_TIME_M;

1182 tm->tm_sec = 0;

1183 tm->tm_min = atoi(str + 2);

1184 *(str + 2) = '0円';

1185 tm->tm_hour = atoi(str + 0);

1186

1187 return DTK_TIME;

1188 }

1189 }

1190

1191 return -1;

1192} /* DecodeNumberField() */

References DTK_DATE, DTK_DATE_M, DTK_TIME, DTK_TIME_M, i, len, str, strtoint(), tm, pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, and pg_tm::tm_year.

Referenced by DecodeDateTime(), and DecodeNumber().

◆ DecodePosixTimezone()

static int DecodePosixTimezone ( char * str,

int * tzp

)

static

Definition at line 1547 of file dt_common.c.

1548{

1549 int val,

1550 tz;

1551 int type;

1552 char *cp;

1553 char delim;

1554

1555 cp = str;

1556 while (*cp != '0円' && isalpha((unsigned char) *cp))

1557 cp++;

1558

1559 if (DecodeTimezone(cp, &tz) != 0)

1560 return -1;

1561

1562 delim = *cp;

1563 *cp = '0円';

1564 type = DecodeSpecial(MAXDATEFIELDS - 1, str, &val);

1565 *cp = delim;

1566

1567 switch (type)

1568 {

1569 case DTZ:

1570 case TZ:

1571 *tzp = -(val + tz);

1572 break;

1573

1574 default:

1575 return -1;

1576 }

1577

1578 return 0;

1579} /* DecodePosixTimezone() */

References DecodeSpecial(), DecodeTimezone(), DTZ, MAXDATEFIELDS, str, type, TZ, and val.

Referenced by DecodeDateTime().

◆ DecodeSpecial()

static int DecodeSpecial ( int field,

char * lowtoken,

int * val

)

static

Definition at line 635 of file dt_common.c.

636{

637 int type;

638 const datetkn *tp;

639

640 /* use strncmp so that we match truncated tokens */

641 if (datecache[field] != NULL &&

642 strncmp(lowtoken, datecache[field]->token, TOKMAXLEN) == 0)

643 tp = datecache[field];

644 else

645 {

646 tp = NULL;

647 if (!tp)

648 tp = datebsearch(lowtoken, datetktbl, szdatetktbl);

649 }

650 datecache[field] = tp;

651 if (tp == NULL)

652 {

653 type = UNKNOWN_FIELD;

654 *val = 0;

655 }

656 else

657 {

658 type = tp->type;

659 *val = tp->value;

660 }

661

662 return type;

663} /* DecodeSpecial() */

datetktbl

static const datetkn datetktbl[]

Definition: dt_common.c:20

szdatetktbl

static const unsigned int szdatetktbl

Definition: dt_common.c:486

datecache

static const datetkn * datecache[MAXDATEFIELDS]

Definition: dt_common.c:489

datebsearch

static const datetkn * datebsearch(const char *key, const datetkn *base, unsigned int nel)

Definition: dt_common.c:502

UNKNOWN_FIELD

#define UNKNOWN_FIELD

Definition: datetime.h:124

datetkn::value

int32 value

Definition: datetime.h:211

datetkn::type

char type

Definition: datetime.h:210

token

Definition: oauth-curl.c:192

References datebsearch(), datecache, datetktbl, szdatetktbl, TOKMAXLEN, type, datetkn::type, UNKNOWN_FIELD, val, and datetkn::value.

Referenced by DecodeDate(), DecodeDateTime(), and DecodePosixTimezone().

◆ DecodeTime()

int DecodeTime ( char * str,

int * tmask,

struct tm * tm,

fsec_t * fsec

)

Definition at line 1437 of file dt_common.c.

1438{

1439 char *cp;

1440

1441 *tmask = DTK_TIME_M;

1442

1443 tm->tm_hour = strtoint(str, &cp, 10);

1444 if (*cp != ':')

1445 return -1;

1446 str = cp + 1;

1447 tm->tm_min = strtoint(str, &cp, 10);

1448 if (*cp == '0円')

1449 {

1450 tm->tm_sec = 0;

1451 *fsec = 0;

1452 }

1453 else if (*cp != ':')

1454 return -1;

1455 else

1456 {

1457 str = cp + 1;

1458 tm->tm_sec = strtoint(str, &cp, 10);

1459 if (*cp == '0円')

1460 *fsec = 0;

1461 else if (*cp == '.')

1462 {

1463 char fstr[7];

1464 int i;

1465

1466 cp++;

1467

1468 /*

1469 * OK, we have at most six digits to care about. Let's construct a

1470 * string with those digits, zero-padded on the right, and then do

1471 * the conversion to an integer.

1472 *

1473 * XXX This truncates the seventh digit, unlike rounding it as the

1474 * backend does.

1475 */

1476 for (i = 0; i < 6; i++)

1477 fstr[i] = *cp != '0円' ? *cp++ : '0';

1478 fstr[i] = '0円';

1479 *fsec = strtoint(fstr, &cp, 10);

1480 if (*cp != '0円')

1481 return -1;

1482 }

1483 else

1484 return -1;

1485 }

1486

1487 /* do a sanity check */

1488 if (tm->tm_hour < 0 || tm->tm_min < 0 || tm->tm_min > 59 ||

1489 tm->tm_sec < 0 || tm->tm_sec > 59 || *fsec >= USECS_PER_SEC)

1490 return -1;

1491

1492 return 0;

1493} /* DecodeTime() */

USECS_PER_SEC

#define USECS_PER_SEC

Definition: timestamp.h:134

References DTK_TIME_M, i, str, strtoint(), tm, pg_tm::tm_hour, pg_tm::tm_min, pg_tm::tm_sec, and USECS_PER_SEC.

Referenced by DecodeDateTime().

◆ DecodeTimezone()

static int DecodeTimezone ( char * str,

int * tzp

)

static

Definition at line 1502 of file dt_common.c.

1503{

1504 int tz;

1505 int hr,

1506 min;

1507 char *cp;

1508 int len;

1509

1510 /* assume leading character is "+" or "-" */

1511 hr = strtoint(str + 1, &cp, 10);

1512

1513 /* explicit delimiter? */

1514 if (*cp == ':')

1515 min = strtoint(cp + 1, &cp, 10);

1516 /* otherwise, might have run things together... */

1517 else if (*cp == '0円' && (len = strlen(str)) > 3)

1518 {

1519 min = strtoint(str + len - 2, &cp, 10);

1520 if (min < 0 || min >= 60)

1521 return -1;

1522

1523 *(str + len - 2) = '0円';

1524 hr = strtoint(str + 1, &cp, 10);

1525 if (hr < 0 || hr > 13)

1526 return -1;

1527 }

1528 else

1529 min = 0;

1530

1531 tz = (hr * MINS_PER_HOUR + min) * SECS_PER_MINUTE;

1532 if (*str == '-')

1533 tz = -tz;

1534

1535 *tzp = -tz;

1536 return *cp != '0円';

1537} /* DecodeTimezone() */

MINS_PER_HOUR

#define MINS_PER_HOUR

Definition: timestamp.h:129

SECS_PER_MINUTE

#define SECS_PER_MINUTE

Definition: timestamp.h:128

References len, MINS_PER_HOUR, SECS_PER_MINUTE, str, and strtoint().

Referenced by DecodeDateTime(), DecodePosixTimezone(), and PGTYPEStimestamp_defmt_scan().

◆ DecodeUnits()

int DecodeUnits ( int field,

char * lowtoken,

int * val

)

Definition at line 536 of file dt_common.c.

537{

538 int type;

539 const datetkn *tp;

540

541 /* use strncmp so that we match truncated tokens */

542 if (deltacache[field] != NULL &&

543 strncmp(lowtoken, deltacache[field]->token, TOKMAXLEN) == 0)

544 tp = deltacache[field];

545 else

546 tp = datebsearch(lowtoken, deltatktbl, szdeltatktbl);

547 deltacache[field] = tp;

548 if (tp == NULL)

549 {

550 type = UNKNOWN_FIELD;

551 *val = 0;

552 }

553 else

554 {

555 type = tp->type;

556 *val = tp->value;

557 }

558

559 return type;

560} /* DecodeUnits() */

deltacache

static const datetkn * deltacache[MAXDATEFIELDS]

Definition: dt_common.c:491

szdeltatktbl

static const unsigned int szdeltatktbl

Definition: dt_common.c:487

deltatktbl

static const datetkn deltatktbl[]

Definition: dt_common.c:421

References datebsearch(), deltacache, deltatktbl, szdeltatktbl, TOKMAXLEN, type, datetkn::type, UNKNOWN_FIELD, val, and datetkn::value.

◆ dt2time()

void dt2time ( double jd,

int * hour,

int * min,

int * sec,

fsec_t * fsec

)

Definition at line 1068 of file dt_common.c.

1069{

1070 int64 time;

1071

1072 time = jd;

1073 *hour = time / USECS_PER_HOUR;

1074 time -= (*hour) * USECS_PER_HOUR;

1075 *min = time / USECS_PER_MINUTE;

1076 time -= (*min) * USECS_PER_MINUTE;

1077 *sec = time / USECS_PER_SEC;

1078 *fsec = time - (*sec * USECS_PER_SEC);

1079} /* dt2time() */

int64

int64_t int64

Definition: c.h:535

USECS_PER_HOUR

#define USECS_PER_HOUR

Definition: timestamp.h:132

USECS_PER_MINUTE

#define USECS_PER_MINUTE

Definition: timestamp.h:133

References USECS_PER_HOUR, USECS_PER_MINUTE, and USECS_PER_SEC.

Referenced by DecodeDateTime().

◆ EncodeDateOnly()

void EncodeDateOnly ( struct tm * tm,

int style,

char * str,

bool EuroDates

)

Definition at line 669 of file dt_common.c.

670{

671 Assert(tm->tm_mon >= 1 && tm->tm_mon <= MONTHS_PER_YEAR);

672

673 switch (style)

674 {

675 case USE_ISO_DATES:

676 /* compatible with ISO date formats */

677 if (tm->tm_year > 0)

678 sprintf(str, "%04d-%02d-%02d",

679 tm->tm_year, tm->tm_mon, tm->tm_mday);

680 else

681 sprintf(str, "%04d-%02d-%02d %s",

682 -(tm->tm_year - 1), tm->tm_mon, tm->tm_mday, "BC");

683 break;

684

685 case USE_SQL_DATES:

686 /* compatible with Oracle/Ingres date formats */

687 if (EuroDates)

688 sprintf(str, "%02d/%02d", tm->tm_mday, tm->tm_mon);

689 else

690 sprintf(str, "%02d/%02d", tm->tm_mon, tm->tm_mday);

691 if (tm->tm_year > 0)

692 sprintf(str + 5, "/%04d", tm->tm_year);

693 else

694 sprintf(str + 5, "/%04d %s", -(tm->tm_year - 1), "BC");

695 break;

696

697 case USE_GERMAN_DATES:

698 /* German-style date format */

699 sprintf(str, "%02d.%02d", tm->tm_mday, tm->tm_mon);

700 if (tm->tm_year > 0)

701 sprintf(str + 5, ".%04d", tm->tm_year);

702 else

703 sprintf(str + 5, ".%04d %s", -(tm->tm_year - 1), "BC");

704 break;

705

706 case USE_POSTGRES_DATES:

707 default:

708 /* traditional date-only style for Postgres */

709 if (EuroDates)

710 sprintf(str, "%02d-%02d", tm->tm_mday, tm->tm_mon);

711 else

712 sprintf(str, "%02d-%02d", tm->tm_mon, tm->tm_mday);

713 if (tm->tm_year > 0)

714 sprintf(str + 5, "-%04d", tm->tm_year);

715 else

716 sprintf(str + 5, "-%04d %s", -(tm->tm_year - 1), "BC");

717 break;

718 }

719}

Assert

Assert(PointerIsAligned(start, uint64))

USE_SQL_DATES

#define USE_SQL_DATES

Definition: miscadmin.h:237

USE_POSTGRES_DATES

#define USE_POSTGRES_DATES

Definition: miscadmin.h:235

USE_ISO_DATES

#define USE_ISO_DATES

Definition: miscadmin.h:236

USE_GERMAN_DATES

#define USE_GERMAN_DATES

Definition: miscadmin.h:238

sprintf

#define sprintf

Definition: port.h:241

References Assert(), MONTHS_PER_YEAR, sprintf, str, tm, pg_tm::tm_mday, pg_tm::tm_mon, pg_tm::tm_year, USE_GERMAN_DATES, USE_ISO_DATES, USE_POSTGRES_DATES, and USE_SQL_DATES.

◆ EncodeDateTime()

void EncodeDateTime ( struct tm * tm,

fsec_t fsec,

bool print_tz,

int tz,

const char * tzn,

int style,

char * str,

bool EuroDates

)

Definition at line 753 of file dt_common.c.

754{

755 int day,

756 hour,

757 min;

758

759 /*

760 * Negative tm_isdst means we have no valid time zone translation.

761 */

762 if (tm->tm_isdst < 0)

763 print_tz = false;

764

765 switch (style)

766 {

767 case USE_ISO_DATES:

768 /* Compatible with ISO-8601 date formats */

769

770 sprintf(str, "%04d-%02d-%02d %02d:%02d",

771 (tm->tm_year > 0) ? tm->tm_year : -(tm->tm_year - 1),

772 tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min);

773

774 /*

775 * Print fractional seconds if any. The field widths here should

776 * be at least equal to MAX_TIMESTAMP_PRECISION.

777 */

778 if (fsec != 0)

779 {

780 sprintf(str + strlen(str), ":%02d.%06d", tm->tm_sec, fsec);

781 TrimTrailingZeros(str);

782 }

783 else

784 sprintf(str + strlen(str), ":%02d", tm->tm_sec);

785

786 if (tm->tm_year <= 0)

787 sprintf(str + strlen(str), " BC");

788

789 if (print_tz)

790 {

791 hour = -(tz / SECS_PER_HOUR);

792 min = (abs(tz) / MINS_PER_HOUR) % MINS_PER_HOUR;

793 if (min != 0)

794 sprintf(str + strlen(str), "%+03d:%02d", hour, min);

795 else

796 sprintf(str + strlen(str), "%+03d", hour);

797 }

798 break;

799

800 case USE_SQL_DATES:

801 /* Compatible with Oracle/Ingres date formats */

802

803 if (EuroDates)

804 sprintf(str, "%02d/%02d", tm->tm_mday, tm->tm_mon);

805 else

806 sprintf(str, "%02d/%02d", tm->tm_mon, tm->tm_mday);

807

808 sprintf(str + 5, "/%04d %02d:%02d",

809 (tm->tm_year > 0) ? tm->tm_year : -(tm->tm_year - 1),

810 tm->tm_hour, tm->tm_min);

811

812 /*

813 * Print fractional seconds if any. The field widths here should

814 * be at least equal to MAX_TIMESTAMP_PRECISION.

815 */

816 if (fsec != 0)

817 {

818 sprintf(str + strlen(str), ":%02d.%06d", tm->tm_sec, fsec);

819 TrimTrailingZeros(str);

820 }

821 else

822 sprintf(str + strlen(str), ":%02d", tm->tm_sec);

823

824 if (tm->tm_year <= 0)

825 sprintf(str + strlen(str), " BC");

826

827 /*

828 * Note: the uses of %.*s in this function would be risky if the

829 * timezone names ever contain non-ASCII characters, since we are

830 * not being careful to do encoding-aware clipping. However, all

831 * TZ abbreviations in the IANA database are plain ASCII.

832 */

833

834 if (print_tz)

835 {

836 if (tzn)

837 sprintf(str + strlen(str), " %.*s", MAXTZLEN, tzn);

838 else

839 {

840 hour = -(tz / SECS_PER_HOUR);

841 min = (abs(tz) / MINS_PER_HOUR) % MINS_PER_HOUR;

842 if (min != 0)

843 sprintf(str + strlen(str), "%+03d:%02d", hour, min);

844 else

845 sprintf(str + strlen(str), "%+03d", hour);

846 }

847 }

848 break;

849

850 case USE_GERMAN_DATES:

851 /* German variant on European style */

852

853 sprintf(str, "%02d.%02d", tm->tm_mday, tm->tm_mon);

854

855 sprintf(str + 5, ".%04d %02d:%02d",

856 (tm->tm_year > 0) ? tm->tm_year : -(tm->tm_year - 1),

857 tm->tm_hour, tm->tm_min);

858

859 /*

860 * Print fractional seconds if any. The field widths here should

861 * be at least equal to MAX_TIMESTAMP_PRECISION.

862 */

863 if (fsec != 0)

864 {

865 sprintf(str + strlen(str), ":%02d.%06d", tm->tm_sec, fsec);

866 TrimTrailingZeros(str);

867 }

868 else

869 sprintf(str + strlen(str), ":%02d", tm->tm_sec);

870

871 if (tm->tm_year <= 0)

872 sprintf(str + strlen(str), " BC");

873

874 if (print_tz)

875 {

876 if (tzn)

877 sprintf(str + strlen(str), " %.*s", MAXTZLEN, tzn);

878 else

879 {

880 hour = -(tz / SECS_PER_HOUR);

881 min = (abs(tz) / MINS_PER_HOUR) % MINS_PER_HOUR;

882 if (min != 0)

883 sprintf(str + strlen(str), "%+03d:%02d", hour, min);

884 else

885 sprintf(str + strlen(str), "%+03d", hour);

886 }

887 }

888 break;

889

890 case USE_POSTGRES_DATES:

891 default:

892 /* Backward-compatible with traditional Postgres abstime dates */

893

894 day = date2j(tm->tm_year, tm->tm_mon, tm->tm_mday);

895 tm->tm_wday = (int) ((day + date2j(2000, 1, 1) + 1) % 7);

896

897 memcpy(str, days[tm->tm_wday], 3);

898 strcpy(str + 3, " ");

899

900 if (EuroDates)

901 sprintf(str + 4, "%02d %3s", tm->tm_mday, months[tm->tm_mon - 1]);

902 else

903 sprintf(str + 4, "%3s %02d", months[tm->tm_mon - 1], tm->tm_mday);

904

905 sprintf(str + 10, " %02d:%02d", tm->tm_hour, tm->tm_min);

906

907 /*

908 * Print fractional seconds if any. The field widths here should

909 * be at least equal to MAX_TIMESTAMP_PRECISION.

910 */

911 if (fsec != 0)

912 {

913 sprintf(str + strlen(str), ":%02d.%06d", tm->tm_sec, fsec);

914 TrimTrailingZeros(str);

915 }

916 else

917 sprintf(str + strlen(str), ":%02d", tm->tm_sec);

918

919 sprintf(str + strlen(str), " %04d",

920 (tm->tm_year > 0) ? tm->tm_year : -(tm->tm_year - 1));

921 if (tm->tm_year <= 0)

922 sprintf(str + strlen(str), " BC");

923

924 if (print_tz)

925 {

926 if (tzn)

927 sprintf(str + strlen(str), " %.*s", MAXTZLEN, tzn);

928 else

929 {

930 /*

931 * We have a time zone, but no string version. Use the

932 * numeric form, but be sure to include a leading space to

933 * avoid formatting something which would be rejected by

934 * the date/time parser later. - thomas 2001年10月19日

935 */

936 hour = -(tz / SECS_PER_HOUR);

937 min = (abs(tz) / MINS_PER_HOUR) % MINS_PER_HOUR;

938 if (min != 0)

939 sprintf(str + strlen(str), " %+03d:%02d", hour, min);

940 else

941 sprintf(str + strlen(str), " %+03d", hour);

942 }

943 }

944 break;

945 }

946}

days

char * days[]

Definition: dt_common.c:495

TrimTrailingZeros

void TrimTrailingZeros(char *str)

Definition: dt_common.c:722

months

char * months[]

Definition: dt_common.c:493

References date2j(), days, MAXTZLEN, MINS_PER_HOUR, months, SECS_PER_HOUR, sprintf, str, tm, pg_tm::tm_hour, pg_tm::tm_isdst, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_wday, pg_tm::tm_year, TrimTrailingZeros(), USE_GERMAN_DATES, USE_ISO_DATES, USE_POSTGRES_DATES, and USE_SQL_DATES.

◆ find_end_token()

static char * find_end_token ( char * str,

char * fmt

)

static

Definition at line 2354 of file dt_common.c.

2355{

2356 /*

2357 * str: here is28the day12the hour fmt: here is%dthe day%hthe hour

2358 *

2359 * we extract the 28, we read the percent sign and the type "d" then this

2360 * functions gets called as find_end_token("28the day12the hour", "the

2361 * day%hthehour")

2362 *

2363 * fmt points to "the day%hthehour", next_percent points to %hthehour and

2364 * we have to find a match for everything between these positions ("the

2365 * day"). We look for "the day" in str and know that the pattern we are

2366 * about to scan ends where this string starts (right after the "28")

2367 *

2368 * At the end, *fmt is '0円' and *str isn't. end_position then is

2369 * unchanged.

2370 */

2371 char *end_position = NULL;

2372 char *next_percent,

2373 *subst_location = NULL;

2374 int scan_offset = 0;

2375 char last_char;

2376

2377 /* are we at the end? */

2378 if (!*fmt)

2379 {

2380 end_position = fmt;

2381 return end_position;

2382 }

2383

2384 /* not at the end */

2385 while (fmt[scan_offset] == '%' && fmt[scan_offset + 1])

2386 {

2387 /*

2388 * there is no delimiter, skip to the next delimiter if we're reading

2389 * a number and then something that is not a number "9:15pm", we might

2390 * be able to recover with the strtol end pointer. Go for the next

2391 * percent sign

2392 */

2393 scan_offset += 2;

2394 }

2395 next_percent = strchr(fmt + scan_offset, '%');

2396 if (next_percent)

2397 {

2398 /*

2399 * we don't want to allocate extra memory, so we temporarily set the

2400 * '%' sign to '0円' and call strstr However since we allow whitespace

2401 * to float around everything, we have to shorten the pattern until we

2402 * reach a non-whitespace character

2403 */

2404

2405 subst_location = next_percent;

2406 while (*(subst_location - 1) == ' ' && subst_location - 1 > fmt + scan_offset)

2407 subst_location--;

2408 last_char = *subst_location;

2409 *subst_location = '0円';

2410

2411 /*

2412 * the haystack is the str and the needle is the original fmt but it

2413 * ends at the position where the next percent sign would be

2414 */

2415

2416 /*

2417 * There is one special case. Imagine: str = " 2", fmt = "%d %...",

2418 * since we want to allow blanks as "dynamic" padding we have to

2419 * accept this. Now, we are called with a fmt of " %..." and look for

2420 * " " in str. We find it at the first position and never read the

2421 * 2...

2422 */

2423 while (*str == ' ')

2424 str++;

2425 end_position = strstr(str, fmt + scan_offset);

2426 *subst_location = last_char;

2427 }

2428 else

2429 {

2430 /*

2431 * there is no other percent sign. So everything up to the end has to

2432 * match.

2433 */

2434 end_position = str + strlen(str);

2435 }

2436 if (!end_position)

2437 {

2438 /*

2439 * maybe we have the following case:

2440 *

2441 * str = "4:15am" fmt = "%M:%S %p"

2442 *

2443 * at this place we could have

2444 *

2445 * str = "15am" fmt = " %p"

2446 *

2447 * and have set fmt to " " because overwrote the % sign with a NULL

2448 *

2449 * In this case where we would have to match a space but can't find

2450 * it, set end_position to the end of the string

2451 */

2452 if ((fmt + scan_offset)[0] == ' ' && fmt + scan_offset + 1 == subst_location)

2453 end_position = str + strlen(str);

2454 }

2455 return end_position;

2456}

References str.

Referenced by pgtypes_defmt_scan().

◆ GetCurrentDateTime()

void GetCurrentDateTime ( struct tm * tm )

Definition at line 1060 of file dt_common.c.

1061{

1062 int tz;

1063

1064 abstime2tm(time(NULL), &tz, tm, NULL);

1065}

abstime2tm

static void abstime2tm(AbsoluteTime _time, int *tzp, struct tm *tm, char **tzn)

Definition: dt_common.c:973

References abstime2tm(), and tm.

Referenced by DecodeDateTime().

◆ GetEpochTime()

int GetEpochTime ( struct tm * tm )

Definition at line 949 of file dt_common.c.

950{

951 struct tm *t0;

952 struct tm tmbuf;

953 time_t epoch = 0;

954

955 t0 = gmtime_r(&epoch, &tmbuf);

956

957 if (t0)

958 {

959 tm->tm_year = t0->tm_year + 1900;

960 tm->tm_mon = t0->tm_mon + 1;

961 tm->tm_mday = t0->tm_mday;

962 tm->tm_hour = t0->tm_hour;

963 tm->tm_min = t0->tm_min;

964 tm->tm_sec = t0->tm_sec;

965

966 return 0;

967 }

968

969 return -1;

970} /* GetEpochTime() */

epoch

static const unsigned __int64 epoch

Definition: win32gettimeofday.c:36

References epoch, tm, pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, and pg_tm::tm_year.

◆ j2date()

void j2date ( int jd,

int * year,

int * month,

int * day

)

Definition at line 606 of file dt_common.c.

607{

608 unsigned int julian;

609 unsigned int quad;

610 unsigned int extra;

611 int y;

612

613 julian = jd;

614 julian += 32044;

615 quad = julian / 146097;

616 extra = (julian - quad * 146097) * 4 + 3;

617 julian += 60 + quad * 3 + extra / 146097;

618 quad = julian / 1461;

619 julian -= quad * 1461;

620 y = julian * 4 / 1461;

621 julian = ((y != 0) ? (julian + 305) % 365 : (julian + 306) % 366) + 123;

622 y += quad * 4;

623 *year = y - 4800;

624 quad = julian * 2141 / 65536;

625 *day = julian - 7834 * quad / 256;

626 *month = (quad + 10) % 12 + 1;

627} /* j2date() */

References y.

Referenced by DecodeDateTime(), and DecodeNumber().

◆ ParseDateTime()

int ParseDateTime ( char * timestr,

char * lowstr,

char ** field,

int * ftype,

int * numfields,

char ** endstr

)

Definition at line 1600 of file dt_common.c.

1602{

1603 int nf = 0;

1604 char *lp = lowstr;

1605

1606 *endstr = timestr;

1607 /* outer loop through fields */

1608 while (*(*endstr) != '0円')

1609 {

1610 /* Record start of current field */

1611 if (nf >= MAXDATEFIELDS)

1612 return -1;

1613 field[nf] = lp;

1614

1615 /* leading digit? then date or time */

1616 if (isdigit((unsigned char) *(*endstr)))

1617 {

1618 *lp++ = *(*endstr)++;

1619 while (isdigit((unsigned char) *(*endstr)))

1620 *lp++ = *(*endstr)++;

1621

1622 /* time field? */

1623 if (*(*endstr) == ':')

1624 {

1625 ftype[nf] = DTK_TIME;

1626 *lp++ = *(*endstr)++;

1627 while (isdigit((unsigned char) *(*endstr)) ||

1628 (*(*endstr) == ':') || (*(*endstr) == '.'))

1629 *lp++ = *(*endstr)++;

1630 }

1631 /* date field? allow embedded text month */

1632 else if (*(*endstr) == '-' || *(*endstr) == '/' || *(*endstr) == '.')

1633 {

1634 /* save delimiting character to use later */

1635 char *dp = (*endstr);

1636

1637 *lp++ = *(*endstr)++;

1638 /* second field is all digits? then no embedded text month */

1639 if (isdigit((unsigned char) *(*endstr)))

1640 {

1641 ftype[nf] = (*dp == '.') ? DTK_NUMBER : DTK_DATE;

1642 while (isdigit((unsigned char) *(*endstr)))

1643 *lp++ = *(*endstr)++;

1644

1645 /*

1646 * insist that the delimiters match to get a three-field

1647 * date.

1648 */

1649 if (*(*endstr) == *dp)

1650 {

1651 ftype[nf] = DTK_DATE;

1652 *lp++ = *(*endstr)++;

1653 while (isdigit((unsigned char) *(*endstr)) || (*(*endstr) == *dp))

1654 *lp++ = *(*endstr)++;

1655 }

1656 }

1657 else

1658 {

1659 ftype[nf] = DTK_DATE;

1660 while (isalnum((unsigned char) *(*endstr)) || (*(*endstr) == *dp))

1661 *lp++ = pg_tolower((unsigned char) *(*endstr)++);

1662 }

1663 }

1664

1665 /*

1666 * otherwise, number only and will determine year, month, day, or

1667 * concatenated fields later...

1668 */

1669 else

1670 ftype[nf] = DTK_NUMBER;

1671 }

1672 /* Leading decimal point? Then fractional seconds... */

1673 else if (*(*endstr) == '.')

1674 {

1675 *lp++ = *(*endstr)++;

1676 while (isdigit((unsigned char) *(*endstr)))

1677 *lp++ = *(*endstr)++;

1678

1679 ftype[nf] = DTK_NUMBER;

1680 }

1681

1682 /*

1683 * text? then date string, month, day of week, special, or timezone

1684 */

1685 else if (isalpha((unsigned char) *(*endstr)))

1686 {

1687 ftype[nf] = DTK_STRING;

1688 *lp++ = pg_tolower((unsigned char) *(*endstr)++);

1689 while (isalpha((unsigned char) *(*endstr)))

1690 *lp++ = pg_tolower((unsigned char) *(*endstr)++);

1691

1692 /*

1693 * Full date string with leading text month? Could also be a POSIX

1694 * time zone...

1695 */

1696 if (*(*endstr) == '-' || *(*endstr) == '/' || *(*endstr) == '.')

1697 {

1698 char *dp = (*endstr);

1699

1700 ftype[nf] = DTK_DATE;

1701 *lp++ = *(*endstr)++;

1702 while (isdigit((unsigned char) *(*endstr)) || *(*endstr) == *dp)

1703 *lp++ = *(*endstr)++;

1704 }

1705 }

1706 /* skip leading spaces */

1707 else if (isspace((unsigned char) *(*endstr)))

1708 {

1709 (*endstr)++;

1710 continue;

1711 }

1712 /* sign? then special or numeric timezone */

1713 else if (*(*endstr) == '+' || *(*endstr) == '-')

1714 {

1715 *lp++ = *(*endstr)++;

1716 /* soak up leading whitespace */

1717 while (isspace((unsigned char) *(*endstr)))

1718 (*endstr)++;

1719 /* numeric timezone? */

1720 if (isdigit((unsigned char) *(*endstr)))

1721 {

1722 ftype[nf] = DTK_TZ;

1723 *lp++ = *(*endstr)++;

1724 while (isdigit((unsigned char) *(*endstr)) ||

1725 (*(*endstr) == ':') || (*(*endstr) == '.'))

1726 *lp++ = *(*endstr)++;

1727 }

1728 /* special? */

1729 else if (isalpha((unsigned char) *(*endstr)))

1730 {

1731 ftype[nf] = DTK_SPECIAL;

1732 *lp++ = pg_tolower((unsigned char) *(*endstr)++);

1733 while (isalpha((unsigned char) *(*endstr)))

1734 *lp++ = pg_tolower((unsigned char) *(*endstr)++);

1735 }

1736 /* otherwise something wrong... */

1737 else

1738 return -1;

1739 }

1740 /* ignore punctuation but use as delimiter */

1741 else if (ispunct((unsigned char) *(*endstr)))

1742 {

1743 (*endstr)++;

1744 continue;

1745 }

1746 /* otherwise, something is not right... */

1747 else

1748 return -1;

1749

1750 /* force in a delimiter after each field */

1751 *lp++ = '0円';

1752 nf++;

1753 }

1754

1755 *numfields = nf;

1756

1757 return 0;

1758} /* ParseDateTime() */

pg_tolower

unsigned char pg_tolower(unsigned char ch)

Definition: pgstrcasecmp.c:122

References DTK_DATE, DTK_NUMBER, DTK_SPECIAL, DTK_STRING, DTK_TIME, DTK_TZ, MAXDATEFIELDS, and pg_tolower().

◆ pgtypes_defmt_scan()

static int pgtypes_defmt_scan ( union un_fmt_comb * scan_val,

int scan_type,

char ** pstr,

char * pfmt

)

static

Definition at line 2459 of file dt_common.c.

2460{

2461 /*

2462 * scan everything between pstr and pstr_end. This is not including the

2463 * last character so we might set it to '0円' for the parsing

2464 */

2465

2466 char last_char;

2467 int err = 0;

2468 char *pstr_end;

2469 char *strtol_end = NULL;

2470

2471 while (**pstr == ' ')

2472 pstr++;

2473 pstr_end = find_end_token(*pstr, pfmt);

2474 if (!pstr_end)

2475 {

2476 /* there was an error, no match */

2477 return 1;

2478 }

2479 last_char = *pstr_end;

2480 *pstr_end = '0円';

2481

2482 switch (scan_type)

2483 {

2484 case PGTYPES_TYPE_UINT:

2485

2486 /*

2487 * numbers may be blank-padded, this is the only deviation from

2488 * the fmt-string we accept

2489 */

2490 while (**pstr == ' ')

2491 (*pstr)++;

2492 errno = 0;

2493 scan_val->uint_val = (unsigned int) strtol(*pstr, &strtol_end, 10);

2494 if (errno)

2495 err = 1;

2496 break;

2497 case PGTYPES_TYPE_UINT_LONG:

2498 while (**pstr == ' ')

2499 (*pstr)++;

2500 errno = 0;

2501 scan_val->luint_val = (unsigned long int) strtol(*pstr, &strtol_end, 10);

2502 if (errno)

2503 err = 1;

2504 break;

2505 case PGTYPES_TYPE_STRING_MALLOCED:

2506 scan_val->str_val = pgtypes_strdup(*pstr);

2507 if (scan_val->str_val == NULL)

2508 err = 1;

2509 break;

2510 }

2511 if (strtol_end && *strtol_end)

2512 *pstr = strtol_end;

2513 else

2514 *pstr = pstr_end;

2515 *pstr_end = last_char;

2516 return err;

2517}

find_end_token

static char * find_end_token(char *str, char *fmt)

Definition: dt_common.c:2354

err

void err(int eval, const char *fmt,...)

Definition: err.c:43

pgtypes_strdup

char * pgtypes_strdup(const char *str)

Definition: common.c:20

PGTYPES_TYPE_UINT

#define PGTYPES_TYPE_UINT

Definition: pgtypeslib_extern.h:16

PGTYPES_TYPE_STRING_MALLOCED

#define PGTYPES_TYPE_STRING_MALLOCED

Definition: pgtypeslib_extern.h:11

PGTYPES_TYPE_UINT_LONG

#define PGTYPES_TYPE_UINT_LONG

Definition: pgtypeslib_extern.h:21

un_fmt_comb::uint_val

unsigned int uint_val

Definition: pgtypeslib_extern.h:28

un_fmt_comb::luint_val

unsigned long int luint_val

Definition: pgtypeslib_extern.h:30

un_fmt_comb::str_val

char * str_val

Definition: pgtypeslib_extern.h:27

References err(), find_end_token(), un_fmt_comb::luint_val, pgtypes_strdup(), PGTYPES_TYPE_STRING_MALLOCED, PGTYPES_TYPE_UINT, PGTYPES_TYPE_UINT_LONG, un_fmt_comb::str_val, and un_fmt_comb::uint_val.

Referenced by PGTYPEStimestamp_defmt_scan().

◆ PGTYPEStimestamp_defmt_scan()

int PGTYPEStimestamp_defmt_scan ( char ** str,

char * fmt,

timestamp * d,

int * year,

int * month,

int * day,

int * hour,

int * minute,

int * second,

int * tz

)

Definition at line 2521 of file dt_common.c.

2525{

2526 union un_fmt_comb scan_val;

2527 int scan_type;

2528

2529 char *pstr,

2530 *pfmt,

2531 *tmp;

2532 int err = 1;

2533 unsigned int j;

2534 struct tm tm;

2535

2536 pfmt = fmt;

2537 pstr = *str;

2538

2539 while (*pfmt)

2540 {

2541 err = 0;

2542 while (*pfmt == ' ')

2543 pfmt++;

2544 while (*pstr == ' ')

2545 pstr++;

2546 if (*pfmt != '%')

2547 {

2548 if (*pfmt == *pstr)

2549 {

2550 pfmt++;

2551 pstr++;

2552 }

2553 else

2554 {

2555 /* Error: no match */

2556 err = 1;

2557 return err;

2558 }

2559 continue;

2560 }

2561 /* here *pfmt equals '%' */

2562 pfmt++;

2563 switch (*pfmt)

2564 {

2565 case 'a':

2566 pfmt++;

2567

2568 /*

2569 * we parse the day and see if it is a week day but we do not

2570 * check if the week day really matches the date

2571 */

2572 err = 1;

2573 j = 0;

2574 while (pgtypes_date_weekdays_short[j])

2575 {

2576 if (strncmp(pgtypes_date_weekdays_short[j], pstr,

2577 strlen(pgtypes_date_weekdays_short[j])) == 0)

2578 {

2579 /* found it */

2580 err = 0;

2581 pstr += strlen(pgtypes_date_weekdays_short[j]);

2582 break;

2583 }

2584 j++;

2585 }

2586 break;

2587 case 'A':

2588 /* see note above */

2589 pfmt++;

2590 err = 1;

2591 j = 0;

2592 while (days[j])

2593 {

2594 if (strncmp(days[j], pstr, strlen(days[j])) == 0)

2595 {

2596 /* found it */

2597 err = 0;

2598 pstr += strlen(days[j]);

2599 break;

2600 }

2601 j++;

2602 }

2603 break;

2604 case 'b':

2605 case 'h':

2606 pfmt++;

2607 err = 1;

2608 j = 0;

2609 while (months[j])

2610 {

2611 if (strncmp(months[j], pstr, strlen(months[j])) == 0)

2612 {

2613 /* found it */

2614 err = 0;

2615 pstr += strlen(months[j]);

2616 *month = j + 1;

2617 break;

2618 }

2619 j++;

2620 }

2621 break;

2622 case 'B':

2623 /* see note above */

2624 pfmt++;

2625 err = 1;

2626 j = 0;

2627 while (pgtypes_date_months[j])

2628 {

2629 if (strncmp(pgtypes_date_months[j], pstr, strlen(pgtypes_date_months[j])) == 0)

2630 {

2631 /* found it */

2632 err = 0;

2633 pstr += strlen(pgtypes_date_months[j]);

2634 *month = j + 1;

2635 break;

2636 }

2637 j++;

2638 }

2639 break;

2640 case 'c':

2641 /* XXX */

2642 break;

2643 case 'C':

2644 pfmt++;

2645 scan_type = PGTYPES_TYPE_UINT;

2646 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2647 *year = scan_val.uint_val * 100;

2648 break;

2649 case 'd':

2650 case 'e':

2651 pfmt++;

2652 scan_type = PGTYPES_TYPE_UINT;

2653 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2654 *day = scan_val.uint_val;

2655 break;

2656 case 'D':

2657

2658 /*

2659 * we have to concatenate the strings in order to be able to

2660 * find the end of the substitution

2661 */

2662 pfmt++;

2663 tmp = pgtypes_alloc(strlen("%m/%d/%y") + strlen(pstr) + 1);

2664 if (!tmp)

2665 return 1;

2666 strcpy(tmp, "%m/%d/%y");

2667 strcat(tmp, pfmt);

2668 err = PGTYPEStimestamp_defmt_scan(&pstr, tmp, d, year, month, day, hour, minute, second, tz);

2669 free(tmp);

2670 return err;

2671 case 'm':

2672 pfmt++;

2673 scan_type = PGTYPES_TYPE_UINT;

2674 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2675 *month = scan_val.uint_val;

2676 break;

2677 case 'y':

2678 case 'g': /* XXX difference to y (ISO) */

2679 pfmt++;

2680 scan_type = PGTYPES_TYPE_UINT;

2681 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2682 if (*year < 0)

2683 {

2684 /* not yet set */

2685 *year = scan_val.uint_val;

2686 }

2687 else

2688 *year += scan_val.uint_val;

2689 if (*year < 100)

2690 *year += 1900;

2691 break;

2692 case 'G':

2693 /* XXX difference to %V (ISO) */

2694 pfmt++;

2695 scan_type = PGTYPES_TYPE_UINT;

2696 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2697 *year = scan_val.uint_val;

2698 break;

2699 case 'H':

2700 case 'I':

2701 case 'k':

2702 case 'l':

2703 pfmt++;

2704 scan_type = PGTYPES_TYPE_UINT;

2705 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2706 *hour += scan_val.uint_val;

2707 break;

2708 case 'j':

2709 pfmt++;

2710 scan_type = PGTYPES_TYPE_UINT;

2711 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2712

2713 /*

2714 * XXX what should we do with that? We could say that it's

2715 * sufficient if we have the year and the day within the year

2716 * to get at least a specific day.

2717 */

2718 break;

2719 case 'M':

2720 pfmt++;

2721 scan_type = PGTYPES_TYPE_UINT;

2722 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2723 *minute = scan_val.uint_val;

2724 break;

2725 case 'n':

2726 pfmt++;

2727 if (*pstr == '\n')

2728 pstr++;

2729 else

2730 err = 1;

2731 break;

2732 case 'p':

2733 err = 1;

2734 pfmt++;

2735 if (strncmp(pstr, "am", 2) == 0)

2736 {

2737 *hour += 0;

2738 err = 0;

2739 pstr += 2;

2740 }

2741 if (strncmp(pstr, "a.m.", 4) == 0)

2742 {

2743 *hour += 0;

2744 err = 0;

2745 pstr += 4;

2746 }

2747 if (strncmp(pstr, "pm", 2) == 0)

2748 {

2749 *hour += 12;

2750 err = 0;

2751 pstr += 2;

2752 }

2753 if (strncmp(pstr, "p.m.", 4) == 0)

2754 {

2755 *hour += 12;

2756 err = 0;

2757 pstr += 4;

2758 }

2759 break;

2760 case 'P':

2761 err = 1;

2762 pfmt++;

2763 if (strncmp(pstr, "AM", 2) == 0)

2764 {

2765 *hour += 0;

2766 err = 0;

2767 pstr += 2;

2768 }

2769 if (strncmp(pstr, "A.M.", 4) == 0)

2770 {

2771 *hour += 0;

2772 err = 0;

2773 pstr += 4;

2774 }

2775 if (strncmp(pstr, "PM", 2) == 0)

2776 {

2777 *hour += 12;

2778 err = 0;

2779 pstr += 2;

2780 }

2781 if (strncmp(pstr, "P.M.", 4) == 0)

2782 {

2783 *hour += 12;

2784 err = 0;

2785 pstr += 4;

2786 }

2787 break;

2788 case 'r':

2789 pfmt++;

2790 tmp = pgtypes_alloc(strlen("%I:%M:%S %p") + strlen(pstr) + 1);

2791 if (!tmp)

2792 return 1;

2793 strcpy(tmp, "%I:%M:%S %p");

2794 strcat(tmp, pfmt);

2795 err = PGTYPEStimestamp_defmt_scan(&pstr, tmp, d, year, month, day, hour, minute, second, tz);

2796 free(tmp);

2797 return err;

2798 case 'R':

2799 pfmt++;

2800 tmp = pgtypes_alloc(strlen("%H:%M") + strlen(pstr) + 1);

2801 if (!tmp)

2802 return 1;

2803 strcpy(tmp, "%H:%M");

2804 strcat(tmp, pfmt);

2805 err = PGTYPEStimestamp_defmt_scan(&pstr, tmp, d, year, month, day, hour, minute, second, tz);

2806 free(tmp);

2807 return err;

2808 case 's':

2809 pfmt++;

2810 scan_type = PGTYPES_TYPE_UINT_LONG;

2811 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2812 /* number of seconds in scan_val.luint_val */

2813 {

2814 struct tm *tms;

2815 struct tm tmbuf;

2816 time_t et = (time_t) scan_val.luint_val;

2817

2818 tms = gmtime_r(&et, &tmbuf);

2819

2820 if (tms)

2821 {

2822 *year = tms->tm_year + 1900;

2823 *month = tms->tm_mon + 1;

2824 *day = tms->tm_mday;

2825 *hour = tms->tm_hour;

2826 *minute = tms->tm_min;

2827 *second = tms->tm_sec;

2828 }

2829 else

2830 err = 1;

2831 }

2832 break;

2833 case 'S':

2834 pfmt++;

2835 scan_type = PGTYPES_TYPE_UINT;

2836 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2837 *second = scan_val.uint_val;

2838 break;

2839 case 't':

2840 pfmt++;

2841 if (*pstr == '\t')

2842 pstr++;

2843 else

2844 err = 1;

2845 break;

2846 case 'T':

2847 pfmt++;

2848 tmp = pgtypes_alloc(strlen("%H:%M:%S") + strlen(pstr) + 1);

2849 if (!tmp)

2850 return 1;

2851 strcpy(tmp, "%H:%M:%S");

2852 strcat(tmp, pfmt);

2853 err = PGTYPEStimestamp_defmt_scan(&pstr, tmp, d, year, month, day, hour, minute, second, tz);

2854 free(tmp);

2855 return err;

2856 case 'u':

2857 pfmt++;

2858 scan_type = PGTYPES_TYPE_UINT;

2859 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2860 if (scan_val.uint_val < 1 || scan_val.uint_val > 7)

2861 err = 1;

2862 break;

2863 case 'U':

2864 pfmt++;

2865 scan_type = PGTYPES_TYPE_UINT;

2866 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2867 if (scan_val.uint_val > 53)

2868 err = 1;

2869 break;

2870 case 'V':

2871 pfmt++;

2872 scan_type = PGTYPES_TYPE_UINT;

2873 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2874 if (scan_val.uint_val < 1 || scan_val.uint_val > 53)

2875 err = 1;

2876 break;

2877 case 'w':

2878 pfmt++;

2879 scan_type = PGTYPES_TYPE_UINT;

2880 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2881 if (scan_val.uint_val > 6)

2882 err = 1;

2883 break;

2884 case 'W':

2885 pfmt++;

2886 scan_type = PGTYPES_TYPE_UINT;

2887 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2888 if (scan_val.uint_val > 53)

2889 err = 1;

2890 break;

2891 case 'x':

2892 case 'X':

2893 /* XXX */

2894 break;

2895 case 'Y':

2896 pfmt++;

2897 scan_type = PGTYPES_TYPE_UINT;

2898 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2899 *year = scan_val.uint_val;

2900 break;

2901 case 'z':

2902 pfmt++;

2903 scan_type = PGTYPES_TYPE_STRING_MALLOCED;

2904 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2905 if (!err)

2906 {

2907 err = DecodeTimezone(scan_val.str_val, tz);

2908 free(scan_val.str_val);

2909 }

2910 break;

2911 case 'Z':

2912 pfmt++;

2913 scan_type = PGTYPES_TYPE_STRING_MALLOCED;

2914 err = pgtypes_defmt_scan(&scan_val, scan_type, &pstr, pfmt);

2915 if (!err)

2916 {

2917 /*

2918 * XXX use DecodeSpecial instead? Do we need strcasecmp

2919 * here?

2920 */

2921 err = 1;

2922 for (j = 0; j < szdatetktbl; j++)

2923 {

2924 if ((datetktbl[j].type == TZ || datetktbl[j].type == DTZ) &&

2925 pg_strcasecmp(datetktbl[j].token,

2926 scan_val.str_val) == 0)

2927 {

2928 *tz = -datetktbl[j].value;

2929 err = 0;

2930 break;

2931 }

2932 }

2933 free(scan_val.str_val);

2934 }

2935 break;

2936 case '+':

2937 /* XXX */

2938 break;

2939 case '%':

2940 pfmt++;

2941 if (*pstr == '%')

2942 pstr++;

2943 else

2944 err = 1;

2945 break;

2946 default:

2947 err = 1;

2948 }

2949 }

2950 if (!err)

2951 {

2952 if (*second < 0)

2953 *second = 0;

2954 if (*minute < 0)

2955 *minute = 0;

2956 if (*hour < 0)

2957 *hour = 0;

2958 if (*day < 0)

2959 {

2960 err = 1;

2961 *day = 1;

2962 }

2963 if (*month < 0)

2964 {

2965 err = 1;

2966 *month = 1;

2967 }

2968 if (*year < 0)

2969 {

2970 err = 1;

2971 *year = 1970;

2972 }

2973

2974 if (*second > 59)

2975 {

2976 err = 1;

2977 *second = 0;

2978 }

2979 if (*minute > 59)

2980 {

2981 err = 1;

2982 *minute = 0;

2983 }

2984 if (*hour > 24 || /* test for > 24:00:00 */

2985 (*hour == 24 && (*minute > 0 || *second > 0)))

2986 {

2987 err = 1;

2988 *hour = 0;

2989 }

2990 if (*month > MONTHS_PER_YEAR)

2991 {

2992 err = 1;

2993 *month = 1;

2994 }

2995 if (*day > day_tab[isleap(*year)][*month - 1])

2996 {

2997 *day = day_tab[isleap(*year)][*month - 1];

2998 err = 1;

2999 }

3000

3001 tm.tm_sec = *second;

3002 tm.tm_min = *minute;

3003 tm.tm_hour = *hour;

3004 tm.tm_mday = *day;

3005 tm.tm_mon = *month;

3006 tm.tm_year = *year;

3007

3008 tm2timestamp(&tm, 0, tz, d);

3009 }

3010 return err;

3011}

tm2timestamp

int tm2timestamp(struct pg_tm *tm, fsec_t fsec, int *tzp, Timestamp *result)

Definition: timestamp.c:2006

PGTYPEStimestamp_defmt_scan

int PGTYPEStimestamp_defmt_scan(char **str, char *fmt, timestamp *d, int *year, int *month, int *day, int *hour, int *minute, int *second, int *tz)

Definition: dt_common.c:2521

pgtypes_date_months

char * pgtypes_date_months[]

Definition: dt_common.c:499

pgtypes_date_weekdays_short

char * pgtypes_date_weekdays_short[]

Definition: dt_common.c:497

pgtypes_defmt_scan

static int pgtypes_defmt_scan(union un_fmt_comb *scan_val, int scan_type, char **pstr, char *pfmt)

Definition: dt_common.c:2459

free

#define free(a)

Definition: header.h:65

pgtypes_alloc

char * pgtypes_alloc(long size)

Definition: common.c:10

j

int j

Definition: isn.c:78

pg_strcasecmp

int pg_strcasecmp(const char *s1, const char *s2)

Definition: pgstrcasecmp.c:36

un_fmt_comb

Definition: pgtypeslib_extern.h:26

References datetktbl, day_tab, days, DecodeTimezone(), DTZ, err(), free, isleap, j, un_fmt_comb::luint_val, months, MONTHS_PER_YEAR, pg_strcasecmp(), pgtypes_alloc(), pgtypes_date_months, pgtypes_date_weekdays_short, pgtypes_defmt_scan(), PGTYPES_TYPE_STRING_MALLOCED, PGTYPES_TYPE_UINT, PGTYPES_TYPE_UINT_LONG, PGTYPEStimestamp_defmt_scan(), str, un_fmt_comb::str_val, szdatetktbl, tm, tm2timestamp(), pg_tm::tm_hour, pg_tm::tm_mday, pg_tm::tm_min, pg_tm::tm_mon, pg_tm::tm_sec, pg_tm::tm_year, type, TZ, un_fmt_comb::uint_val, and datetkn::value.

Referenced by PGTYPEStimestamp_defmt_asc(), and PGTYPEStimestamp_defmt_scan().

◆ TrimTrailingZeros()

void TrimTrailingZeros ( char * str )

Definition at line 722 of file dt_common.c.

723{

724 int len = strlen(str);

725

726 /* chop off trailing zeros... but leave at least 2 fractional digits */

727 while (*(str + len - 1) == '0' && *(str + len - 3) != '.')

728 {

729 len--;

730 *(str + len) = '0円';

731 }

732}

References len, and str.

Referenced by AppendSeconds(), and EncodeDateTime().

Variable Documentation

◆ datecache

const datetkn* datecache[MAXDATEFIELDS] = {NULL}

static

Definition at line 489 of file dt_common.c.

Referenced by DecodeSpecial().

◆ datetktbl

const datetkn datetktbl[]

static

Definition at line 20 of file dt_common.c.

Referenced by DecodeSpecial(), and PGTYPEStimestamp_defmt_scan().

◆ day_tab

const int day_tab[2][13]

Initial value:

= {

{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0},

{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0}}

Definition at line 14 of file dt_common.c.

Referenced by DecodeDateTime(), and PGTYPEStimestamp_defmt_scan().

◆ days

char* days[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", NULL}

Definition at line 495 of file dt_common.c.

Referenced by EncodeDateTime(), and PGTYPEStimestamp_defmt_scan().

◆ deltacache

const datetkn* deltacache[MAXDATEFIELDS] = {NULL}

static

Definition at line 491 of file dt_common.c.

Referenced by DecodeUnits().

◆ deltatktbl

const datetkn deltatktbl[]

static

Definition at line 421 of file dt_common.c.

Referenced by DecodeUnits().

◆ months

char* months[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", NULL}

Definition at line 493 of file dt_common.c.

Referenced by EncodeDateTime(), and PGTYPEStimestamp_defmt_scan().

◆ pgtypes_date_months

char* pgtypes_date_months[] = {"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December", NULL}

Definition at line 499 of file dt_common.c.

Referenced by dttofmtasc_replace(), PGTYPESdate_defmt_asc(), and PGTYPEStimestamp_defmt_scan().

◆ pgtypes_date_weekdays_short

char* pgtypes_date_weekdays_short[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", NULL}

Definition at line 497 of file dt_common.c.

Referenced by dttofmtasc_replace(), PGTYPESdate_fmt_asc(), and PGTYPEStimestamp_defmt_scan().

◆ szdatetktbl

const unsigned int szdatetktbl = lengthof(datetktbl)

static

Definition at line 486 of file dt_common.c.

Referenced by DecodeSpecial(), and PGTYPEStimestamp_defmt_scan().

◆ szdeltatktbl

const unsigned int szdeltatktbl = lengthof(deltatktbl)

static

Definition at line 487 of file dt_common.c.

Referenced by DecodeUnits().