~drizzle-trunk/drizzle/development

/* Copyright (C) 2004 MySQL AB

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; version 2 of the License.

   This program 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 General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/*

   Most of the following code and structures were derived from

   public domain code from ftp://elsie.nci.nih.gov/pub

   (We will refer to this code as to elsie-code further.)

*/

/*

  We should not include mysql_priv.h in mysql_tzinfo_to_sql utility since

  it creates unsolved link dependencies on some platforms.

*/

#ifdef USE_PRAGMA_IMPLEMENTATION

#pragma implementation				// gcc: Class implementation

#endif

#include <my_global.h>

#if !defined(TZINFO2SQL) && !defined(TESTTIME)

#include "mysql_priv.h"

#else

#include <my_time.h>

#include "tztime.h"

#include <my_sys.h>

#endif

#include "tzfile.h"

#include <m_string.h>

#include <my_dir.h>

/*

  Now we don't use abbreviations in server but we will do this in future.

*/

#if defined(TZINFO2SQL) || defined(TESTTIME)

#define ABBR_ARE_USED

#else

#if !defined(DBUG_OFF)

/* Let use abbreviations for debug purposes */

#undef ABBR_ARE_USED

#define ABBR_ARE_USED

#endif /* !defined(DBUG_OFF) */

#endif /* defined(TZINFO2SQL) || defined(TESTTIME) */

/* Structure describing local time type (e.g. Moscow summer time (MSD)) */

typedef struct ttinfo

{

  long tt_gmtoff; // Offset from UTC in seconds

  uint tt_isdst;   // Is daylight saving time or not. Used to set tm_isdst

#ifdef ABBR_ARE_USED

  uint tt_abbrind; // Index of start of abbreviation for this time type.

#endif

  /*

    We don't use tt_ttisstd and tt_ttisgmt members of original elsie-code

    struct since we don't support POSIX-style TZ descriptions in variables.

  */

} TRAN_TYPE_INFO;

/* Structure describing leap-second corrections. */

typedef struct lsinfo

{

  my_time_t ls_trans; // Transition time

  long      ls_corr;  // Correction to apply

} LS_INFO;

/*

  Structure with information describing ranges of my_time_t shifted to local

  time (my_time_t + offset). Used for local MYSQL_TIME -> my_time_t conversion.

  See comments for TIME_to_gmt_sec() for more info.

*/

typedef struct revtinfo

{

  long rt_offset; // Offset of local time from UTC in seconds

  uint rt_type;    // Type of period 0 - Normal period. 1 - Spring time-gap

} REVT_INFO;

#ifdef TZNAME_MAX

#define MY_TZNAME_MAX	TZNAME_MAX

#endif

#ifndef TZNAME_MAX

#define MY_TZNAME_MAX	255

#endif

/*

  Structure which fully describes time zone which is

  described in our db or in zoneinfo files.

*/

typedef struct st_time_zone_info

{

  uint leapcnt;  // Number of leap-second corrections

  uint timecnt;  // Number of transitions between time types

  uint typecnt;  // Number of local time types

  uint charcnt;  // Number of characters used for abbreviations

  uint revcnt;   // Number of transition descr. for TIME->my_time_t conversion

  /* The following are dynamical arrays are allocated in MEM_ROOT */

  my_time_t *ats;       // Times of transitions between time types

  uchar	*types; // Local time types for transitions

  TRAN_TYPE_INFO *ttis; // Local time types descriptions

#ifdef ABBR_ARE_USED

  /* Storage for local time types abbreviations. They are stored as ASCIIZ */

  char *chars;

#endif

  /*

    Leap seconds corrections descriptions, this array is shared by

    all time zones who use leap seconds.

  */

  LS_INFO *lsis;

  /*

    Starting points and descriptions of shifted my_time_t (my_time_t + offset)

    ranges on which shifted my_time_t -> my_time_t mapping is linear or undefined.

    Used for tm -> my_time_t conversion.

  */

  my_time_t *revts;

  REVT_INFO *revtis;

  /*

    Time type which is used for times smaller than first transition or if

    there are no transitions at all.

  */

  TRAN_TYPE_INFO *fallback_tti;

} TIME_ZONE_INFO;

