Skip navigation links

 Systems for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Downloads
• Documentation
• Articles
• Forums
• Bugs
• Forge
• Blogs

 

---

Learn about new MySQL releases, technical articles, events and more.

Subscribe Now »

mysql/src/5.1-dbg/sql/tztime.cc File Reference

#include <my_global.h>
#include "mysql_priv.h"
#include "tzfile.h"
#include <m_string.h>
#include <my_dir.h>

Include dependency graph for tztime.cc:

Go to the source code of this file.

Classes
struct	ttinfo
struct	lsinfo
struct	revtinfo
struct	st_time_zone_info
class	Time_zone_system
class	Time_zone_utc
class	Time_zone_db
class	Time_zone_offset
class	Tz_names_entry
Defines
#define	ABBR_ARE_USED
#define	MY_TZNAME_MAX   255
#define	LEAPS_THRU_END_OF(y)   ((y) / 4 - (y) / 100 + (y) / 400)
Typedefs
typedef ttinfo	TRAN_TYPE_INFO
typedef lsinfo	LS_INFO
typedef revtinfo	REVT_INFO
typedef st_time_zone_info	TIME_ZONE_INFO
Functions
static my_bool	prepare_tz_info (TIME_ZONE_INFO *sp, MEM_ROOT *storage)
static void	sec_to_TIME (TIME *tmp, my_time_t t, long offset)
static uint	find_time_range (my_time_t t, const my_time_t *range_boundaries, uint higher_bound)
static const TRAN_TYPE_INFO *	find_transition_type (my_time_t t, const TIME_ZONE_INFO *sp)
static void	gmt_sec_to_TIME (TIME *tmp, my_time_t sec_in_utc, const TIME_ZONE_INFO *sp)
static my_time_t	sec_since_epoch (int year, int mon, int mday, int hour, int min, int sec)
my_time_t	sec_since_epoch_TIME (TIME *t)
static my_time_t	TIME_to_gmt_sec (const TIME *t, const TIME_ZONE_INFO *sp, my_bool *in_dst_time_gap)
byte *	my_tz_names_get_key (Tz_names_entry *entry, uint *length, my_bool not_used __attribute__((unused)))
byte *	my_offset_tzs_get_key (Time_zone_offset *entry, uint *length, my_bool not_used __attribute__((unused)))
static void	tz_init_table_list (TABLE_LIST *tz_tabs, TABLE_LIST ***global_next_ptr)
TABLE_LIST *	my_tz_get_table_list (THD *thd, TABLE_LIST ***global_next_ptr)
my_bool	my_tz_init (THD *org_thd, const char *default_tzname, my_bool bootstrap)
void	my_tz_free ()
static Time_zone *	tz_load_from_open_tables (const String *tz_name, TABLE_LIST *tz_tables)
my_bool	str_to_offset (const char *str, uint length, long *offset)
Time_zone *	my_tz_find (const String *name, TABLE_LIST *tz_tables)
Time_zone *	my_tz_find_with_opening_tz_tables (THD *thd, const String *name)
Variables
static const uint	mon_lengths [2][MONS_PER_YEAR]
static const uint	mon_starts [2][MONS_PER_YEAR]
static const uint	year_lengths [2]
static const String	tz_SYSTEM_name ("SYSTEM", 6,&my_charset_latin1)
static Time_zone_utc	tz_UTC
static Time_zone_system	tz_SYSTEM
Time_zone *	my_tz_UTC = &tz_UTC
Time_zone *	my_tz_SYSTEM = &tz_SYSTEM
static HASH	tz_names
static HASH	offset_tzs
static MEM_ROOT	tz_storage
static pthread_mutex_t	tz_LOCK
static bool	tz_inited = 0
static uint	tz_leapcnt = 0
static LS_INFO *	tz_lsis = 0
static bool	time_zone_tables_exist = 1
static const LEX_STRING	tz_tables_names [MY_TZ_TABLES_COUNT]
static const LEX_STRING	tz_tables_db_name = { C_STRING_WITH_LEN("mysql")}
TABLE_LIST	fake_time_zone_tables_list

