package Date::Manip::TZ;

# Copyright (c) 2008-2017 Sullivan Beck. All rights reserved.

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

# under the same terms as Perl itself.

########################################################################

# Any routine that starts with an underscore (_) is NOT intended for

# public use.  They are for internal use in the the Date::Manip

# modules and are subject to change without warning or notice.

#

# ABSOLUTELY NO USER SUPPORT IS OFFERED FOR THESE ROUTINES!

########################################################################

use Date::Manip::Obj;

use Date::Manip::TZ_Base;

@ISA = qw(Date::Manip::Obj Date::Manip::TZ_Base);

require 5.010000;

use warnings;

use strict;

use IO::File;

require Date::Manip::Zones;

use Date::Manip::Base;

use Data::Dumper;

our $VERSION;

$VERSION='6.60';

END { undef $VERSION; }

# To get rid of a 'used only once' warnings.

END {

   my $tmp = \%Date::Manip::Zones::Module;

   $tmp    = \%Date::Manip::Zones::ZoneNames;

   $tmp    = \%Date::Manip::Zones::Alias;

   $tmp    = \%Date::Manip::Zones::Abbrev;

   $tmp    = \%Date::Manip::Zones::Offmod;

   $tmp    = $Date::Manip::Zones::FirstDate;

   $tmp    = $Date::Manip::Zones::LastDate;

   $tmp    = $Date::Manip::Zones::LastYear;

   $tmp    = $Date::Manip::Zones::TzcodeVersion;

   $tmp    = $Date::Manip::Zones::TzdataVersion;

}

########################################################################

# BASE METHODS

########################################################################

sub _init {

   my($self) = @_;

   $$self{'data'} =

     {

      # These are the variables defined in Date::Manip::Zones

      'Module'         => \%Date::Manip::Zones::Module,

      'ZoneNames'      => \%Date::Manip::Zones::ZoneNames,

      'Alias'          => \%Date::Manip::Zones::Alias,

      'Abbrev'         => \%Date::Manip::Zones::Abbrev,

      'Offmod'         => \%Date::Manip::Zones::Offmod,

      'FirstDate'      => $Date::Manip::Zones::FirstDate,

      'LastDate'       => $Date::Manip::Zones::LastDate,

      'LastYear'       => $Date::Manip::Zones::LastYear,

      # These override values from Date::Manip::Zones

      'MyAlias'        => {},

      'MyAbbrev'       => {},

      'MyOffsets'      => {},

      # Each timezone/offset module that is loaded goes here

      'Zones'          => {},

      'Offsets'        => {},

      # methods     a list of methods used for determining the

      #             current zone

      # path        the PATH to set for determining the current

      #             zone

      # dates       critical dates on a per/year (UT) basis

      # zonerx      the regular expression for matching timezone

      #             names/aliases

      # abbrx       the regular expression for matching timezone

      #             abbreviations

      # offrx       the regular expression for matching a valid

      #             timezone offset

      # zrx         the regular expression to match all timezone

      #             information

      'methods'        => [],

      'path'           => undef,

      'zonerx'         => undef,

      'abbrx'          => undef,

      'offrx'          => undef,

      'zrx'            => undef,

     };

   # OS specific stuff

   my $dmb = $$self{'base'};

   my $os  = $dmb->_os();

   if ($os eq 'Unix') {

      $$self{'data'}{'path'}    = '/bin:/usr/bin';

      $$self{'data'}{'methods'} = [

                                   qw(main   TZ

                                      env    zone TZ

                                      file   /etc/TIMEZONE

                                      file   /etc/timezone

                                      file   /etc/sysconfig/clock

                                      file   /etc/default/init

                                      tzdata /etc/localtime /usr/share/zoneinfo

                                    ),

                                   'command',  '/bin/date +%Z',

                                   'command',  '/usr/bin/date +%Z',

                                   'command',  '/usr/local/bin/date +%Z',

                                   qw(cmdfield /bin/date -2

                                      cmdfield /usr/bin/date -2

                                      cmdfield /usr/local/bin/date -2

                                    ),

                                   'command',  '/bin/date +%z',

                                   'command',  '/usr/bin/date +%z',

                                   'command',  '/usr/local/bin/date +%z',

                                   'gmtoff'

                                  ];

   } elsif ($os eq 'Windows') {

      $$self{'data'}{'methods'} = [

                                   qw(main TZ

                                      env  zone TZ

                                      registry

                                      gmtoff),

                                  ];

   } elsif ($os eq 'VMS') {

      $$self{'data'}{'methods'} = [

                                   qw(main TZ

                                      env  zone TZ

                                      env  zone SYS$TIMEZONE_NAME

                                      env  zone UCX$TZ

                                      env  zone TCPIP$TZ

                                      env  zone MULTINET_TIMEZONE

                                      env  offset SYS$TIMEZONE_DIFFERENTIAL

                                      gmtoff

                                    ),

                                  ];

   } else {

      $$self{'data'}{'methods'} = [

                                   qw(main TZ

                                      env  zone TZ

                                      gmtoff

                                    ),

                                  ];

   }

}