static my_bool prepare_tz_info(TIME_ZONE_INFO *sp, MEM_ROOT *storage);

#if defined(TZINFO2SQL) || defined(TESTTIME)

/*

  Load time zone description from zoneinfo (TZinfo) file.

  SYNOPSIS

    tz_load()

      name - path to zoneinfo file

      sp   - TIME_ZONE_INFO structure to fill

  RETURN VALUES

    0 - Ok

    1 - Error

*/

static my_bool

tz_load(const char *name, TIME_ZONE_INFO *sp, MEM_ROOT *storage)

{

  uchar *p;

  int read_from_file;

  uint i;

  FILE *file;

  if (!(file= my_fopen(name, O_RDONLY|O_BINARY, MYF(MY_WME))))

    return 1;

  {

    union

    {

      struct tzhead tzhead;

      uchar buf[sizeof(struct tzhead) + sizeof(my_time_t) * TZ_MAX_TIMES +

                TZ_MAX_TIMES + sizeof(TRAN_TYPE_INFO) * TZ_MAX_TYPES +

#ifdef ABBR_ARE_USED

               max(TZ_MAX_CHARS + 1, (2 * (MY_TZNAME_MAX + 1))) +

#endif

               sizeof(LS_INFO) * TZ_MAX_LEAPS];

    } u;

    uint ttisstdcnt;

    uint ttisgmtcnt;

    char *tzinfo_buf;

    read_from_file= my_fread(file, u.buf, sizeof(u.buf), MYF(MY_WME));

    if (my_fclose(file, MYF(MY_WME)) != 0)

      return 1;

    if (read_from_file < (int)sizeof(struct tzhead))

      return 1;

    ttisstdcnt= int4net(u.tzhead.tzh_ttisgmtcnt);

    ttisgmtcnt= int4net(u.tzhead.tzh_ttisstdcnt);

    sp->leapcnt= int4net(u.tzhead.tzh_leapcnt);

    sp->timecnt= int4net(u.tzhead.tzh_timecnt);

    sp->typecnt= int4net(u.tzhead.tzh_typecnt);

    sp->charcnt= int4net(u.tzhead.tzh_charcnt);

    p= u.tzhead.tzh_charcnt + sizeof(u.tzhead.tzh_charcnt);

    if (sp->leapcnt > TZ_MAX_LEAPS ||

        sp->typecnt == 0 || sp->typecnt > TZ_MAX_TYPES ||

        sp->timecnt > TZ_MAX_TIMES ||

        sp->charcnt > TZ_MAX_CHARS ||

        (ttisstdcnt != sp->typecnt && ttisstdcnt != 0) ||

        (ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0))

      return 1;

    if ((uint)(read_from_file - (p - u.buf)) <

        sp->timecnt * 4 +                       /* ats */

        sp->timecnt +                           /* types */

        sp->typecnt * (4 + 2) +                 /* ttinfos */

        sp->charcnt +                           /* chars */

        sp->leapcnt * (4 + 4) +                 /* lsinfos */

        ttisstdcnt +                            /* ttisstds */

        ttisgmtcnt)                             /* ttisgmts */

      return 1;

    if (!(tzinfo_buf= (char *)alloc_root(storage,

                                         ALIGN_SIZE(sp->timecnt *

                                                    sizeof(my_time_t)) +

                                         ALIGN_SIZE(sp->timecnt) +

                                         ALIGN_SIZE(sp->typecnt *

                                                    sizeof(TRAN_TYPE_INFO)) +

#ifdef ABBR_ARE_USED

                                         ALIGN_SIZE(sp->charcnt) +

#endif

                                         sp->leapcnt * sizeof(LS_INFO))))

      return 1;

    sp->ats= (my_time_t *)tzinfo_buf;

    tzinfo_buf+= ALIGN_SIZE(sp->timecnt * sizeof(my_time_t));

    sp->types= (uchar *)tzinfo_buf;

    tzinfo_buf+= ALIGN_SIZE(sp->timecnt);

    sp->ttis= (TRAN_TYPE_INFO *)tzinfo_buf;

    tzinfo_buf+= ALIGN_SIZE(sp->typecnt * sizeof(TRAN_TYPE_INFO));

#ifdef ABBR_ARE_USED

    sp->chars= tzinfo_buf;

    tzinfo_buf+= ALIGN_SIZE(sp->charcnt);

#endif

    sp->lsis= (LS_INFO *)tzinfo_buf;

    for (i= 0; i < sp->timecnt; i++, p+= 4)

      sp->ats[i]= int4net(p);

    for (i= 0; i < sp->timecnt; i++)

    {

      sp->types[i]= (uchar) *p++;

      if (sp->types[i] >= sp->typecnt)

        return 1;

    }

    for (i= 0; i < sp->typecnt; i++)

    {

      TRAN_TYPE_INFO * ttisp;

      ttisp= &sp->ttis[i];

      ttisp->tt_gmtoff= int4net(p);

      p+= 4;

      ttisp->tt_isdst= (uchar) *p++;

      if (ttisp->tt_isdst != 0 && ttisp->tt_isdst != 1)

        return 1;

      ttisp->tt_abbrind= (uchar) *p++;

      if (ttisp->tt_abbrind > sp->charcnt)

        return 1;

    }

    for (i= 0; i < sp->charcnt; i++)

      sp->chars[i]= *p++;

    sp->chars[i]= '\0';	/* ensure '\0' at end */

    for (i= 0; i < sp->leapcnt; i++)

    {

      LS_INFO *lsisp;

      lsisp= &sp->lsis[i];

      lsisp->ls_trans= int4net(p);

      p+= 4;

      lsisp->ls_corr= int4net(p);

      p+= 4;

    }

    /*

      Since we don't support POSIX style TZ definitions in variables we

      don't read further like glibc or elsie code.

    */

  }

  return prepare_tz_info(sp, storage);

}