---

Define Documentation

#define ABBR_ARE_USED

Definition at line 54 of file tztime.cc.

#define LEAPS_THRU_END_OF

(

y

)

((y) / 4 - (y) / 100 + (y) / 400)

Definition at line 521 of file tztime.cc.

#define MY_TZNAME_MAX   255

Definition at line 94 of file tztime.cc.

---

Typedef Documentation

typedef struct lsinfo LS_INFO

typedef struct revtinfo REVT_INFO

typedef struct st_time_zone_info TIME_ZONE_INFO

typedef struct ttinfo TRAN_TYPE_INFO

---

Function Documentation

static uint find_time_range	(	my_time_t	t,
		const my_time_t *	range_boundaries,
		uint	higher_bound
	)			[static]

Definition at line 626 of file tztime.cc.

References DBUG_ASSERT.

{
  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;
}

static const TRAN_TYPE_INFO* find_transition_type	(	my_time_t	t,
		const TIME_ZONE_INFO *	sp
	)			[static]

Definition at line 668 of file tztime.cc.

References st_time_zone_info::ats, st_time_zone_info::fallback_tti, find_time_range(), st_time_zone_info::timecnt, st_time_zone_info::ttis, st_time_zone_info::types, and unlikely.

{
  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)]]);
}

Here is the call graph for this function:

static void gmt_sec_to_TIME	(	TIME *	tmp,
		my_time_t	sec_in_utc,
		const TIME_ZONE_INFO *	sp
	)			[static]

Definition at line 710 of file tztime.cc.

References find_transition_type(), st_time_zone_info::leapcnt, lsinfo::ls_corr, lsinfo::ls_trans, st_time_zone_info::lsis, sec_to_TIME(), st_mysql_time::second, and ttinfo::tt_gmtoff.

{
  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;
}

Here is the call graph for this function:

byte* my_offset_tzs_get_key	(	Time_zone_offset *	entry,
		uint *	length,
		my_bool not_used	__attribute__((unused))
	)

Definition at line 1423 of file tztime.cc.

{
  *length= sizeof(long);
  return (byte*) &entry->offset;
}

Time_zone* my_tz_find	(	const String *	name,
		TABLE_LIST *	tz_tables
	)

Definition at line 2213 of file tztime.cc.

References current_thd, DBUG_ASSERT, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, hash_search(), my_hash_insert(), name, offset, offset_tzs, pthread_mutex_lock, pthread_mutex_unlock, sql_print_error(), str_to_offset(), Tz_names_entry::tz, tz_load_from_open_tables(), tz_names, tz_storage, and VOID.

{
  Tz_names_entry *tmp_tzname;
  Time_zone *result_tz= 0;
  long offset;
  DBUG_ENTER("my_tz_find");
  DBUG_PRINT("enter", ("time zone name='%s'",
                       name ? ((String *)name)->c_ptr_safe() : "NULL"));
  DBUG_ASSERT(!time_zone_tables_exist || tz_tables ||
              current_thd->slave_thread);

  if (!name)
    DBUG_RETURN(0);

  VOID(pthread_mutex_lock(&tz_LOCK));

  if (!str_to_offset(name->ptr(), name->length(), &offset))
  {

    if (!(result_tz= (Time_zone_offset *)hash_search(&offset_tzs,
                                                     (const byte *)&offset,
                                                     sizeof(long))))
    {
      DBUG_PRINT("info", ("Creating new Time_zone_offset object"));

      if (!(result_tz= new (&tz_storage) Time_zone_offset(offset)) ||
          my_hash_insert(&offset_tzs, (const byte *) result_tz))
      {
        result_tz= 0;
        sql_print_error("Fatal error: Out of memory "
                        "while setting new time zone");
      }
    }
  }
  else
  {
    result_tz= 0;
    if ((tmp_tzname= (Tz_names_entry *)hash_search(&tz_names,
                                                   (const byte *)name->ptr(),
                                                   name->length())))
      result_tz= tmp_tzname->tz;
    else if (time_zone_tables_exist && tz_tables)
      result_tz= tz_load_from_open_tables(name, tz_tables);
  }

  VOID(pthread_mutex_unlock(&tz_LOCK));

  DBUG_RETURN(result_tz);
}

