/* GLIB - Library of useful routines for C programming

* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

*

* SPDX-License-Identifier: LGPL-2.1-or-later

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2.1 of the License, or (at your option) any later version.

*

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this library; if not, see <http://www.gnu.org/licenses/>.

*/

/*

* Modified by the GLib Team and others 1997-2000. See the AUTHORS

* file for a list of people on the GLib Team. See the ChangeLog

* files for a list of changes. These files are distributed with

* GLib at ftp://ftp.gtk.org/pub/gtk/.

*/

/*

* MT safe

*/

#include "config.h"

#include "glibconfig.h"

#define DEBUG_MSG(x) /* */

#ifdef G_ENABLE_DEBUG

/* #define DEBUG_MSG(args) g_message args ; */

#endif

#include <time.h>

#include <string.h>

#include <stdlib.h>

#include <locale.h>

#ifdef G_OS_WIN32

#include <windows.h>

#endif

#include "gdate.h"

#include "gconvert.h"

#include "gmem.h"

#include "gstrfuncs.h"

#include "gtestutils.h"

#include "gthread.h"

#include "gunicode.h"

#include "gutilsprivate.h"

#ifdef G_OS_WIN32

#include "garray.h"

#endif

/**

* GDate:

* @julian_days: the Julian representation of the date

* @julian: this bit is set if @julian_days is valid

* @dmy: this is set if @day, @month and @year are valid

* @day: the day of the day-month-year representation of the date,

* as a number between 1 and 31

* @month: the month of the day-month-year representation of the date,

* as a number between 1 and 12

* @year: the year of the day-month-year representation of the date

*

* `GDate` is a struct for calendrical calculations.

*

* The `GDate` data structure represents a day between January 1, Year 1,

* and sometime a few thousand years in the future (right now it will go

* to the year 65535 or so, but [method@GLib.Date.set_parse] only parses up to the

* year 8000 or so - just count on "a few thousand"). `GDate` is meant to

* represent everyday dates, not astronomical dates or historical dates

* or ISO timestamps or the like. It extrapolates the current Gregorian

* calendar forward and backward in time; there is no attempt to change

* the calendar to match time periods or locations. `GDate` does not store

* time information; it represents a day.

*

* The `GDate` implementation has several nice features; it is only a

* 64-bit struct, so storing large numbers of dates is very efficient. It

* can keep both a Julian and day-month-year representation of the date,

* since some calculations are much easier with one representation or the

* other. A Julian representation is simply a count of days since some

* fixed day in the past; for #GDate the fixed day is January 1, 1 AD.

* ("Julian" dates in the #GDate API aren't really Julian dates in the

* technical sense; technically, Julian dates count from the start of the

* Julian period, Jan 1, 4713 BC).

*

* `GDate` is simple to use. First you need a "blank" date; you can get a

* dynamically allocated date from [ctor@GLib.Date.new], or you can declare an

* automatic variable or array and initialize it by calling [method@GLib.Date.clear].

* A cleared date is safe; it's safe to call [method@GLib.Date.set_dmy] and the other

* mutator functions to initialize the value of a cleared date. However, a cleared date

* is initially invalid, meaning that it doesn't represent a day that exists.

* It is undefined to call any of the date calculation routines on an invalid date.

* If you obtain a date from a user or other unpredictable source, you should check

* its validity with the [method@GLib.Date.valid] predicate. [method@GLib.Date.valid]

* is also used to check for errors with [method@GLib.Date.set_parse] and other functions

* that can fail. Dates can be invalidated by calling [method@GLib.Date.clear] again.

*

* It is very important to use the API to access the `GDate` struct. Often only the

* day-month-year or only the Julian representation is valid. Sometimes neither is valid.

* Use the API.

*

* GLib also features `GDateTime` which represents a precise time.

*/

/**

* G_USEC_PER_SEC:

*

* Number of microseconds in one second (1 million).

* This macro is provided for code readability.

*/