#endif /* defined(TZINFO2SQL) || defined(TESTTIME) */

/*

  Finish preparation of time zone description for use in TIME_to_gmt_sec()

  and gmt_sec_to_TIME() functions.

  SYNOPSIS

    prepare_tz_info()

      sp - pointer to time zone description

      storage - pointer to MEM_ROOT where arrays for map allocated

  DESCRIPTION

    First task of this function is to find fallback time type which will

    be used if there are no transitions or we have moment in time before

    any transitions.

    Second task is to build "shifted my_time_t" -> my_time_t map used in

    MYSQL_TIME -> my_time_t conversion.

    Note: See description of TIME_to_gmt_sec() function first.

    In order to perform MYSQL_TIME -> my_time_t conversion we need to build table

    which defines "shifted by tz offset and leap seconds my_time_t" ->

    my_time_t function wich is almost the same (except ranges of ambiguity)

    as reverse function to piecewise linear function used for my_time_t ->

    "shifted my_time_t" conversion and which is also specified as table in

    zoneinfo file or in our db (It is specified as start of time type ranges

    and time type offsets). So basic idea is very simple - let us iterate

    through my_time_t space from one point of discontinuity of my_time_t ->

    "shifted my_time_t" function to another and build our approximation of

    reverse function. (Actually we iterate through ranges on which

    my_time_t -> "shifted my_time_t" is linear function).

  RETURN VALUES

    0	Ok

    1	Error

*/

static my_bool

prepare_tz_info(TIME_ZONE_INFO *sp, MEM_ROOT *storage)

