]> 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:

doc/timetable: spell check
[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" or version == "3" 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
163                         --[[
164                         For version-3-format time zone files, the POSIX-TZ-style string may
165                         use two minor extensions to the POSIX TZ format, as described in newtzset (3).
166                         First, the hours part of its transition times may be signed and range from
167                         -167 through 167 instead of the POSIX-required unsigned values
168                         from 0 through 24.  Second, DST is in effect all year if it starts
169                         January 1 at 00:00 and ends December 31 at 24:00 plus the difference
170                         between daylight saving and standard time.
171                         ]]
172
173                         assert ( assert ( fd:read ( 1 ) ) == "\n" , "Expected newline at end of version 2 header" )
174
175                         TZ = assert ( fd:read ( "*l" ) )
176                         if #TZ == 0 then
177                                 TZ = nil
178                         end
179                 end
180
181                 for i=1, tzh_typecnt do
182                         local v = ttinfos [ i ]
183                         v.abbr = abbreviations:sub ( v.abbrind+1 , v.abbrind+3 )
184                         v.isstd = isstd [ i ] or false
185                         v.isgmt = isgmt [ i ] or false
186                         setmetatable ( v , tt_info_mt )
187                 end
188
189                 --[[
190                 Use the first standard-time ttinfo structure in the file
191                 (or simply the first ttinfo structure in the absence of a standard-time structure)
192                 if either tzh_timecnt is zero or the time argument is less than the first transition time recorded in the file.
193                 ]]
194                 local first = 1
195                 do
196                         for i=1, tzh_ttisstdcnt do
197                                 if isstd[i] then
198                                         first = i
199                                         break
200                                 end
201                         end
202                 end
203
204                 local res = {
205                         [0] = {
206                                 transition_time = MIN_TIME ;
207                                 info = ttinfos [ first ] ;
208                         }
209                 }
210                 for i=1, tzh_timecnt do
211                         res [ i ] = {
212                                 transition_time = transition_times [ i ] ;
213                                 info = ttinfos [ transition_time_ind [ i ]+1 ] ;
214                         }
215                 end
216                 return setmetatable ( res , tz_info_mt )
217         else
218                 error ( "Unsupported version" )
219         end
220 end
221
222 local function read_tzfile ( path )
223         local fd = assert ( io.open ( path , "rb" ) )
224         local tzinfo = read_tz ( fd )
225         fd:close ( )
226         return tzinfo
227 end
228
229 return {
230         read_tz = read_tz ;
231         read_tzfile = read_tzfile ;
232 }