/**

* G_NSEC_PER_SEC:

*

* Number of nanoseconds in one second (1 billion).

* This macro is provided for code readability.

*

* Since: 2.88

*/

/**

* GTimeVal:

* @tv_sec: seconds

* @tv_usec: microseconds

*

* Represents a precise time, with seconds and microseconds.

*

* Similar to the struct timeval returned by the `gettimeofday()`

* UNIX system call.

*

* GLib is attempting to unify around the use of 64-bit integers to

* represent microsecond-precision time. As such, this type will be

* removed from a future version of GLib. A consequence of using `glong` for

* `tv_sec` is that on 32-bit systems `GTimeVal` is subject to the year 2038

* problem.

*

* Deprecated: 2.62: Use #GDateTime or #guint64 instead.

*/

/**

* GTime:

*

* Simply a replacement for `time_t`. It has been deprecated

* since it is not equivalent to `time_t` on 64-bit platforms

* with a 64-bit `time_t`.

*

* Unrelated to #GTimer.

*

* Note that #GTime is defined to always be a 32-bit integer,

* unlike `time_t` which may be 64-bit on some systems. Therefore,

* #GTime will overflow in the year 2038, and you cannot use the

* address of a #GTime variable as argument to the UNIX time()

* function.

*

* Instead, do the following:

*

* |[<!-- language="C" -->

* time_t ttime;

* GTime gtime;

*

* time (&ttime);

* gtime = (GTime)ttime;

* ]|

*

* Deprecated: 2.62: This is not [Y2038-safe](https://en.wikipedia.org/wiki/Year_2038_problem).

* Use #GDateTime or #time_t instead.

*/

/**

* GDateDMY:

* @G_DATE_DAY: a day

* @G_DATE_MONTH: a month

* @G_DATE_YEAR: a year

*

* This enumeration isn't used in the API, but may be useful if you need

* to mark a number as a day, month, or year.

*/

/**

* GDateDay:

*

* Integer representing a day of the month; between 1 and 31.

*

* The %G_DATE_BAD_DAY value represents an invalid day of the month.

*/

/**

* GDateMonth:

* @G_DATE_BAD_MONTH: invalid value

* @G_DATE_JANUARY: January

* @G_DATE_FEBRUARY: February

* @G_DATE_MARCH: March

* @G_DATE_APRIL: April

* @G_DATE_MAY: May

* @G_DATE_JUNE: June

* @G_DATE_JULY: July

* @G_DATE_AUGUST: August

* @G_DATE_SEPTEMBER: September

* @G_DATE_OCTOBER: October

* @G_DATE_NOVEMBER: November

* @G_DATE_DECEMBER: December

*

* Enumeration representing a month; values are %G_DATE_JANUARY,

* %G_DATE_FEBRUARY, etc. %G_DATE_BAD_MONTH is the invalid value.

*/

/**

* GDateYear:

*

* Integer type representing a year.

*

* The %G_DATE_BAD_YEAR value is the invalid value. The year

* must be 1 or higher; negative ([BCE](https://en.wikipedia.org/wiki/Common_Era))

* years are not allowed.

*

* The year is represented with four digits.

*/

/**

* GDateWeekday:

* @G_DATE_BAD_WEEKDAY: invalid value

* @G_DATE_MONDAY: Monday

* @G_DATE_TUESDAY: Tuesday

* @G_DATE_WEDNESDAY: Wednesday

* @G_DATE_THURSDAY: Thursday

* @G_DATE_FRIDAY: Friday

* @G_DATE_SATURDAY: Saturday

* @G_DATE_SUNDAY: Sunday

*

* Enumeration representing a day of the week; %G_DATE_MONDAY,

* %G_DATE_TUESDAY, etc. %G_DATE_BAD_WEEKDAY is an invalid weekday.

*/

/**

* G_DATE_BAD_DAY:

*

* Represents an invalid #GDateDay.

*/