Here is the call graph for this function:

Time_zone* my_tz_find_with_opening_tz_tables	(	THD *	thd,
		const String *	name
	)

Definition at line 2289 of file tztime.cc.

References close_thread_tables(), DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, my_tz_find(), MY_TZ_TABLES_COUNT, name, simple_open_n_lock_tables(), and tz_init_table_list().

{
  Time_zone *tz;
  DBUG_ENTER("my_tz_find_with_opening_tables");
  DBUG_ASSERT(thd);
  DBUG_ASSERT(thd->slave_thread); // intended for use with slave thread only

  if (!(tz= my_tz_find(name, 0)) && time_zone_tables_exist)
  {
    /*
      Probably we have not loaded this time zone yet so let us look it up in
      our time zone tables. Note that if we don't have tz tables on this
      slave, we don't even try.
    */
    TABLE_LIST tables[MY_TZ_TABLES_COUNT];
    TABLE_LIST *dummy;
    TABLE_LIST **dummyp= &dummy;
    tz_init_table_list(tables, &dummyp);
    if (simple_open_n_lock_tables(thd, tables))
      DBUG_RETURN(0);
    tz= my_tz_find(name, tables);
    /* We need to close tables _now_ to not pollute coming query */
    close_thread_tables(thd);
  }
  DBUG_RETURN(tz);
}

Here is the call graph for this function:

void my_tz_free

(

)

Definition at line 1752 of file tztime.cc.

References free_root(), hash_free(), MYF, offset_tzs, pthread_mutex_destroy, tz_names, tz_storage, and VOID.

{
  if (tz_inited)
  {
    tz_inited= 0;
    VOID(pthread_mutex_destroy(&tz_LOCK));
    hash_free(&offset_tzs);
    hash_free(&tz_names);
    free_root(&tz_storage, MYF(0));
  }
}

Here is the call graph for this function:

TABLE_LIST* my_tz_get_table_list	(	THD *	thd,
		TABLE_LIST ***	global_next_ptr
	)

Definition at line 1511 of file tztime.cc.

References DBUG_ENTER, DBUG_RETURN, fake_time_zone_tables_list, MY_TZ_TABLES_COUNT, and tz_init_table_list().

{
  TABLE_LIST *tz_tabs;
  DBUG_ENTER("my_tz_get_table_list");

  if (!time_zone_tables_exist)
    DBUG_RETURN(0);

  if (!(tz_tabs= (TABLE_LIST *)thd->alloc(sizeof(TABLE_LIST) *
                                          MY_TZ_TABLES_COUNT)))
    DBUG_RETURN(&fake_time_zone_tables_list);

  tz_init_table_list(tz_tabs, global_next_ptr);

  DBUG_RETURN(tz_tabs);
}

Here is the call graph for this function:

my_bool my_tz_init	(	THD *	org_thd,
		const char *	default_tzname,
		my_bool	bootstrap
	)

Definition at line 1555 of file tztime.cc.