{

  my_time_t cur_t= MY_TIME_T_MIN;

  my_time_t cur_l, end_t, end_l;

  my_time_t cur_max_seen_l= MY_TIME_T_MIN;

  long cur_offset, cur_corr, cur_off_and_corr;

  uint next_trans_idx, next_leap_idx;

  uint i;

  /*

    Temporary arrays where we will store tables. Needed because

    we don't know table sizes ahead. (Well we can estimate their

    upper bound but this will take extra space.)

  */

  my_time_t revts[TZ_MAX_REV_RANGES];

  REVT_INFO revtis[TZ_MAX_REV_RANGES];

  /*

    Let us setup fallback time type which will be used if we have not any

    transitions or if we have moment of time before first transition.

    We will find first non-DST local time type and use it (or use first

    local time type if all of them are DST types).

  */

  for (i= 0; i < sp->typecnt && sp->ttis[i].tt_isdst; i++)

    /* no-op */ ;

  if (i == sp->typecnt)

    i= 0;

  sp->fallback_tti= &(sp->ttis[i]);

  /*

    Let us build shifted my_time_t -> my_time_t map.

  */

  sp->revcnt= 0;

  /* Let us find initial offset */

  if (sp->timecnt == 0 || cur_t < sp->ats[0])

  {

    /*

      If we have not any transitions or t is before first transition we are using

      already found fallback time type which index is already in i.

    */

    next_trans_idx= 0;

  }

  else

  {

    /* cur_t == sp->ats[0] so we found transition */

    i= sp->types[0];

    next_trans_idx= 1;

  }

  cur_offset= sp->ttis[i].tt_gmtoff;

  /* let us find leap correction... unprobable, but... */

  for (next_leap_idx= 0; next_leap_idx < sp->leapcnt &&

         cur_t >= sp->lsis[next_leap_idx].ls_trans;

         ++next_leap_idx)

    continue;

  if (next_leap_idx > 0)

    cur_corr= sp->lsis[next_leap_idx - 1].ls_corr;

  else

    cur_corr= 0;

  /* Iterate trough t space */

  while (sp->revcnt < TZ_MAX_REV_RANGES - 1)

  {

    cur_off_and_corr= cur_offset - cur_corr;

    /*

      We assuming that cur_t could be only overflowed downwards,

      we also assume that end_t won't be overflowed in this case.

    */

    if (cur_off_and_corr < 0 &&

        cur_t < MY_TIME_T_MIN - cur_off_and_corr)

      cur_t= MY_TIME_T_MIN - cur_off_and_corr;

    cur_l= cur_t + cur_off_and_corr;

    /*

      Let us choose end_t as point before next time type change or leap

      second correction.

    */

    end_t= min((next_trans_idx < sp->timecnt) ? sp->ats[next_trans_idx] - 1:

                                                MY_TIME_T_MAX,

               (next_leap_idx < sp->leapcnt) ?

                 sp->lsis[next_leap_idx].ls_trans - 1: MY_TIME_T_MAX);

    /*

      again assuming that end_t can be overlowed only in positive side

      we also assume that end_t won't be overflowed in this case.

    */

    if (cur_off_and_corr > 0 &&

        end_t > MY_TIME_T_MAX - cur_off_and_corr)

      end_t= MY_TIME_T_MAX - cur_off_and_corr;

    end_l= end_t + cur_off_and_corr;

    if (end_l > cur_max_seen_l)

    {

      /* We want special handling in the case of first range */

      if (cur_max_seen_l == MY_TIME_T_MIN)

      {

        revts[sp->revcnt]= cur_l;

        revtis[sp->revcnt].rt_offset= cur_off_and_corr;

        revtis[sp->revcnt].rt_type= 0;

        sp->revcnt++;

        cur_max_seen_l= end_l;

      }

      else

      {

        if (cur_l > cur_max_seen_l + 1)

        {

          /* We have a spring time-gap and we are not at the first range */

          revts[sp->revcnt]= cur_max_seen_l + 1;

          revtis[sp->revcnt].rt_offset= revtis[sp->revcnt-1].rt_offset;

          revtis[sp->revcnt].rt_type= 1;

          sp->revcnt++;

          if (sp->revcnt == TZ_MAX_TIMES + TZ_MAX_LEAPS + 1)

            break; /* That was too much */

          cur_max_seen_l= cur_l - 1;

        }

        /* Assume here end_l > cur_max_seen_l (because end_l>=cur_l) */

        revts[sp->revcnt]= cur_max_seen_l + 1;

        revtis[sp->revcnt].rt_offset= cur_off_and_corr;

        revtis[sp->revcnt].rt_type= 0;

        sp->revcnt++;

        cur_max_seen_l= end_l;

      }

    }

    if (end_t == MY_TIME_T_MAX ||

        (cur_off_and_corr > 0) &&

        (end_t >= MY_TIME_T_MAX - cur_off_and_corr))

      /* end of t space */

      break;

    cur_t= end_t + 1;

    /*

      Let us find new offset and correction. Because of our choice of end_t

      cur_t can only be point where new time type starts or/and leap

      correction is performed.

    */

    if (sp->timecnt != 0 && cur_t >= sp->ats[0]) /* else reuse old offset */

      if (next_trans_idx < sp->timecnt &&

          cur_t == sp->ats[next_trans_idx])

      {

        /* We are at offset point */

        cur_offset= sp->ttis[sp->types[next_trans_idx]].tt_gmtoff;

        ++next_trans_idx;

      }

    if (next_leap_idx < sp->leapcnt &&

        cur_t == sp->lsis[next_leap_idx].ls_trans)

    {

      /* we are at leap point */

      cur_corr= sp->lsis[next_leap_idx].ls_corr;

      ++next_leap_idx;

    }

  }

  /* check if we have had enough space */

  if (sp->revcnt == TZ_MAX_REV_RANGES - 1)

    return 1;

  /* set maximum end_l as finisher */

  revts[sp->revcnt]= end_l;

  /* Allocate arrays of proper size in sp and copy result there */

  if (!(sp->revts= (my_time_t *)alloc_root(storage,

                                  sizeof(my_time_t) * (sp->revcnt + 1))) ||

      !(sp->revtis= (REVT_INFO *)alloc_root(storage,

                                  sizeof(REVT_INFO) * sp->revcnt)))

    return 1;

  memcpy(sp->revts, revts, sizeof(my_time_t) * (sp->revcnt + 1));

  memcpy(sp->revtis, revtis, sizeof(REVT_INFO) * sp->revcnt);

  return 0;

}

