]> git.madduck.net Git - etc/awesome.git/blob - luatz/tzfile.lua

madduck's git repository

Every one of the projects in this repository is available at the canonical URL git://git.madduck.net/madduck/pub/<projectpath> — see each project's metadata for the exact URL.

All patches and comments are welcome. Please squash your changes to logical commits before using git-format-patch and git-send-email to patches@git.madduck.net. If you'd read over the Git project's submission guidelines and adhered to them, I'd be especially grateful.

SSH access, as well as push access can be individually arranged.

If you use my repositories frequently, consider adding the following snippet to ~/.gitconfig and using the third clone URL listed for each project:

[url "git://git.madduck.net/madduck/"]
  insteadOf = madduck:

luatz/tzfile: Read in (but don't yet use) TZ string
[etc/awesome.git] / 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 }