luatz/tzfile.lua

   1 local tz_info_mt = require "luatz.tzinfo".tz_info_mt
   2 local tt_info_mt = require "luatz.tzinfo".tt_info_mt
   3
   4
   5 local function read_int32be ( fd )
   6         local data , err = fd:read ( 4 )
   7         if data == nil then return nil , err end
   8         local o1 , o2 , o3 , o4 = data:byte ( 1 , 4 )
   9
  10         local unsigned = o4 + o3*2^8 + o2*2^16 + o1*2^24
  11         if unsigned >= 2^31 then
  12                 return unsigned - 2^32
  13         else
  14                 return unsigned
  15         end
  16 end
  17
  18 local function read_int64be ( fd )
  19         local data , err = fd:read ( 8 )
  20         if data == nil then return nil , err end
  21         local o1 , o2 , o3 , o4 , o5 , o6 , o7 , o8 = data:byte ( 1 , 8 )
  22
  23         local unsigned = o8 + o7*2^8 + o6*2^16 + o5*2^24 + o4*2^32 + o3*2^40 + o2*2^48 + o1*2^56
  24         if unsigned >= 2^63 then
  25                 return unsigned - 2^64
  26         else
  27                 return unsigned
  28         end
  29 end
  30
  31 local function read_flags ( fd , n )
  32         local data , err = fd:read ( n )
  33         if data == nil then return nil , err end
  34
  35         local res = { }
  36         for i=1, n do
  37                 res[i] = data:byte(i,i) ~= 0
  38         end
  39         return res
  40 end
  41
  42 local fifteen_nulls = ("\0"):rep(15)
  43 local function read_tz ( fd )
  44         assert ( fd:read(4) == "TZif" , "Invalid TZ file" )
  45         local version = assert ( fd:read(1) )
  46         if version == "\0" or version == "2" then
  47                 local MIN_TIME = -2^32+1
  48
  49                 assert ( assert ( fd:read(15) ) == fifteen_nulls , "Expected 15 nulls" )
  50
  51                 -- The number of UTC/local indicators stored in the file.
  52                 local tzh_ttisgmtcnt = assert ( read_int32be ( fd ) )
  53
  54                 -- The number of standard/wall indicators stored in the file.
  55                 local tzh_ttisstdcnt = assert ( read_int32be ( fd ) )
  56
  57                 -- The number of leap seconds for which data is stored in the file.
  58                 local tzh_leapcnt = assert ( read_int32be ( fd ) )
  59
  60                 -- The number of "transition times" for which data is stored in the file.
  61                 local tzh_timecnt = assert ( read_int32be ( fd ) )
  62
  63                 -- The number of "local time types" for which data is stored in the file (must not be zero).
  64                 local tzh_typecnt = assert ( read_int32be ( fd ) )
  65
  66                 -- The number of characters of "timezone abbreviation strings" stored in the file.
  67                 local tzh_charcnt = assert ( read_int32be ( fd ) )
  68
  69                 local transition_times = { }
  70                 for i=1, tzh_timecnt do
  71                         transition_times [ i ] = assert ( read_int32be ( fd ) )
  72                 end
  73                 local transition_time_ind = { assert ( fd:read ( tzh_timecnt ) ):byte ( 1 , -1 ) }
  74
  75                 local ttinfos = { }
  76                 for i=1, tzh_typecnt do
  77                         ttinfos [ i ] = {
  78                                 gmtoff = assert ( read_int32be ( fd ) ) ;
  79                                 isdst  = assert ( fd:read ( 1 ) ) ~= "\0" ;
  80                                 abbrind = assert ( fd:read ( 1 ) ):byte ( ) ;
  81                         }
  82                 end
  83
  84                 local abbreviations = assert ( fd:read ( tzh_charcnt ) )
  85
  86                 local leap_seconds = { }
  87                 for i=1, tzh_leapcnt do
  88                         leap_seconds [ i ] = {
  89                                 offset = assert ( read_int32be ( fd ) ) ;
  90                                 n = assert ( read_int32be ( fd ) ) ;
  91                         }
  92                 end
  93
  94                 local isstd = assert ( read_flags ( fd , tzh_ttisstdcnt ) )
  95
  96                 local isgmt = assert ( read_flags ( fd , tzh_ttisgmtcnt ) )
  97
  98                 local TZ
  99
 100                 if version == "2" then
 101                         --[[
 102                         For version-2-format timezone files, the above header and data is followed by a second header and data,
 103                         identical in format except that eight bytes are used for each transition time or leap-second time.
 104                         ]]
 105                         assert ( fd:read(5) == "TZif2" )
 106                         assert ( assert ( fd:read(15) ) == fifteen_nulls , "Expected 15 nulls" )
 107
 108                         MIN_TIME = -2^64+1
 109
 110                         -- The number of UTC/local indicators stored in the file.
 111                         tzh_ttisgmtcnt = assert ( read_int32be ( fd ) )
 112
 113                         -- The number of standard/wall indicators stored in the file.
 114                         tzh_ttisstdcnt = assert ( read_int32be ( fd ) )
 115
 116                         -- The number of leap seconds for which data is stored in the file.
 117                         tzh_leapcnt = assert ( read_int32be ( fd ) )
 118
 119                         -- The number of "transition times" for which data is stored in the file.
 120                         tzh_timecnt = assert ( read_int32be ( fd ) )
 121
 122                         -- The number of "local time types" for which data is stored in the file (must not be zero).
 123                         tzh_typecnt = assert ( read_int32be ( fd ) )
 124
 125                         -- The number of characters of "timezone abbreviation strings" stored in the file.
 126                         tzh_charcnt = assert ( read_int32be ( fd ) )
 127
 128                         transition_times = { }
 129                         for i=1, tzh_timecnt do
 130                                 transition_times [ i ] = assert ( read_int64be ( fd ) )
 131                         end
 132                         transition_time_ind = { assert ( fd:read ( tzh_timecnt ) ):byte ( 1 , -1 ) }
 133
 134                         ttinfos = { }
 135                         for i=1, tzh_typecnt do
 136                                 ttinfos [ i ] = {
 137                                         gmtoff = assert ( read_int32be ( fd ) ) ;
 138                                         isdst  = assert ( fd:read ( 1 ) ) ~= "\0" ;
 139                                         abbrind = assert ( fd:read ( 1 ) ):byte ( ) ;
 140                                 }
 141                         end
 142
 143                         abbreviations = assert ( fd:read ( tzh_charcnt ) )
 144
 145                         leap_seconds = { }
 146                         for i=1, tzh_leapcnt do
 147                                 leap_seconds [ i ] = {
 148                                         offset = assert ( read_int64be ( fd ) ) ;
 149                                         n = assert ( read_int32be ( fd ) ) ;
 150                                 }
 151                         end
 152
 153                         isstd = assert ( read_flags ( fd , tzh_ttisstdcnt ) )
 154
 155                         isgmt = assert ( read_flags ( fd , tzh_ttisgmtcnt ) )
 156
 157                         --[[
 158                         After the second header and data comes a newline-enclosed, POSIX-TZ-environment-variable-style string
 159                         for use in handling instants after the last transition time stored in the file
 160                         (with nothing between the newlines if there is no POSIX representation for such instants).
 161                         ]]
 162                         assert ( assert ( fd:read ( 1 ) ) == "\n" , "Expected newline at end of version 2 header" )
 163
 164                         TZ = assert ( fd:read ( "*l" ) )
 165                         if #TZ == 0 then
 166                                 TZ = nil
 167                         end
 168                 end
 169
 170                 for i=1, tzh_typecnt do
 171                         local v = ttinfos [ i ]
 172                         v.abbr = abbreviations:sub ( v.abbrind+1 , v.abbrind+3 )
 173                         v.isstd = isstd [ i ] or false
 174                         v.isgmt = isgmt [ i ] or false
 175                         setmetatable ( v , tt_info_mt )
 176                 end
 177
 178                 --[[
 179                 Use the first standard-time ttinfo structure in the file
 180                 (or simply the first ttinfo structure in the absence of a standard-time structure)
 181                 if either tzh_timecnt is zero or the time argument is less than the first transition time recorded in the file.
 182                 ]]
 183                 local first = 1
 184                 do
 185                         for i=1, tzh_ttisstdcnt do
 186                                 if isstd[i] then
 187                                         first = i
 188                                         break
 189                                 end
 190                         end
 191                 end
 192
 193                 local res = {
 194                         [0] = {
 195                                 transition_time = MIN_TIME ;
 196                                 info = ttinfos [ first ] ;
 197                         }
 198                 }
 199                 for i=1, tzh_timecnt do
 200                         res [ i ] = {
 201                                 transition_time = transition_times [ i ] ;
 202                                 info = ttinfos [ transition_time_ind [ i ]+1 ] ;
 203                         }
 204                 end
 205                 return setmetatable ( res , tz_info_mt )
 206         else
 207                 error ( "Unsupported version" )
 208         end
 209 end
 210
 211 local function read_tzfile ( path )
 212         local fd = assert ( io.open ( path , "rb" ) )
 213         local tzinfo = read_tz ( fd )
 214         fd:close ( )
 215         return tzinfo
 216 end
 217
 218 return {
 219         read_tz = read_tz ;
 220         read_tzfile = read_tzfile ;
 221 }