#if !defined(TZINFO2SQL)

static const uint mon_lengths[2][MONS_PER_YEAR]=

{

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

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

};

static const uint mon_starts[2][MONS_PER_YEAR]=

{

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

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

};

static const uint year_lengths[2]=

{

  DAYS_PER_NYEAR, DAYS_PER_LYEAR

};

#define LEAPS_THRU_END_OF(y)  ((y) / 4 - (y) / 100 + (y) / 400)

/*

  Converts time from my_time_t representation (seconds in UTC since Epoch)

  to broken down representation using given local time zone offset.

  SYNOPSIS

    sec_to_TIME()

      tmp    - pointer to structure for broken down representation

      t      - my_time_t value to be converted

      offset - local time zone offset

  DESCRIPTION

    Convert my_time_t with offset to MYSQL_TIME struct. Differs from timesub

    (from elsie code) because doesn't contain any leap correction and

    TM_GMTOFF and is_dst setting and contains some MySQL specific

    initialization. Funny but with removing of these we almost have

    glibc's offtime function.

*/

static void

sec_to_TIME(MYSQL_TIME * tmp, my_time_t t, long offset)

{

  long days;

  long rem;

  int y;

  int yleap;

  const uint *ip;

  days= (long) (t / SECS_PER_DAY);

  rem=  (long) (t % SECS_PER_DAY);

  /*

    We do this as separate step after dividing t, because this

    allows us handle times near my_time_t bounds without overflows.

  */

  rem+= offset;

  while (rem < 0)

  {

    rem+= SECS_PER_DAY;

    days--;

  }

  while (rem >= SECS_PER_DAY)

  {

    rem -= SECS_PER_DAY;

    days++;

  }

  tmp->hour= (uint)(rem / SECS_PER_HOUR);

  rem= rem % SECS_PER_HOUR;

  tmp->minute= (uint)(rem / SECS_PER_MIN);

  /*

    A positive leap second requires a special

    representation.  This uses "... ??:59:60" et seq.

  */

  tmp->second= (uint)(rem % SECS_PER_MIN);

  y= EPOCH_YEAR;

  while (days < 0 || days >= (long)year_lengths[yleap= isleap(y)])

  {

    int	newy;

    newy= y + days / DAYS_PER_NYEAR;

    if (days < 0)

      newy--;

    days-= (newy - y) * DAYS_PER_NYEAR +

           LEAPS_THRU_END_OF(newy - 1) -

           LEAPS_THRU_END_OF(y - 1);

    y= newy;

  }

  tmp->year= y;

  ip= mon_lengths[yleap];

  for (tmp->month= 0; days >= (long) ip[tmp->month]; tmp->month++)

    days= days - (long) ip[tmp->month];

  tmp->month++;

  tmp->day= (uint)(days + 1);

  /* filling MySQL specific MYSQL_TIME members */

  tmp->neg= 0; tmp->second_part= 0;

  tmp->time_type= MYSQL_TIMESTAMP_DATETIME;

}

