1 files changed, 28 insertions, 45 deletions
diff --git a/src/ltn12.lua b/src/ltn12.lua
index 993d3c3..6c5ea28 100644
--- a/src/ltn12.lua
+++ b/src/ltn12.lua
@@ -31,55 +31,38 @@ function filter.cycle(low, ctx, extra)
    end
 end
-- given the return of a filter, can it have pending data?
+-- chains a bunch of filters together 
-local function pending(s)
+-- by Wim Couwenberg
-    return s ~= "" and s
+function filter.chain(...)
-end
+    local current = 1
+    local bottom = 1
-- chains two filters together
+    local top = table.getn(arg)
-local function chain2(f1, f2)
+    local retry = "" 
-    local cf1, cf2
    return function(chunk)
-        -- if f2 has pending data, service it first, always
+        if chunk ~= retry then
-        if pending(cf2) then
+            current = bottom
-            cf2 = f2(cf1)
+            retry = chunk and retry
-            if pending(cf2) then return cf2 end
        end
-        -- here either f2 was already empty or we just found out it is
+        repeat
-        -- we get filtered data from f1
+            if current == bottom then
-        cf1 = f1(chunk)
+                chunk = arg[current](chunk)
-        -- make sure next time we call f1 to get pending data, 
+                if chunk == "" or bottom == top then return chunk
-        -- we don't pass the same chunk again 
+                elseif chunk then current = current + 1
-        if chunk then chunk = "" end 
+                else 
-        -- while there is data in f1
+                    bottom = bottom + 1 
-        while pending(cf1) do
+                    current = bottom
-            -- pass the new data to f2
+                end
-            cf2 = f2(cf1)
+            else
-            -- if f2 produced something, return it
+                chunk = arg[current](chunk or "")
-            if pending(cf2) then
+                if chunk == "" then
-                -- make sure next time we call f2 to get pending data, 
+                    chunk = retry
-                -- we don't pass the same chunk again 
+                    current = current - 1
-                if cf1 then cf1 = "" end
+                elseif current == top then return chunk
-                return cf2
+                else current = current + 1
+                end
            end
-            -- here f2 is still not satisfied with the amount of data
+        until false
-            -- f1 produced. we keep trying.
-            cf1 = f1(chunk)
-        end
-        -- here f1 was empty or it became empty without managing
-        -- to produce enough data for f2 to produce something
-        cf2 = f2(cf1)
-        return cf2
-    end
-end
-- chains a bunch of filters together
-function filter.chain(...)
-    local f = arg[1]
-    for i = 2, table.getn(arg) do
-        f = chain2(f, arg[i])
    end
-    return f
 end
 -----------------------------------------------------------------------------

diff --git a/src/ltn12.lua b/src/ltn12.lua index 993d3c3..6c5ea28 100644 --- a/src/ltn12.lua +++ b/src/ltn12.lua
@@ -31,55 +31,38 @@ function filter.cycle(low, ctx, extra)
31	end	31	end
32	end	32	end
33		33
34	-- given the return of a filter, can it have pending data?	34	-- chains a bunch of filters together
35	local function pending(s)	35	-- by Wim Couwenberg
36	return s ~= "" and s	36	function filter.chain(...)
37	end	37	local current = 1
38		38	local bottom = 1
39	-- chains two filters together	39	local top = table.getn(arg)
40	local function chain2(f1, f2)	40	local retry = ""
41	local cf1, cf2
42	return function(chunk)	41	return function(chunk)
43	-- if f2 has pending data, service it first, always	42	if chunk ~= retry then
44	if pending(cf2) then	43	current = bottom
45	cf2 = f2(cf1)	44	retry = chunk and retry
46	if pending(cf2) then return cf2 end
47	end	45	end
48	-- here either f2 was already empty or we just found out it is	46	repeat
49	-- we get filtered data from f1	47	if current == bottom then
50	cf1 = f1(chunk)	48	chunk = arg[current](chunk)
51	-- make sure next time we call f1 to get pending data,	49	if chunk == "" or bottom == top then return chunk
52	-- we don't pass the same chunk again	50	elseif chunk then current = current + 1
53	if chunk then chunk = "" end	51	else
54	-- while there is data in f1	52	bottom = bottom + 1
55	while pending(cf1) do	53	current = bottom
56	-- pass the new data to f2	54	end
57	cf2 = f2(cf1)	55	else
58	-- if f2 produced something, return it	56	chunk = arg[current](chunk or "")
59	if pending(cf2) then	57	if chunk == "" then
60	-- make sure next time we call f2 to get pending data,	58	chunk = retry
61	-- we don't pass the same chunk again	59	current = current - 1
62	if cf1 then cf1 = "" end	60	elseif current == top then return chunk
63	return cf2	61	else current = current + 1
		62	end
64	end	63	end
65	-- here f2 is still not satisfied with the amount of data	64	until false
66	-- f1 produced. we keep trying.
67	cf1 = f1(chunk)
68	end
69	-- here f1 was empty or it became empty without managing
70	-- to produce enough data for f2 to produce something
71	cf2 = f2(cf1)
72	return cf2
73	end
74	end
75
76	-- chains a bunch of filters together
77	function filter.chain(...)
78	local f = arg[1]
79	for i = 2, table.getn(arg) do
80	f = chain2(f, arg[i])
81	end	65	end
82	return f
83	end	66	end
84		67
85	-----------------------------------------------------------------------------	68	-----------------------------------------------------------------------------