/**

* G_DATE_BAD_JULIAN:

*

* Represents an invalid Julian day number.

*/

/**

* G_DATE_BAD_YEAR:

*

* Represents an invalid year.

*/

/**

* g_date_new:

*

* Allocates a #GDate and initializes

* it to a safe state. The new date will

* be cleared (as if you'd called g_date_clear()) but invalid (it won't

* represent an existing day). Free the return value with g_date_free().

*

* Returns: a newly-allocated #GDate

*/

GDate*

g_date_new (void)

{

GDate *d = g_new0 (GDate, 1); /* happily, 0 is the invalid flag for everything. */

return d;

}

/**

* g_date_new_dmy:

* @day: day of the month

* @month: month of the year

* @year: year

*

* Create a new #GDate representing the given day-month-year triplet.

*

* The triplet you pass in must represent a valid date. Use g_date_valid_dmy()

* if needed to validate it. The returned #GDate is guaranteed to be non-%NULL

* and valid.

*

* Returns: (transfer full) (not nullable): a newly-allocated #GDate

* initialized with @day, @month, and @year

*/

GDate*

g_date_new_dmy (GDateDay day,

GDateMonth m,

GDateYear y)

{

GDate *d;

g_return_val_if_fail (g_date_valid_dmy (day, m, y), NULL);

d = g_new (GDate, 1);

d->julian = FALSE;

d->dmy = TRUE;

d->month = m;

d->day = day;

d->year = y;

g_assert (g_date_valid (d));

return d;

}

/**

* g_date_new_julian:

* @julian_day: days since January 1, Year 1

*

* Create a new #GDate representing the given Julian date.

*

* The @julian_day you pass in must be valid. Use g_date_valid_julian() if

* needed to validate it. The returned #GDate is guaranteed to be non-%NULL and

* valid.

*

* Returns: (transfer full) (not nullable): a newly-allocated #GDate initialized

* with @julian_day

*/

GDate*

g_date_new_julian (guint32 julian_day)

{

GDate *d;

g_return_val_if_fail (g_date_valid_julian (julian_day), NULL);

d = g_new (GDate, 1);

d->julian = TRUE;

d->dmy = FALSE;

d->julian_days = julian_day;

g_assert (g_date_valid (d));

return d;

}

/**

* g_date_free:

* @date: a #GDate to free

*

* Frees a #GDate returned from g_date_new().

*/

void

g_date_free (GDate *date)

{

g_return_if_fail (date != NULL);

g_free (date);

}

/**

* g_date_copy:

* @date: a #GDate to copy

*

* Copies a GDate to a newly-allocated GDate. If the input was invalid

* (as determined by g_date_valid()), the invalid state will be copied

* as is into the new object.

*

* Returns: (transfer full): a newly-allocated #GDate initialized from @date

*

* Since: 2.56

*/

GDate *

g_date_copy (const GDate *date)

{

GDate *res;

g_return_val_if_fail (date != NULL, NULL);

if (g_date_valid (date))

res = g_date_new_julian (g_date_get_julian (date));

else

{

res = g_date_new ();

*res = *date;

}

return res;

}

/**

* g_date_valid:

* @date: a #GDate to check

*

* Returns %TRUE if the #GDate represents an existing day. The date must not

* contain garbage; it should have been initialized with g_date_clear()

* if it wasn't allocated by one of the g_date_new() variants.

*

* Returns: Whether the date is valid

*/

gboolean

g_date_valid (const GDate *d)

{

g_return_val_if_fail (d != NULL, FALSE);

return (d->julian || d->dmy);

}

static const guint8 days_in_months[2][13] =

{ /* error, jan feb mar apr may jun jul aug sep oct nov dec */

{ 0, 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 } /* leap year */

};

static const guint16 days_in_year[2][14] =

{ /* 0, jan feb mar apr may jun jul aug sep oct nov dec */

{ 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },

{ 0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }

};