sub _init_final {

   my($self) = @_;

   $self->_set_curr_zone();

}

no strict 'refs';

# This loads data from an offset module

#

sub _offmod {

   my($self,$offset) = @_;

   return  if (exists $$self{'data'}{'Offsets'}{$offset});

   my $mod  = $$self{'data'}{'Offmod'}{$offset};

   eval "require Date::Manip::Offset::${mod}";

   my %off  = %{ "Date::Manip::Offset::${mod}::Offset" };

   $$self{'data'}{'Offsets'}{$offset} = { %off };

}

# This loads data from a zone module (takes a lowercase zone)

#

sub _module {

   my($self,$zone) = @_;

   return  if (exists $$self{'data'}{'Zones'}{$zone}{'Loaded'});

   my $mod   = $$self{'data'}{'Module'}{$zone};

   eval "require Date::Manip::TZ::${mod}";

   my %dates = %{ "Date::Manip::TZ::${mod}::Dates" };

   my %last  = %{ "Date::Manip::TZ::${mod}::LastRule" };

   $$self{'data'}{'Zones'}{$zone} =

     {

      'Dates'    => { %dates },

      'LastRule' => { %last },

      'Loaded'   => 1

     };

}

use strict 'refs';

########################################################################

# CHECKING/MODIFYING ZONEINFO DATA

########################################################################

sub _zone {

   my($self,$zone) = @_;

   $zone = lc($zone);

   if (exists $$self{'data'}{'MyAlias'}{$zone}) {

      return $$self{'data'}{'MyAlias'}{$zone};

   } elsif (exists $$self{'data'}{'Alias'}{$zone}) {

      return  $$self{'data'}{'Alias'}{$zone};

   } else {

      return '';

   }

}

sub tzdata {

   my($self) = @_;

   return $Date::Manip::Zones::TzdataVersion;

}

sub tzcode {

   my($self) = @_;

   return $Date::Manip::Zones::TzcodeVersion;

}

sub define_alias {

   my($self,$alias,$zone) = @_;

   $alias = lc($alias);

   if ($alias eq 'reset') {

      $$self{'data'}{'MyAlias'} = {};

      $$self{'data'}{'zonerx'}  = undef;

      return 0;

   }

   if (lc($zone) eq 'reset') {

      delete $$self{'data'}{'MyAlias'}{$alias};

      $$self{'data'}{'zonerx'} = undef;

      return 0;

   }

   $zone  = $self->_zone($zone);

   return 1  if (! $zone);

   $$self{'data'}{'MyAlias'}{$alias} = $zone;

   $$self{'data'}{'zonerx'} = undef;

   return 0;

}

sub define_abbrev {

   my($self,$abbrev,@zone) = @_;

   $abbrev = lc($abbrev);

   if ($abbrev eq 'reset') {

      $$self{'data'}{'MyAbbrev'} = {};

      $$self{'data'}{'abbrx'}    = undef;

      return 0;

   }

   if ($#zone == 0  &&  lc($zone[0]) eq 'reset') {

      delete $$self{'data'}{'MyAbbrev'}{$abbrev};

      $$self{'data'}{'abbrx'} = undef;

      return (0);

   }

   if (! exists $$self{'data'}{'Abbrev'}{$abbrev}) {

      return (1);

   }

   my (@z,%z);

   my %zone = map { $_,1 } @{ $$self{'data'}{'Abbrev'}{$abbrev} };

   foreach my $z (@zone) {

      my $zone = $self->_zone($z);

      return (2,$z)  if (! $zone);

      return (3,$z)  if (! exists $zone{$zone});

      next  if (exists $z{$zone});

      $z{$zone} = 1;

      push(@z,$zone);

   }

   $$self{'data'}{'MyAbbrev'}{$abbrev} = [ @z ];

   $$self{'data'}{'abbrx'}             = undef;

   return ();

}