/*

  Find time range wich contains given my_time_t value

  SYNOPSIS

    find_time_range()

      t                - my_time_t value for which we looking for range

      range_boundaries - sorted array of range starts.

      higher_bound     - number of ranges

  DESCRIPTION

    Performs binary search for range which contains given my_time_t value.

    It has sense if number of ranges is greater than zero and my_time_t value

    is greater or equal than beginning of first range. It also assumes that

    t belongs to some range specified or end of last is MY_TIME_T_MAX.

    With this localtime_r on real data may takes less time than with linear

    search (I've seen 30% speed up).

  RETURN VALUE

    Index of range to which t belongs

*/

static uint

find_time_range(my_time_t t, const my_time_t *range_boundaries,

                uint higher_bound)

{

  uint i, lower_bound= 0;

  /*

    Function will work without this assertion but result would be meaningless.

  */

  DBUG_ASSERT(higher_bound > 0 && t >= range_boundaries[0]);

  /*

    Do binary search for minimal interval which contain t. We preserve:

    range_boundaries[lower_bound] <= t < range_boundaries[higher_bound]

    invariant and decrease this higher_bound - lower_bound gap twice

    times on each step.

  */

  while (higher_bound - lower_bound > 1)

  {

    i= (lower_bound + higher_bound) >> 1;

    if (range_boundaries[i] <= t)

      lower_bound= i;

    else

      higher_bound= i;

  }

  return lower_bound;

}

/*

  Find local time transition for given my_time_t.

  SYNOPSIS

    find_transition_type()

      t   - my_time_t value to be converted

      sp  - pointer to struct with time zone description

  RETURN VALUE

    Pointer to structure in time zone description describing

    local time type for given my_time_t.

*/

static

const TRAN_TYPE_INFO *

find_transition_type(my_time_t t, const TIME_ZONE_INFO *sp)

{

  if (unlikely(sp->timecnt == 0 || t < sp->ats[0]))

  {

    /*

      If we have not any transitions or t is before first transition let

      us use fallback time type.

    */

    return sp->fallback_tti;

  }

  /*

    Do binary search for minimal interval between transitions which

    contain t. With this localtime_r on real data may takes less

    time than with linear search (I've seen 30% speed up).

  */

  return &(sp->ttis[sp->types[find_time_range(t, sp->ats, sp->timecnt)]]);

}

/*

  Converts time in my_time_t representation (seconds in UTC since Epoch) to

  broken down MYSQL_TIME representation in local time zone.

  SYNOPSIS

    gmt_sec_to_TIME()

      tmp          - pointer to structure for broken down represenatation

      sec_in_utc   - my_time_t value to be converted

      sp           - pointer to struct with time zone description

  TODO

    We can improve this function by creating joined array of transitions and

    leap corrections. This will require adding extra field to TRAN_TYPE_INFO

    for storing number of "extra" seconds to minute occured due to correction

    (60th and 61st second, look how we calculate them as "hit" in this

    function).

    Under realistic assumptions about frequency of transitions the same array

    can be used fot MYSQL_TIME -> my_time_t conversion. For this we need to

    implement tweaked binary search which will take into account that some

    MYSQL_TIME has two matching my_time_t ranges and some of them have none.

*/

static void

gmt_sec_to_TIME(MYSQL_TIME *tmp, my_time_t sec_in_utc, const TIME_ZONE_INFO *sp)