References alloc_root(), bzero, close_thread_tables(), db, DBUG_ENTER, DBUG_PRINT, DBUG_RETURN, st_table::field, st_table::file, global_system_variables, HA_ERR_END_OF_FILE, handler::ha_index_end(), handler::ha_index_init(), hash_free(), hash_init, handler::index_first(), handler::index_next(), init_alloc_root(), lsinfo::ls_corr, lsinfo::ls_trans, my_charset_latin1, my_hash_insert(), MY_MUTEX_INIT_FAST, my_offset_tzs_get_key(), my_pthread_setspecific_ptr, my_tz_find(), my_tz_free(), my_tz_names_get_key(), my_tz_SYSTEM, MY_TZ_TABLES_COUNT, Tz_names_entry::name, offset_tzs, pthread_mutex_init, st_table::record, String::set(), simple_open_n_lock_tables(), sql_print_error(), sql_print_warning(), STRING_WITH_LEN, system_variables::time_zone, TL_READ, Tz_names_entry::tz, tz_init_table_list(), tz_lsis, TZ_MAX_LEAPS, tz_names, tz_storage, st_table::use_all_columns(), Field::val_int(), and VOID.

{
  THD *thd;
  TABLE_LIST *tables= 0;
  TABLE_LIST tables_buff[1+MY_TZ_TABLES_COUNT], **last_global_next_ptr;
  TABLE *table;
  Tz_names_entry *tmp_tzname;
  my_bool return_val= 1;
  char db[]= "mysql";
  int res;
  DBUG_ENTER("my_tz_init");

  /*
    To be able to run this from boot, we allocate a temporary THD
  */
  if (!(thd= new THD))
    DBUG_RETURN(1);
  thd->thread_stack= (char*) &thd;
  thd->store_globals();

  /* Init all memory structures that require explicit destruction */
  if (hash_init(&tz_names, &my_charset_latin1, 20,
                0, 0, (hash_get_key)my_tz_names_get_key, 0, 0))
  {
    sql_print_error("Fatal error: OOM while initializing time zones");
    goto end;
  }
  if (hash_init(&offset_tzs, &my_charset_latin1, 26, 0, 0,
                (hash_get_key)my_offset_tzs_get_key, 0, 0))
  {
    sql_print_error("Fatal error: OOM while initializing time zones");
    hash_free(&tz_names);
    goto end;
  }
  init_alloc_root(&tz_storage, 32 * 1024, 0);
  VOID(pthread_mutex_init(&tz_LOCK, MY_MUTEX_INIT_FAST));
  tz_inited= 1;

  /* Add 'SYSTEM' time zone to tz_names hash */
  if (!(tmp_tzname= new (&tz_storage) Tz_names_entry()))
  {
    sql_print_error("Fatal error: OOM while initializing time zones");
    goto end_with_cleanup;
  }
  tmp_tzname->name.set(STRING_WITH_LEN("SYSTEM"), &my_charset_latin1);
  tmp_tzname->tz= my_tz_SYSTEM;
  if (my_hash_insert(&tz_names, (const byte *)tmp_tzname))
  {
    sql_print_error("Fatal error: OOM while initializing time zones");
    goto end_with_cleanup;
  }

  if (bootstrap)
  {
    /* If we are in bootstrap mode we should not load time zone tables */
    return_val= time_zone_tables_exist= 0;
    goto end_with_setting_default_tz;
  }

  /*
    After this point all memory structures are inited and we even can live
    without time zone description tables. Now try to load information about
    leap seconds shared by all time zones.
  */

  thd->set_db(db, sizeof(db)-1);
  bzero((char*) &tables_buff, sizeof(TABLE_LIST));
  tables_buff[0].alias= tables_buff[0].table_name=
    (char*)"time_zone_leap_second";
  tables_buff[0].lock_type= TL_READ;
  tables_buff[0].db= db;
  /*
    Fill TABLE_LIST for the rest of the time zone describing tables
    and link it to first one.
  */
  last_global_next_ptr= &(tables_buff[0].next_global);
  tz_init_table_list(tables_buff + 1, &last_global_next_ptr);

  if (simple_open_n_lock_tables(thd, tables_buff))
  {
    sql_print_warning("Can't open and lock time zone table: %s "
                      "trying to live without them", thd->net.last_error);
    /* We will try emulate that everything is ok */
    return_val= time_zone_tables_exist= 0;
    goto end_with_setting_default_tz;
  }
  tables= tables_buff + 1;

  /*
    Now we are going to load leap seconds descriptions that are shared
    between all time zones that use them. We are using index for getting
    records in proper order. Since we share the same MEM_ROOT between
    all time zones we just allocate enough memory for it first.
  */
  if (!(tz_lsis= (LS_INFO*) alloc_root(&tz_storage,
                                       sizeof(LS_INFO) * TZ_MAX_LEAPS)))
  {
    sql_print_error("Fatal error: Out of memory while loading "
                    "mysql.time_zone_leap_second table");
    goto end_with_close;
  }

  table= tables_buff[0].table;
  /*
    It is OK to ignore ha_index_init()/ha_index_end() return values since
    mysql.time_zone* tables are MyISAM and these operations always succeed
    for MyISAM.
  */
  (void)table->file->ha_index_init(0, 1);
  table->use_all_columns();

  tz_leapcnt= 0;

  res= table->file->index_first(table->record[0]);

  while (!res)
  {
    if (tz_leapcnt + 1 > TZ_MAX_LEAPS)
    {
      sql_print_error("Fatal error: While loading mysql.time_zone_leap_second"
                      " table: too much leaps");
      table->file->ha_index_end();
      goto end_with_close;
    }

    tz_lsis[tz_leapcnt].ls_trans= (my_time_t)table->field[0]->val_int();
    tz_lsis[tz_leapcnt].ls_corr= (long)table->field[1]->val_int();

    tz_leapcnt++;

    DBUG_PRINT("info",
      ("time_zone_leap_second table: tz_leapcnt=%u tt_time=%lld offset=%ld",
       tz_leapcnt, (longlong)tz_lsis[tz_leapcnt-1].ls_trans,
       tz_lsis[tz_leapcnt-1].ls_corr));

    res= table->file->index_next(table->record[0]);
  }

  (void)table->file->ha_index_end();

  if (res != HA_ERR_END_OF_FILE)
  {
    sql_print_error("Fatal error: Error while loading "
                    "mysql.time_zone_leap_second table");
    goto end_with_close;
  }

  /*
    Loading of info about leap seconds succeeded
  */

  return_val= 0;


end_with_setting_default_tz:
  /* If we have default time zone try to load it */
  if (default_tzname)
  {
    String tmp_tzname(default_tzname, &my_charset_latin1);
    if (!(global_system_variables.time_zone= my_tz_find(&tmp_tzname, tables)))
    {
      sql_print_error("Fatal error: Illegal or unknown default time zone '%s'",
                      default_tzname);
      return_val= 1;
    }
  }

end_with_close:
  thd->version--; /* Force close to free memory */
  close_thread_tables(thd);

end_with_cleanup:

  /* if there were error free time zone describing structs */
  if (return_val)
    my_tz_free();
end:
  delete thd;
  if (org_thd)
    org_thd->store_globals();                   /* purecov: inspected */
  else
  {
    /* Remember that we don't have a THD */
    my_pthread_setspecific_ptr(THR_THD,  0);
    my_pthread_setspecific_ptr(THR_MALLOC,  0);
  }
  DBUG_RETURN(return_val);
}

Here is the call graph for this function:

byte* my_tz_names_get_key	(	Tz_names_entry *	entry,
		uint *	length,
		my_bool not_used	__attribute__((unused))
	)

Definition at line 1416 of file tztime.cc.

{
  *length= entry->name.length();
  return (byte*) entry->name.ptr();
}

static my_bool prepare_tz_info	(	TIME_ZONE_INFO *	sp,
		MEM_ROOT *	storage
	)			[static]

Definition at line 315 of file tztime.cc.

References st_time_zone_info::fallback_tti, LINT_INIT, MY_TIME_T_MIN, st_time_zone_info::revcnt, st_time_zone_info::timecnt, ttinfo::tt_isdst, st_time_zone_info::ttis, st_time_zone_info::typecnt, and TZ_MAX_REV_RANGES.

{
  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];

  LINT_INIT(end_l);

  /*
    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;
}