/**

* g_date_valid_month:

* @month: month

*

* Returns %TRUE if the month value is valid. The 12 #GDateMonth

* enumeration values are the only valid months.

*

* Returns: %TRUE if the month is valid

*/

gboolean

g_date_valid_month (GDateMonth m)

{

return (((gint) m > G_DATE_BAD_MONTH) && ((gint) m < 13));

}

/**

* g_date_valid_year:

* @year: year

*

* Returns %TRUE if the year is valid. Any year greater than 0 is valid,

* though there is a 16-bit limit to what #GDate will understand.

*

* Returns: %TRUE if the year is valid

*/

gboolean

g_date_valid_year (GDateYear y)

{

return ( y > G_DATE_BAD_YEAR );

}

/**

* g_date_valid_day:

* @day: day to check

*

* Returns %TRUE if the day of the month is valid (a day is valid if it's

* between 1 and 31 inclusive).

*

* Returns: %TRUE if the day is valid

*/

gboolean

g_date_valid_day (GDateDay d)

{

return ( (d > G_DATE_BAD_DAY) && (d < 32) );

}

/**

* g_date_valid_weekday:

* @weekday: weekday

*

* Returns %TRUE if the weekday is valid. The seven #GDateWeekday enumeration

* values are the only valid weekdays.

*

* Returns: %TRUE if the weekday is valid

*/

gboolean

g_date_valid_weekday (GDateWeekday w)

{

return (((gint) w > G_DATE_BAD_WEEKDAY) && ((gint) w < 8));

}

/**

* g_date_valid_julian:

* @julian_date: Julian day to check

*

* Returns %TRUE if the Julian day is valid. Anything greater than zero

* is basically a valid Julian, though there is a 32-bit limit.

*

* Returns: %TRUE if the Julian day is valid

*/

gboolean

g_date_valid_julian (guint32 j)

{

return (j > G_DATE_BAD_JULIAN);

}

/**

* g_date_valid_dmy:

* @day: day

* @month: month

* @year: year

*

* Returns %TRUE if the day-month-year triplet forms a valid, existing day

* in the range of days #GDate understands (Year 1 or later, no more than

* a few thousand years in the future).

*

* Returns: %TRUE if the date is a valid one

*/

gboolean

g_date_valid_dmy (GDateDay d,

GDateMonth m,

GDateYear y)

{

/* No need to check the upper bound of @y, because #GDateYear is 16 bits wide,

* just like #GDate.year. */

return ( (m > G_DATE_BAD_MONTH) &&

(m < 13) &&

(d > G_DATE_BAD_DAY) &&

(y > G_DATE_BAD_YEAR) && /* must check before using g_date_is_leap_year */

(d <= (g_date_is_leap_year (y) ?

days_in_months[1][m] : days_in_months[0][m])) );

}

/* "Julian days" just means an absolute number of days, where Day 1 ==

* Jan 1, Year 1

*/

static void

g_date_update_julian (const GDate *const_d)

{

GDate *d = (GDate *) const_d;

GDateYear year;

gint idx;

g_return_if_fail (d != NULL);

g_return_if_fail (d->dmy != 0);

g_return_if_fail (!d->julian);

g_return_if_fail (g_date_valid_dmy (d->day, d->month, d->year));

/* What we actually do is: multiply years * 365 days in the year,

* add the number of years divided by 4, subtract the number of

* years divided by 100 and add the number of years divided by 400,

* which accounts for leap year stuff. Code from Steffen Beyer's

* DateCalc.

*/

year = d->year - 1; /* we know d->year > 0 since it's valid */

d->julian_days = year * 365U;

d->julian_days += (year >>= 2); /* divide by 4 and add */

d->julian_days -= (year /= 25); /* divides original # years by 100 */

d->julian_days += year >> 2; /* divides by 4, which divides original by 400 */

idx = g_date_is_leap_year (d->year) ? 1 : 0;

d->julian_days += days_in_year[idx][d->month] + d->day;

g_return_if_fail (g_date_valid_julian (d->julian_days));

d->julian = TRUE;

}