sub define_offset {

   my($self,$offset,@args) = @_;

   my $dmb                 = $$self{'base'};

   if (lc($offset) eq 'reset') {

      $$self{'data'}{'MyOffsets'} = {};

      return (0);

   }

   if ($#args == 0  &&  lc($args[0]) eq 'reset') {

      delete $$self{'data'}{'MyOffsets'}{$offset};

      return (0);

   }

   # Check that $offset is valid. If it is, load the

   # appropriate module.

   if (ref($offset)) {

      $offset = $dmb->join('offset',$offset);

   } else {

      $offset = $dmb->_delta_convert('offset',$offset);

   }

   return (9)  if (! $offset);

   return (1)  if (! exists $$self{'data'}{'Offmod'}{$offset});

   $self->_offmod($offset);

   # Find out whether we're handling STD, DST, or both.

   my(@isdst) = (0,1);

   if ($args[0] =~ /^std|dst|stdonly|dstonly$/i) {

      my $tmp = lc(shift(@args));

      if ($tmp eq 'stdonly') {

         @isdst = (0);

      } elsif ($tmp eq 'dstonly') {

         @isdst = (1);

      }

   }

   my @zone = @args;

   if ($#isdst == 0  &&

       ! exists($$self{'data'}{'Offsets'}{$offset}{$isdst[0]})) {

      return (2);

   }

   # Check to see that each zone is valid, and contains this offset.

   my %tmp;

   foreach my $isdst (0,1) {

      next  if (! exists $$self{'data'}{'Offsets'}{$offset}{$isdst});

      my @z = @{ $$self{'data'}{'Offsets'}{$offset}{$isdst} };

      $tmp{$isdst} = { map { $_,1 } @z };

   }

   foreach my $z (@zone) {

      my $lcz = lc($z);

      if (! exists $$self{'data'}{'ZoneNames'}{$lcz}) {

         return (3,$z);

      } elsif (! exists $tmp{0}{$lcz}  &&

               ! exists $tmp{1}{$lcz}) {

         return (4,$z);

      } elsif ($#isdst == 0  &&

               ! exists $tmp{$isdst[0]}{$lcz}) {

         return (5,$z);

      }

      $z = $lcz;

   }

   # Set the zones accordingly.

   foreach my $isdst (@isdst) {

      my @z;

      foreach my $z (@zone) {

         push(@z,$z)  if (exists $tmp{$isdst}{$z});

      }

      $$self{'data'}{'MyOffsets'}{$offset}{$isdst} = [ @z ];

   }

   return (0);

}

########################################################################

# SYSTEM ZONE

########################################################################

sub curr_zone {

   my($self,$reset) = @_;

   my $dmb = $$self{'base'};

   if ($reset) {

      $self->_set_curr_zone();

   }

   my($ret) = $self->_now('systz',1);

   return $$self{'data'}{'ZoneNames'}{$ret}

}

sub curr_zone_methods {

   my($self,@methods) = @_;

   if (${^TAINT}) {

      warn "ERROR: [curr_zone_methods] not allowed when taint checking on\n";

      return;

   }

   $$self{'data'}{'methods'}  = [ @methods ];

}

sub _set_curr_zone {

   my($self) = @_;

   my $dmb   = $$self{'base'};

   my $currzone = $self->_get_curr_zone();

   $$dmb{'data'}{'now'}{'systz'} = $self->_zone($currzone);

}

# This determines the system timezone using all of the methods

# applicable to the operating system. The first match is used.

#

