Mercurial > prosody-hg

comparison util/ztact.lua @ 403:da92afa267cf

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merging with main branch.
author Tobias Markmann <tm@ayena.de>
date Sun, 23 Nov 2008 20:44:48 +0100
parents 4a1dd1c2c219
children cccd610a0ef9
comparison
equal deleted inserted replaced
402:50f1c09541cd 403:da92afa267cf
1
2
3 -- public domain 20080410 lua@ztact.com
4
5
6 pcall (require, 'lfs') -- lfs may not be installed/necessary.
7 pcall (require, 'pozix') -- pozix may not be installed/necessary.
8
9
10 local getfenv, ipairs, next, pairs, pcall, require, select, tostring, type =
11 getfenv, ipairs, next, pairs, pcall, require, select, tostring, type
12 local unpack, xpcall =
13 unpack, xpcall
14
15 local io, lfs, os, string, table, pozix = io, lfs, os, string, table, pozix
16
17 local assert, print = assert, print
18
19 local error = error
20
21
22 module ((...) or 'ztact') ------------------------------------- module ztact
23
24
25 -- dir -------------------------------------------------------------------- dir
26
27
28 function dir (path) -- - - - - - - - - - - - - - - - - - - - - - - - - - dir
29 local it = lfs.dir (path)
30 return function ()
31 repeat
32 local dir = it ()
33 if dir ~= '.' and dir ~= '..' then return dir end
34 until not dir
35 end end
36
37
38 function is_file (path) -- - - - - - - - - - - - - - - - - - is_file (path)
39 local mode = lfs.attributes (path, 'mode')
40 return mode == 'file' and path
41 end
42
43
44 -- network byte ordering -------------------------------- network byte ordering
45
46
47 function htons (word) -- - - - - - - - - - - - - - - - - - - - - - - - htons
48 return (word-word%0x100)/0x100, word%0x100
49 end
50
51
52 -- pcall2 -------------------------------------------------------------- pcall2
53
54
55 getfenv ().pcall = pcall -- store the original pcall as ztact.pcall
56
57
58 local argc, argv, errorhandler, pcall2_f
59
60
61 local function _pcall2 () -- - - - - - - - - - - - - - - - - - - - - _pcall2
62 local tmpv = argv
63 argv = nil
64 return pcall2_f (unpack (tmpv, 1, argc))
65 end
66
67
68 function seterrorhandler (func) -- - - - - - - - - - - - - - seterrorhandler
69 errorhandler = func
70 end
71
72
73 function pcall2 (f, ...) -- - - - - - - - - - - - - - - - - - - - - - pcall2
74
75 pcall2_f = f
76 argc = select ('#', ...)
77 argv = { ... }
78
79 if not errorhandler then
80 local debug = require ('debug')
81 errorhandler = debug.traceback
82 end
83
84 return xpcall (_pcall2, errorhandler)
85 end
86
87
88 function append (t, ...) -- - - - - - - - - - - - - - - - - - - - - - append
89 local insert = table.insert
90 for i,v in ipairs {...} do
91 insert (t, v)
92 end end
93
94
95 function print_r (d, indent) -- - - - - - - - - - - - - - - - - - - print_r
96 local rep = string.rep (' ', indent or 0)
97 if type (d) == 'table' then
98 for k,v in pairs (d) do
99 if type (v) == 'table' then
100 io.write (rep, k, '\n')
101 print_r (v, (indent or 0) + 1)
102 else io.write (rep, k, ' = ', tostring (v), '\n') end
103 end
104 else io.write (d, '\n') end
105 end
106
107
108 function tohex (s) -- - - - - - - - - - - - - - - - - - - - - - - - - tohex
109 return string.format (string.rep ('%02x ', #s), string.byte (s, 1, #s))
110 end
111
112
113 function tostring_r (d, indent, tab0) -- - - - - - - - - - - - - tostring_r
114
115 tab1 = tab0 or {}
116 local rep = string.rep (' ', indent or 0)
117 if type (d) == 'table' then
118 for k,v in pairs (d) do
119 if type (v) == 'table' then
120 append (tab1, rep, k, '\n')
121 tostring_r (v, (indent or 0) + 1, tab1)
122 else append (tab1, rep, k, ' = ', tostring (v), '\n') end
123 end
124 else append (tab1, d, '\n') end
125
126 if not tab0 then return table.concat (tab1) end
127 end
128
129
130 -- queue manipulation -------------------------------------- queue manipulation
131
132
133 -- Possible queue states. 1 (i.e. queue.p[1]) is head of queue.
134 --
135 -- 1..2
136 -- 3..4 1..2
137 -- 3..4 1..2 5..6
138 -- 1..2 5..6
139 -- 1..2
140
141
142 local function print_queue (queue, ...) -- - - - - - - - - - - - print_queue
143 for i=1,10 do io.write ((queue[i] or '.')..' ') end
144 io.write ('\t')
145 for i=1,6 do io.write ((queue.p[i] or '.')..' ') end
146 print (...)
147 end
148
149
150 function dequeue (queue) -- - - - - - - - - - - - - - - - - - - - - dequeue
151
152 local p = queue.p
153 if not p and queue[1] then queue.p = { 1, #queue } p = queue.p end
154
155 if not p[1] then return nil end
156
157 local element = queue[p[1]]
158 queue[p[1]] = nil
159
160 if p[1] < p[2] then p[1] = p[1] + 1
161
162 elseif p[4] then p[1], p[2], p[3], p[4] = p[3], p[4], nil, nil
163
164 elseif p[5] then p[1], p[2], p[5], p[6] = p[5], p[6], nil, nil
165
166 else p[1], p[2] = nil, nil end
167
168 print_queue (queue, ' de '..element)
169 return element
170 end
171
172
173 function enqueue (queue, element) -- - - - - - - - - - - - - - - - - enqueue
174
175 local p = queue.p
176 if not p then queue.p = {} p = queue.p end
177
178 if p[5] then -- p3..p4 p1..p2 p5..p6
179 p[6] = p[6]+1
180 queue[p[6]] = element
181
182 elseif p[3] then -- p3..p4 p1..p2
183
184 if p[4]+1 < p[1] then
185 p[4] = p[4] + 1
186 queue[p[4]] = element
187
188 else
189 p[5] = p[2]+1
190 p[6], queue[p[5]] = p[5], element
191 end
192
193 elseif p[1] then -- p1..p2
194 if p[1] == 1 then
195 p[2] = p[2] + 1
196 queue[p[2]] = element
197
198 else
199 p[3], p[4], queue[1] = 1, 1, element
200 end
201
202 else -- empty queue
203 p[1], p[2], queue[1] = 1, 1, element
204 end
205
206 print_queue (queue, ' '..element)
207 end
208
209
210 local function test_queue ()
211 t = {}
212 enqueue (t, 1)
213 enqueue (t, 2)
214 enqueue (t, 3)
215 enqueue (t, 4)
216 enqueue (t, 5)
217 dequeue (t)
218 dequeue (t)
219 enqueue (t, 6)
220 enqueue (t, 7)
221 enqueue (t, 8)
222 enqueue (t, 9)
223 dequeue (t)
224 dequeue (t)
225 dequeue (t)
226 dequeue (t)
227 enqueue (t, 'a')
228 dequeue (t)
229 enqueue (t, 'b')
230 enqueue (t, 'c')
231 dequeue (t)
232 dequeue (t)
233 dequeue (t)
234 dequeue (t)
235 dequeue (t)
236 enqueue (t, 'd')
237 dequeue (t)
238 dequeue (t)
239 dequeue (t)
240 end
241
242
243 -- test_queue ()
244
245
246 function queue_len (queue)
247 end
248
249
250 function queue_peek (queue)
251 end
252
253
254 -- tree manipulation ---------------------------------------- tree manipulation
255
256
257 function set (parent, ...) --- - - - - - - - - - - - - - - - - - - - - - set
258
259 -- print ('set', ...)
260
261 local len = select ('#', ...)
262 local key, value = select (len-1, ...)
263 local cutpoint, cutkey
264
265 for i=1,len-2 do
266
267 local key = select (i, ...)
268 local child = parent[key]
269
270 if value == nil then
271 if child == nil then return
272 elseif next (child, next (child)) then cutpoint = nil cutkey = nil
273 elseif cutpoint == nil then cutpoint = parent cutkey = key end
274
275 elseif child == nil then child = {} parent[key] = child end
276
277 parent = child
278 end
279
280 if value == nil and cutpoint then cutpoint[cutkey] = nil
281 else parent[key] = value return value end
282 end
283
284
285 function get (parent, ...) --- - - - - - - - - - - - - - - - - - - - - - get
286 local len = select ('#', ...)
287 for i=1,len do
288 parent = parent[select (i, ...)]
289 if parent == nil then break end
290 end
291 return parent
292 end
293
294
295 -- misc ------------------------------------------------------------------ misc
296
297
298 function find (path, ...) --------------------------------------------- find
299
300 local dirs, operators = { path }, {...}
301 for operator in ivalues (operators) do
302 if not operator (path) then break end end
303
304 while next (dirs) do
305 local parent = table.remove (dirs)
306 for child in assert (pozix.opendir (parent)) do
307 if child and child ~= '.' and child ~= '..' then
308 local path = parent..'/'..child
309 if pozix.stat (path, 'is_dir') then table.insert (dirs, path) end
310 for operator in ivalues (operators) do
311 if not operator (path) then break end end
312 end end end end
313
314
315 function ivalues (t) ----------------------------------------------- ivalues
316 local i = 0
317 return function () if t[i+1] then i = i + 1 return t[i] end end
318 end
319
320
321 function lson_encode (mixed, f, indent, indents) --------------- lson_encode
322
323
324 local capture
325 if not f then
326 capture = {}
327 f = function (s) append (capture, s) end
328 end
329
330 indent = indent or 0
331 indents = indents or {}
332 indents[indent] = indents[indent] or string.rep (' ', 2*indent)
333
334 local type = type (mixed)
335
336 if type == 'number' then f (mixed)
337
338 else if type == 'string' then f (string.format ('%q', mixed))
339
340 else if type == 'table' then
341 f ('{')
342 for k,v in pairs (mixed) do
343 f ('\n')
344 f (indents[indent])
345 f ('[') f (lson_encode (k)) f ('] = ')
346 lson_encode (v, f, indent+1, indents)
347 f (',')
348 end
349 f (' }')
350 end end end
351
352 if capture then return table.concat (capture) end
353 end
354
355
356 function timestamp (time) ---------------------------------------- timestamp
357 return os.date ('%Y%m%d.%H%M%S', time)
358 end
359
360
361 function values (t) ------------------------------------------------- values
362 local k, v
363 return function () k, v = next (t, k) return v end
364 end