static void

g_date_update_dmy (const GDate *const_d)

{

GDate *d = (GDate *) const_d;

GDateYear y;

GDateMonth m;

GDateDay day;

guint32 A, B, C, D, E, M;

g_return_if_fail (d != NULL);

g_return_if_fail (d->julian);

g_return_if_fail (!d->dmy);

g_return_if_fail (g_date_valid_julian (d->julian_days));

/* Formula taken from the Calendar FAQ; the formula was for the

* Julian Period which starts on 1 January 4713 BC, so we add

* 1,721,425 to the number of days before doing the formula.

*

* I'm sure this can be simplified for our 1 January 1 AD period

* start, but I can't figure out how to unpack the formula.

*/

A = d->julian_days + 1721425 + 32045;

B = ( 4 *(A + 36524) )/ 146097 - 1;

C = A - (146097 * B)/4;

D = ( 4 * (C + 365) ) / 1461 - 1;

E = C - ((1461*D) / 4);

M = (5 * (E - 1) + 2)/153;

m = M + 3 - (12*(M/10));

day = E - (153*M + 2)/5;

y = 100 * B + D - 4800 + (M/10);

#ifdef G_ENABLE_DEBUG

if (!g_date_valid_dmy (day, m, y))

g_warning ("OOPS julian: %u computed dmy: %u %u %u",

d->julian_days, day, m, y);

#endif

d->month = m;

d->day = day;

d->year = y;

d->dmy = TRUE;

}

/**

* g_date_get_weekday:

* @date: a #GDate

*

* Returns the day of the week for a #GDate. The date must be valid.

*

* Returns: day of the week as a #GDateWeekday.

*/

GDateWeekday

g_date_get_weekday (const GDate *d)

{

g_return_val_if_fail (g_date_valid (d), G_DATE_BAD_WEEKDAY);

if (!d->julian)

g_date_update_julian (d);

g_return_val_if_fail (d->julian, G_DATE_BAD_WEEKDAY);

return ((d->julian_days - 1) % 7) + 1;

}

/**

* g_date_get_month:

* @date: a #GDate to get the month from

*

* Returns the month of the year. The date must be valid.

*

* Returns: month of the year as a #GDateMonth

*/

GDateMonth

g_date_get_month (const GDate *d)

{

g_return_val_if_fail (g_date_valid (d), G_DATE_BAD_MONTH);

if (!d->dmy)

g_date_update_dmy (d);

g_return_val_if_fail (d->dmy, G_DATE_BAD_MONTH);

return d->month;

}

/**

* g_date_get_year:

* @date: a #GDate

*

* Returns the year of a #GDate. The date must be valid.

*

* Returns: year in which the date falls

*/

GDateYear

g_date_get_year (const GDate *d)

{

g_return_val_if_fail (g_date_valid (d), G_DATE_BAD_YEAR);

if (!d->dmy)

g_date_update_dmy (d);

g_return_val_if_fail (d->dmy, G_DATE_BAD_YEAR);

return d->year;

}

/**

* g_date_get_day:

* @date: a #GDate to extract the day of the month from

*

* Returns the day of the month. The date must be valid.

*

* Returns: day of the month

*/

GDateDay

g_date_get_day (const GDate *d)

{

g_return_val_if_fail (g_date_valid (d), G_DATE_BAD_DAY);

if (!d->dmy)

g_date_update_dmy (d);

g_return_val_if_fail (d->dmy, G_DATE_BAD_DAY);

return d->day;

}

/**

* g_date_get_julian:

* @date: a #GDate to extract the Julian day from

*

* Returns the Julian day or "serial number" of the #GDate. The

* Julian day is simply the number of days since January 1, Year 1; i.e.,

* January 1, Year 1 is Julian day 1; January 2, Year 1 is Julian day 2,

* etc. The date must be valid.

*

* Returns: Julian day

*/

guint32