sub _get_curr_zone {

   my($self) = @_;

   my $dmb   = $$self{'base'};

   my $t = time;

   my($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime($t);

   my $currzone = '';

   my $dstflag = ($isdst ? 'dstonly' : 'stdonly');

   my (@methods) = @{ $$self{'data'}{'methods'} };

   my $debug     = ($ENV{DATE_MANIP_DEBUG} ? 1 : 0);

   defined $$self{'data'}{'path'}

     and local $ENV{PATH} = $$self{'data'}{'path'};

   METHOD:

   while (@methods) {

      my $method = shift(@methods);

      my @zone   = ();

      print "*** DEBUG *** METHOD: $method ["  if ($debug);

      if ($method eq 'main') {

         if (! @methods) {

            print "]\n"  if ($debug);

            warn "ERROR: [_set_curr_zone] main requires argument\n";

            return;

         }

         my $var = shift(@methods);

         print "$var] "  if ($debug);

         no strict "refs";

         my $val = ${ "::$var" };

         use strict "refs";

         if (defined $val) {

            push(@zone,$val);

            print "$val\n"  if ($debug);

         } else {

            print "undef\n"  if ($debug);

         }

      } elsif ($method eq 'env') {

         if (@methods < 2) {

            print "]\n"  if ($debug);

            warn "ERROR: [_set_curr_zone] env requires 2 argument\n";

            return;

         }

         my $type = lc( shift(@methods) );

         print "$type,"  if ($debug);

         if ($type ne 'zone'  &&

             $type ne 'offset') {

            print "?]\n"  if ($debug);

            warn "ERROR: [_set_curr_zone] env requires 'offset' or 'zone' " .

                 "as the first argument\n";

            return;

         }

         my $var  = shift(@methods);

         print "$var] "  if ($debug);

         if (exists $ENV{$var}) {

            if ($type eq 'zone') {

               push(@zone,$ENV{$var});

               print "$ENV{$var}\n"  if ($debug);

            } else {

               my $off = $ENV{$var};

               print "$ENV{$var} = "  if ($debug);

               $off    = $dmb->_delta_convert('time',"0:0:$off");

               $off    = $dmb->_delta_convert('offset',$off);

               print "$off\n"  if ($debug);

               push(@zone,$off);

            }

         } else {

            print "undef\n"  if ($debug);

         }

      } elsif ($method eq 'file') {

         if (! @methods) {

            print "]\n"  if ($debug);

            warn "ERROR: [_set_curr_zone] file requires argument\n";

            return;

         }

         my $file = shift(@methods);

         print "$file] "  if ($debug);

         if (! -f $file) {

            print "not found\n"  if ($debug);

            next;

         }

         my $in = new IO::File;

         $in->open($file)  ||  next;

         my $firstline = 1;

         my @z;

         while (! $in->eof) {

            my $line = <$in>;

            chomp($line);

            next  if ($line =~ /^\s*\043/  ||

                      $line =~ /^\s*$/);

            if ($firstline) {

               $firstline = 0;

               $line      =~ s/^\s*//;

               $line      =~ s/\s*$//;

               $line      =~ s/["']//g;  # "

               $line      =~ s/\s+/_/g;

               @z         = ($line);

            }

            # We're looking for lines of the form:

            #   TZ = string

            #   TIMEZONE = string

            #   ZONE = string

            # Alternately, we may use a 1-line file (ignoring comments and

            # whitespace) which contains only the zone name (it may be

            # quoted or contain embedded whitespace).

            #

            # 'string' can be:

            #   the name of a timezone enclosed in single/double quotes

            #   with everything after the closing quote ignored (the

            #   name of the timezone may have spaces instead of underscores)

            #

            #   a space delimited list of tokens, the first of which

            #   is the time zone

            #

            #   the name of a timezone with underscores replaced by

            #   spaces and nothing after the timezone

            #

            # For some reason, RHEL6 desktop version stores timezones as

            #   America/New York

            # instead of

            #   America/New_York

            # which is why we have to handle the space/underscore

            # substitution.

            if ($line =~ /^\s*(?:TZ|TIMEZONE|ZONE)\s*=\s*(.*)\s*$/) {

               my $val  = $1;

               @z       = ();

               last  if (! $val);

               if ($val =~ /^(["'])(.*?)\1/) {

                  my $z = $2;

                  last  if (! $z);

                  $z    =~ s/\s+/_/g;

                  push(@zone,$z);

               } elsif ($val =~ /\s/) {

                  $val  =~ /^(\S+)/;

                  push(@zone,$1);

                  $val  =~ s/\s+/_/g;

                  push(@zone,$val);

               } else {

                  push(@zone,$val);

               }

               last;

            }

         }

         close(IN);

         push(@zone,@z)  if (@z);

         if ($debug) {

            if (@zone) {

               print "@zone\n";

            } else {

               print "no result\n";

            }

         }

      } elsif ($method eq 'tzdata') {

         if (@methods < 2) {

            print "]\n"  if ($debug);

            warn "ERROR: [_set_curr_zone] tzdata requires two arguments\n";

            return;

         }

         my $file    = shift(@methods);

         my $dir     = shift(@methods);

         my $z;

         if (-f $file  &&  -d $dir) {

            $z = _get_zoneinfo_zone($file,$dir);

         }

 	 if (defined($z)) {

 	    push @zone, $z;

 	    print "] $z\n"  if ($debug);

 	 } elsif ($debug) {

 	    print "] no result\n";

 	 }

      } elsif ($method eq 'command') {

         if (! @methods) {

            print "]\n"  if ($debug);

            warn "ERROR: [_set_curr_zone] command requires argument\n";

            return;

         }

         my $command = shift(@methods);

         print "$command] "  if ($debug);

         my ($out)   = _cmd($command);

         push(@zone,$out)  if ($out);

         if ($debug) {

            if ($out) {

               print "$out\n";

            } else {

               print "no output\n";

            }

         }

      } elsif ($method eq 'cmdfield') {

         if ($#methods < 1) {

            print "]\n"  if ($debug);

            warn "ERROR: [_set_curr_zone] cmdfield requires 2 arguments\n";

            return;

         }

         my $command = shift(@methods);

         my $n       = shift(@methods);

         print "$command,$n]\n"  if ($debug);

         my ($out)   = _cmd($command);

         my $val;

         if ($out) {

            $out    =~ s/^\s*//;

            $out    =~ s/\s*$//;

            my @out = split(/\s+/,$out);

            $val    = $out[$n]  if (defined $out[$n]);

            push(@zone,$val);

         }

         if ($debug) {

            if ($val) {

               print "$val\n";

            } else {

               print "no result\n";

            }

         }

      } elsif ($method eq 'gmtoff') {

         print "] "  if ($debug);

         my($secUT,$minUT,$hourUT,$mdayUT,$monUT,$yearUT,$wdayUT,$ydayUT,

            $isdstUT) = gmtime($t);

         if ($mdayUT>($mday+1)) {

            # UT = 28-31   LT = 1

            $mdayUT=0;

         } elsif ($mdayUT<($mday-1)) {

            # UT = 1       LT = 28-31

            $mday=0;

         }

         $sec    = (($mday*24   + $hour)*60   + $min)*60 + $sec;

         $secUT  = (($mdayUT*24 + $hourUT)*60 + $minUT)*60 + $secUT;

         my $off = $sec-$secUT;

         $off    = $dmb->_delta_convert('time',"0:0:$off");

         $off    = $dmb->_delta_convert('offset',$off);

         push(@zone,$off);

         print "$off\n"  if ($debug);

      } elsif ($method eq 'registry') {

         print "] "  if ($debug);

         my $z = $self->_windows_registry_val();

         if ($z) {

            push(@zone,$z);

            print "$z\n"  if ($debug);

         } else {

            print "no result\n"  if ($debug);

         }

      } else {

         print "]\n"  if ($debug);

         warn "ERROR: [_set_curr_zone] invalid method: $method\n";

         return;

      }

      while (@zone) {

         my $zone = lc(shift(@zone));

         # OpenUNIX puts a colon at the start

         $zone =~ s/^://;

         # If we got a zone name/alias

         $currzone = $self->_zone($zone);

         last METHOD  if ($currzone);

         # If we got an abbreviation (EST)

         if (exists $$self{'data'}{'Abbrev'}{$zone}) {

            $currzone = $$self{'data'}{'Abbrev'}{$zone}[0];

            last METHOD;

         }

         # If we got an offset

         $currzone = $self->__zone([],'',$zone,'',$dstflag);

         last METHOD  if ($currzone);

      }

   }

   if (! $currzone) {

      warn "ERROR: Date::Manip unable to determine Time Zone.\n";

      die;

   }

   return $currzone;

}

#######################

# The following section comes from the DateTime-TimeZone module

{

   my $want_content;

   my $want_size;

   my $zoneinfo;

   sub _get_zoneinfo_zone {

      my($localtime,$z) = @_;

      $zoneinfo = $z;

      # /etc/localtime should be either a link to a tzdata file in

      # /usr/share/zoneinfo or a copy of one of the files there.

      return ''  if (! -d $zoneinfo || ! -f $localtime);

      require Cwd;

      if (-l $localtime) {

         return _zoneinfo_file_name_to_zone(

                                            Cwd::abs_path($localtime),

                                            $zoneinfo,

                                           );

      }

      $want_content = _zoneinfo_file_slurp($localtime);

      $want_size    = -s $localtime;

      # File::Find can't bail in the middle of a find, and we only want the

      # first match, so we'll call it in an eval.

      local $@ = undef;

      eval {

         require File::Find;

         File::Find::find

             ({

               wanted      => \&_zoneinfo_find_file,

               no_chdir    => 1,

              },

              $zoneinfo,

           );

           1;

      } and return;

      ref $@

        and return $@->{zone};

      die $@;

   }

   sub _zoneinfo_find_file {

      my $zone;

      defined($zone = _zoneinfo_file_name_to_zone($File::Find::name,

                                                  $zoneinfo))

        and -f $_

        and $want_size == -s _

        and ($want_content eq _zoneinfo_file_slurp($File::Find::name))

        and die { zone => $zone };

   }

}

sub _zoneinfo_file_name_to_zone {

   my($file,$zoneinfo) = @_;

   require File::Spec;

   my $zone = File::Spec->abs2rel($file,$zoneinfo);

   return $zone  if (exists $Date::Manip::Zones::ZoneNames{lc($zone)});

   return;

}

sub _zoneinfo_file_slurp {

   my($file) = @_;

   open my $fh, '<', $file

     or return;

   binmode $fh;

   local $/ = undef;

   return <$fh>;

}

sub _windows_registry_val {

   my($self) = @_;

   require Win32::TieRegistry;

   my $lmachine = new Win32::TieRegistry 'LMachine',

                      { Access => Win32::TieRegistry::KEY_READ(),

                        Delimiter => '/' }

      or return '';

   my $tzinfo = $lmachine->Open('SYSTEM/CurrentControlSet/Control/TimeZoneInformation/');

   #

   # Windows Vista, Windows 2008 Server

   #

   my $tzkn = $tzinfo->GetValue('TimeZoneKeyName');

   if (defined($tzkn)  &&  $tzkn) {

      # For some reason, Vista is tacking on a bunch of stuff at the

      # end of the timezone, starting with a chr(0). Strip it off.

      my $c = chr(0);

      my $i = index($tzkn,$c);

      if ($i != -1) {

         $tzkn = substr($tzkn,0,$i);

      }

      my $z = $self->_zone($tzkn);

      return $z  if ($z);

   }

   #

   # Windows NT, Windows 2000, Windows XP, Windows 2003 Server

   #

   my $stdnam = $tzinfo->GetValue('StandardName');

   my $z = $self->_zone($stdnam);

   return $z  if ($z);

   #

   # For non-English versions, we have to determine which timezone it

   # actually is.

   #

   my $atz = $lmachine->Open('SOFTWARE/Microsoft/Windows NT/CurrentVersion/Time Zones/');

   if (! defined($atz)  ||  ! $atz) {

      $atz = $lmachine->Open('SOFTWARE/Microsoft/Windows/CurrentVersion/Time Zones/');

   }

   return ""  if (! defined($atz)  ||  ! $atz);

   foreach my $z ($atz->SubKeyNames()) {

      my $tmp  = $atz->Open("$z/");

      my $znam = $tmp->GetValue('Std');

      return $z  if ($znam eq $stdnam);

   }

}

# End of DateTime-TimeZone section

#######################

# We will be testing commands that don't exist on all architectures,

# so disable warnings.

#

no warnings;

sub _cmd {

   my($cmd) = @_;

   local(*IN);

   open(IN,"$cmd |")  ||  return ();

   my @out  = <IN>;

   close(IN);

   chomp(@out);

   return @out;

}

use warnings;

########################################################################

# DETERMINING A TIMEZONE

########################################################################

sub zone {

   my($self,@args) = @_;

   my $dmb         = $$self{'base'};

   if (! @args) {

      my($tz) = $self->_now('tz',1);

      return $$self{'data'}{'ZoneNames'}{$tz}

   }

   # Parse the arguments

   my($zone,$abbrev,$offset,$dstflag) = ('','','','');

   my $date = [];

   my $tmp;

   foreach my $arg (@args) {

      if (ref($arg) eq 'ARRAY') {

         if ($#$arg == 5) {

            # [Y,M,D,H,Mn,S]

            return undef  if (@$date);

            $date = $arg;

         } elsif ($#$arg == 2) {

            # [H,Mn,S]

            return undef  if ($offset);

            $offset = $dmb->join('offset',$arg);

            return undef  if (! $offset);