{

  const TRAN_TYPE_INFO *ttisp;

  const LS_INFO *lp;

  long  corr= 0;

  int   hit= 0;

  int   i;

  /*

    Find proper transition (and its local time type) for our sec_in_utc value.

    Funny but again by separating this step in function we receive code

    which very close to glibc's code. No wonder since they obviously use

    the same base and all steps are sensible.

  */

  ttisp= find_transition_type(sec_in_utc, sp);

  /*

    Let us find leap correction for our sec_in_utc value and number of extra

    secs to add to this minute.

    This loop is rarely used because most users will use time zones without

    leap seconds, and even in case when we have such time zone there won't

    be many iterations (we have about 22 corrections at this moment (2004)).

  */

  for ( i= sp->leapcnt; i-- > 0; )

  {

    lp= &sp->lsis[i];

    if (sec_in_utc >= lp->ls_trans)

    {

      if (sec_in_utc == lp->ls_trans)

      {

        hit= ((i == 0 && lp->ls_corr > 0) ||

              lp->ls_corr > sp->lsis[i - 1].ls_corr);

        if (hit)

        {

          while (i > 0 &&

                 sp->lsis[i].ls_trans == sp->lsis[i - 1].ls_trans + 1 &&

                 sp->lsis[i].ls_corr == sp->lsis[i - 1].ls_corr + 1)

          {

            hit++;

            i--;

          }

        }

      }

      corr= lp->ls_corr;

      break;

    }

  }

  sec_to_TIME(tmp, sec_in_utc, ttisp->tt_gmtoff - corr);

  tmp->second+= hit;

}

/*

  Converts local time in broken down representation to local

  time zone analog of my_time_t represenation.

  SYNOPSIS

    sec_since_epoch()

      year, mon, mday, hour, min, sec - broken down representation.

  DESCRIPTION

    Converts time in broken down representation to my_time_t representation

    ignoring time zone. Note that we cannot convert back some valid _local_

    times near ends of my_time_t range because of my_time_t  overflow. But we

    ignore this fact now since MySQL will never pass such argument.

  RETURN VALUE

    Seconds since epoch time representation.

*/

static my_time_t

sec_since_epoch(int year, int mon, int mday, int hour, int min ,int sec)

{

  /* Guard against my_time_t overflow(on system with 32 bit my_time_t) */

  DBUG_ASSERT(!(year == TIMESTAMP_MAX_YEAR && mon == 1 && mday > 17));

#ifndef WE_WANT_TO_HANDLE_UNORMALIZED_DATES

  /*

    It turns out that only whenever month is normalized or unnormalized

    plays role.

  */

  DBUG_ASSERT(mon > 0 && mon < 13);

  long days= year * DAYS_PER_NYEAR - EPOCH_YEAR * DAYS_PER_NYEAR +

             LEAPS_THRU_END_OF(year - 1) -

             LEAPS_THRU_END_OF(EPOCH_YEAR - 1);

  days+= mon_starts[isleap(year)][mon - 1];

#else

  long norm_month= (mon - 1) % MONS_PER_YEAR;

  long a_year= year + (mon - 1)/MONS_PER_YEAR - (int)(norm_month < 0);

  long days= a_year * DAYS_PER_NYEAR - EPOCH_YEAR * DAYS_PER_NYEAR +

             LEAPS_THRU_END_OF(a_year - 1) -

             LEAPS_THRU_END_OF(EPOCH_YEAR - 1);

  days+= mon_starts[isleap(a_year)]

                    [norm_month + (norm_month < 0 ? MONS_PER_YEAR : 0)];

#endif

  days+= mday - 1;

  return ((days * HOURS_PER_DAY + hour) * MINS_PER_HOUR + min) *

         SECS_PER_MIN + sec;

}

/*

  Converts local time in broken down MYSQL_TIME representation to my_time_t

  representation.

  SYNOPSIS

    TIME_to_gmt_sec()

      t               - pointer to structure for broken down represenatation

      sp              - pointer to struct with time zone description

      in_dst_time_gap - pointer to bool which is set to true if datetime

                        value passed doesn't really exist (i.e. falls into

                        spring time-gap) and is not touched otherwise.

  DESCRIPTION

    This is mktime analog for MySQL. It is essentially different

    from mktime (or hypotetical my_mktime) because:

    - It has no idea about tm_isdst member so if it

      has two answers it will give the smaller one

    - If we are in spring time gap then it will return

      beginning of the gap

    - It can give wrong results near the ends of my_time_t due to

      overflows, but we are safe since in MySQL we will never

      call this function for such dates (its restriction for year

      between 1970 and 2038 gives us several days of reserve).

    - By default it doesn't support un-normalized input. But if

      sec_since_epoch() function supports un-normalized dates

      then this function should handle un-normalized input right,

      altough it won't normalize structure TIME.

    Traditional approach to problem of conversion from broken down

    representation to time_t is iterative. Both elsie's and glibc