g_date_get_julian (const GDate *d)

{

g_return_val_if_fail (g_date_valid (d), G_DATE_BAD_JULIAN);

if (!d->julian)

g_date_update_julian (d);

g_return_val_if_fail (d->julian, G_DATE_BAD_JULIAN);

return d->julian_days;

}

/**

* g_date_get_day_of_year:

* @date: a #GDate to extract day of year from

*

* Returns the day of the year, where Jan 1 is the first day of the

* year. The date must be valid.

*

* Returns: day of the year

*/

guint

g_date_get_day_of_year (const GDate *d)

{

gint idx;

g_return_val_if_fail (g_date_valid (d), 0);

if (!d->dmy)

g_date_update_dmy (d);

g_return_val_if_fail (d->dmy, 0);

idx = g_date_is_leap_year (d->year) ? 1 : 0;

return (days_in_year[idx][d->month] + d->day);

}

/**

* g_date_get_monday_week_of_year:

* @date: a #GDate

*

* Returns the week of the year, where weeks are understood to start on

* Monday. If the date is before the first Monday of the year, return 0.

* The date must be valid.

*

* Returns: week of the year

*/

guint

g_date_get_monday_week_of_year (const GDate *date)

{

return g_date_get_week_of_year (date, G_DATE_MONDAY);

}

/**

* g_date_get_sunday_week_of_year:

* @date: a #GDate

*

* Returns the week of the year during which this date falls, if

* weeks are understood to begin on Sunday. The date must be valid.

* Can return 0 if the day is before the first Sunday of the year.

*

* Returns: week number

*/

guint

g_date_get_sunday_week_of_year (const GDate *date)

{

return g_date_get_week_of_year (date, G_DATE_SUNDAY);

}

/**

* g_date_get_week_of_year:

* @date: a [struct@GLib.Date]

* @first_day_of_week: the day which is considered the first day of the week

* (for example, this would be [enum@GLib.DateWeekday.SUNDAY] in US locales,

* [enum@GLib.DateWeekday.MONDAY] in British locales, and

* [enum@GLib.DateWeekday.SATURDAY] in Egyptian locales

*

* Calculates the week of the year during which this date falls.

*

* The result depends on which day is considered the first day of the week,

* which varies by locale. Both `date` and `first_day_of_week` must be valid.

*

* If @date is before the start of the first week of the year (for example,

* before the first Monday in January if @first_day_of_week is

* [enum@GLib.DateWeekday.MONDAY]) then zero will be returned.

*

* Returns: week number (starting from 1), or `0` if @date is before the start

* of the first week of the year

* Since: 2.86

*/

unsigned int

g_date_get_week_of_year (const GDate *date,

GDateWeekday first_day_of_week)

{

GDate first_day_of_year;

unsigned int n_days_before_first_week;

g_return_val_if_fail (g_date_valid (date), 0);

g_return_val_if_fail (first_day_of_week != G_DATE_BAD_WEEKDAY, 0);

if (!date->dmy)

g_date_update_dmy (date);

g_return_val_if_fail (date->dmy, 0);

g_date_clear (&first_day_of_year, 1);

g_date_set_dmy (&first_day_of_year, 1, 1, date->year);

n_days_before_first_week = (first_day_of_week - g_date_get_weekday (&first_day_of_year) + 7) % 7;

return (g_date_get_day_of_year (date) + 6 - n_days_before_first_week) / 7;

}

/**

* g_date_get_iso8601_week_of_year:

* @date: a valid #GDate

*

* Returns the week of the year, where weeks are interpreted according

* to ISO 8601.

*

* Returns: ISO 8601 week number of the year.

*

* Since: 2.6

**/

guint

g_date_get_iso8601_week_of_year (const GDate *d)

