/* GLIB - Library of useful routines for C programming

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

 *

 * 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 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, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * 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"

#ifdef G_OS_WIN32

#include "garray.h"

#endif

/**

 * SECTION:date

 * @title: Date and Time Functions

 * @short_description: calendrical calculations and miscellaneous time stuff

 *

 * 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 g_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 <emphasis>day</emphasis>.

 *

 * 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 g_date_new(), or you can declare an

 * automatic variable or array and initialize it to a sane state by

 * calling g_date_clear(). A cleared date is sane; it's safe to call

 * g_date_set_dmy() and the other mutator functions to initialize the

 * value of a cleared date. However, a cleared date is initially

 * <emphasis>invalid</emphasis>, 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

 * g_date_valid() predicate. g_date_valid() is also used to check for

 * errors with g_date_set_parse() and other functions that can

 * fail. Dates can be invalidated by calling g_date_clear() again.

 *

 * <emphasis>It is very important to use the API to access the #GDate

 * struct.</emphasis> 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.

 */

/**

 * GTimeVal:

 * @tv_sec: seconds

 * @tv_usec: microseconds

 *

 * Represents a precise time, with seconds and microseconds.

 * Similar to the <structname>struct timeval</structname> returned by

 * the gettimeofday() UNIX system call.

 *

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

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

 * removed from a future version of GLib.

 */

/**

 * 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 day of the day-month-year representation of the date,

 *     as a number between 1 and 12

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

 *

 * Represents a day between January 1, Year 1 and a few thousand years in

 * the future. None of its members should be accessed directly. If the

 * <structname>GDate</structname> is obtained from g_date_new(), it will

 * be safe to mutate but invalid and thus not safe for calendrical

 * computations. If it's declared on the stack, it will contain garbage

 * so must be initialized with g_date_clear(). g_date_clear() makes the

 * date invalid but sane. An invalid date doesn't represent a day, it's

 * "empty." A date becomes valid after you set it to a Julian day or you

 * set a day, month, and year.

 */

/**

 * GTime:

 *

 * Simply a replacement for <type>time_t</type>. It has been deprecated

 * since it is <emphasis>not</emphasis> equivalent to <type>time_t</type>

 * on 64-bit platforms with a 64-bit <type>time_t</type>.

 * Unrelated to #GTimer.

 *

 * Note that <type>GTime</type> is defined to always be a 32bit integer,

 * unlike <type>time_t</type> which may be 64bit on some systems.

 * Therefore, <type>GTime</type> will overflow in the year 2038, and

 * you cannot use the address of a <type>GTime</type> variable as argument

 * to the UNIX time() function. Instead, do the following:

 * |[

 * time_t ttime;

 * GTime gtime;

 *

 * time (&ttime);

 * gtime = (GTime)ttime;

 * ]|

 */

/**

 * 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. #G_DATE_BAD_DAY 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 representing a year; #G_DATE_BAD_YEAR is the invalid

 * value. The year must be 1 or higher; negative (BC) 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 sane 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

 *

 * Like g_date_new(), but also sets the value of the date. Assuming the

 * day-month-year triplet you pass in represents an existing day, the

 * returned date will be valid.

 *

 * Returns: 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

 *

 * Like g_date_new(), but also sets the value of the date. Assuming the

 * Julian day number you pass in is valid (greater than 0, less than an

 * unreasonably large number), the returned date will be valid.

 *

 * Returns: 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_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 ( (m > G_DATE_BAD_MONTH) && (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 ( (w > G_DATE_BAD_WEEKDAY) && (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)

{

  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);

  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 ("\nOOPS julian: %u  computed dmy: %u %u %u\n", 

	       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 *d)

{

  GDateWeekday wd;

  guint day;

  GDate first;

  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);  

  g_date_clear (&first, 1);

  g_date_set_dmy (&first, 1, 1, d->year);

  wd = g_date_get_weekday (&first) - 1; /* make Monday day 0 */

  day = g_date_get_day_of_year (d) - 1;

  return ((day + wd)/7U + (wd == 0 ? 1 : 0));

}

/**

 * 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 being 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 *d)

{

  GDateWeekday wd;

  guint day;

  GDate first;

  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);  

  g_date_clear (&first, 1);

  g_date_set_dmy (&first, 1, 1, d->year);

  wd = g_date_get_weekday (&first);

  if (wd == 7) wd = 0; /* make Sunday day 0 */

  day = g_date_get_day_of_year (d) - 1;

  return ((day + wd)/7U + (wd == 0 ? 1 : 0));

}

/**

 * 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 sane 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 *short_month_names[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;