{

guint j, d4, L, d1, w;

g_return_val_if_fail (g_date_valid (d), 0);

if (!d->julian)

g_date_update_julian (d);

g_return_val_if_fail (d->julian, 0);

/* Formula taken from the Calendar FAQ; the formula was for the

* Julian Period which starts on 1 January 4713 BC, so we add

* 1,721,425 to the number of days before doing the formula.

*/

j = d->julian_days + 1721425;

d4 = (j + 31741 - (j % 7)) % 146097 % 36524 % 1461;

L = d4 / 1460;

d1 = ((d4 - L) % 365) + L;

w = d1 / 7 + 1;

return w;

}

/**

* g_date_days_between:

* @date1: the first date

* @date2: the second date

*

* Computes the number of days between two dates.

* If @date2 is prior to @date1, the returned value is negative.

* Both dates must be valid.

*

* Returns: the number of days between @date1 and @date2

*/

gint

g_date_days_between (const GDate *d1,

const GDate *d2)

{

g_return_val_if_fail (g_date_valid (d1), 0);

g_return_val_if_fail (g_date_valid (d2), 0);

return (gint)g_date_get_julian (d2) - (gint)g_date_get_julian (d1);

}

/**

* g_date_clear:

* @date: pointer to one or more dates to clear

* @n_dates: number of dates to clear

*

* Initializes one or more #GDate structs to a safe but invalid

* state. The cleared dates will not represent an existing date, but will

* not contain garbage. Useful to init a date declared on the stack.

* Validity can be tested with g_date_valid().

*/

void

g_date_clear (GDate *d, guint ndates)

{

g_return_if_fail (d != NULL);

g_return_if_fail (ndates != 0);

memset (d, 0x0, ndates*sizeof (GDate));

}

G_LOCK_DEFINE_STATIC (g_date_global);

/* These are for the parser, output to the user should use *

* g_date_strftime () - this creates more never-freed memory to annoy

* all those memory debugger users. :-)

*/

static gchar *long_month_names[13] =

{

NULL,

};

static gchar *long_month_names_alternative[13] =

{

NULL,

};

static gchar *short_month_names[13] =

{

NULL,

};

static gchar *short_month_names_alternative[13] =

{

NULL,

};

/* This tells us if we need to update the parse info */

static gchar *current_locale = NULL;

/* order of these in the current locale */

static GDateDMY dmy_order[3] =

{

G_DATE_DAY, G_DATE_MONTH, G_DATE_YEAR

};

/* Where to chop two-digit years: i.e., for the 1930 default, numbers

* 29 and below are counted as in the year 2000, numbers 30 and above

* are counted as in the year 1900.

*/

static const GDateYear twodigit_start_year = 1930;

/* It is impossible to enter a year between 1 AD and 99 AD with this

* in effect.

*/

static gboolean using_twodigit_years = FALSE;

/* Adjustment of locale era to AD, non-zero means using locale era

*/

static gint locale_era_adjust = 0;

struct _GDateParseTokens {

gint num_ints;

gint n[3];

guint month;

};

typedef struct _GDateParseTokens GDateParseTokens;

static inline gboolean

update_month_match (gsize *longest,

const gchar *haystack,

const gchar *needle)

{

gsize length;

if (needle == NULL)

return FALSE;

length = strlen (needle);

if (*longest >= length)

return FALSE;

if (strstr (haystack, needle) == NULL)

return FALSE;

*longest = length;

return TRUE;

}

#define NUM_LEN 10

/* HOLDS: g_date_global_lock */

static void

g_date_fill_parse_tokens (const gchar *str, GDateParseTokens *pt)

{

gchar num[4][NUM_LEN+1];

gint i;

const guchar *s;

/* We count 4, but store 3; so we can give an error

* if there are 4.

*/

num[0][0] = num[1][0] = num[2][0] = num[3][0] = '\0';

s = (const guchar *) str;

pt->num_ints = 0;

while (*s && pt->num_ints < 4)

{

i = 0;

while (*s && g_ascii_isdigit (*s) && i < NUM_LEN)

{

num[pt->num_ints][i] = *s;

++s;

++i;