barlume 0.0.1.rc.1 → 0.0.1.rc.2

data/lib/barlume/lanterna/kqueue.rb

@@ -42,9 +42,7 @@ class Kqueue < Lanterna; begin
 		end
 
 		attach_function :kqueue, [], :int
-		attach_function :kevent, [:int, :pointer, :int, :pointer, :int, :pointer], :int
-
-		MAX = 4294967295
+		attach_function :kevent, [:int, :pointer, :int, :pointer, :int, :pointer], :int, :blocking => true
 
 		EVFILT_READ     =  -1
 		EVFILT_WRITE    =  -2
@@ -100,145 +98,134 @@ class Kqueue < Lanterna; begin
 		}
 	end
 
+	attr_reader :size
+
 	def initialize
 		super
 
 		FFI.raise_if((@fd = C.kqueue) < 0)
 
-		if C.kevent(@fd, C::EV_SET(C::Kevent.new, @breaker.to_i, C::EVFILT_READ, C::EV_ADD | C::EV_ENABLE, 0, 0, FFI::Pointer.new(C::MAX)), 1, nil, 0, nil) < 0
-			FFI.raise
-		end
+		@timeout = C::TimeSpec.new
+		@ev      = C::Kevent.new
 
-		self.size = 4096
-	end
+		FFI.raise_if(C.kevent(@fd, C::EV_SET(@ev, @breaker.to_i, C::EVFILT_READ, C::EV_ADD | C::EV_ENABLE, 0, 0, 0), 1, nil, 0, nil) < 0)
 
-	def size
-		@events.size / C::Kevent.size
+		self.size = 4096
 	end
 
 	def size= (n)
 		@events = FFI::MemoryPointer.new C::Kevent.size, n
+		@size   = @events.size / C::Kevent.size
 	end
 
-	def add (*)
-		super.tap {
-			@last = nil
-		}
-	end
+	def edge_triggered?;   @edge; end
+	def level_triggered?; !@edge; end
 
-	def remove (what)
-		super.tap {|l|
-			begin
-				FFI.raise_if(C.kevent(@fd, C::EV_SET(C::Kevent.new, what.to_i, C::EVFILT_READ, C::EV_DELETE | C::EV_DISABLE, 0, 0, 0), 1, nil, 0, nil) < 0)
-			rescue Errno::ENOENT; end
+	def edge_triggered!
+		@edge = true
 
-			begin
-				FFI.raise_if(C.kevent(@fd, C::EV_SET(C::Kevent.new, what.to_i, C::EVFILT_WRITE, C::EV_DELETE | C::EV_DISABLE, 0, 0, 0), 1, nil, 0, nil) < 0)
-			rescue Errno::ENOENT; end
+		each {|l|
+			if l.readable?
+				FFI.raise_if(C.kevent(@fd, C::EV_SET(@ev, l.to_i, C::EVFILT_READ, C::EV_ADD | C::EV_ENABLE | C::EV_CLEAR, 0, 0, l.to_i), 1, nil, 0, nil) < 0)
+			end
 
-			@last = nil
+			if l.writable?
+				FFI.raise_if(C.kevent(@fd, C::EV_SET(@ev, l.to_i, C::EVFILT_WRITE, C::EV_ADD | C::EV_ENABLE | C::EV_CLEAR, 0, 0, l.to_i), 1, nil, 0, nil) < 0)
+			end
 		}
 	end
 
-	def available (timeout = nil)
-		set :both; kevent timeout
-
-		Available.new(to(:read), to(:write), to(:error))
-	end
+	def level_triggered!
+		@edge = false
 
-	def readable (timeout = nil)
-		set :read; kevent timeout
+		each {|l|
+			if l.readable?
+				FFI.raise_if(C.kevent(@fd, C::EV_SET(@ev, l.to_i, C::EVFILT_READ, C::EV_ADD | C::EV_ENABLE, 0, 0, l.to_i), 1, nil, 0, nil) < 0)
+			end
 
-		if report_errors?
-			[to(:read), to(:error)]
-		else
-			to :read
-		end
+			if l.writable?
+				FFI.raise_if(C.kevent(@fd, C::EV_SET(@ev, l.to_i, C::EVFILT_WRITE, C::EV_ADD | C::EV_ENABLE, 0, 0, l.to_i), 1, nil, 0, nil) < 0)
+			end
+		}
 	end
 
-	def writable (timeout = nil)
-		set :write; kevent timeout
+	def remove (*)
+		super {|l|
+			begin
+				FFI.raise_if(C.kevent(@fd, C::EV_SET(@ev, l.to_i, C::EVFILT_READ, C::EV_DELETE | C::EV_DISABLE, 0, 0, 0), 1, nil, 0, nil) < 0)
+			rescue Errno::ENOENT, Errno::ENOTDIR; end
 
-		if report_errors?
-			[to(:write), to(:error)]
-		else
-			to :write
-		end
+			begin
+				FFI.raise_if(C.kevent(@fd, C::EV_SET(@ev, l.to_i, C::EVFILT_WRITE, C::EV_DELETE | C::EV_DISABLE, 0, 0, 0), 1, nil, 0, nil) < 0)
+			rescue Errno::ENOENT, Errno::ENOTDIR; end
+		}
 	end
 
-	def set (what)
-		return if @last == what
+	def readable! (*)
+		super {|l|
+			FFI.raise_if(C.kevent(@fd, C::EV_SET(@ev, l.to_i, C::EVFILT_READ, C::EV_ADD | C::EV_ENABLE | (edge_triggered? ? C::EV_CLEAR : 0), 0, 0, 0), 1, nil, 0, nil) < 0)
+		}
+	end
 
-		ev = C::Kevent.new
+	def no_readable! (*)
+		super {|l|
+			FFI.raise_if(C.kevent(@fd, C::EV_SET(@ev, l.to_i, C::EVFILT_READ, C::EV_ADD | C::EV_DISABLE, 0, 0, 0), 1, nil, 0, nil) < 0)
+		}
+	end
 
-		if what == :read
-			descriptors.each_with_index {|descriptor, index|
-				index = FFI::Pointer.new(index)
+	def writable! (*)
+		super {|l|
+			FFI.raise_if(C.kevent(@fd, C::EV_SET(@ev, l.to_i, C::EVFILT_WRITE, C::EV_ADD | C::EV_ENABLE | (edge_triggered? ? C::EV_CLEAR : 0), 0, 0, 0), 1, nil, 0, nil) < 0)
+		}
+	end
 
-				FFI.raise_if(C.kevent(@fd, C::EV_SET(ev, descriptor.to_i, C::EVFILT_READ, C::EV_ADD | C::EV_ENABLE, 0, 0, index), 1, nil, 0, nil) < 0)
-				FFI.raise_if(C.kevent(@fd, C::EV_SET(ev, descriptor.to_i, C::EVFILT_WRITE, C::EV_ADD | C::EV_DISABLE, 0, 0, index), 1, nil, 0, nil) < 0)
-			}
-		elsif what == :write
-			descriptors.each_with_index {|descriptor, index|
-				index = FFI::Pointer.new(index)
+	def no_writable! (*)
+		super {|l|
+			FFI.raise_if(C.kevent(@fd, C::EV_SET(@ev, l.to_i, C::EVFILT_WRITE, C::EV_ADD | C::EV_DISABLE, 0, 0, 0), 1, nil, 0, nil) < 0)
+		}
+	end
 
-				FFI.raise_if(C.kevent(@fd, C::EV_SET(ev, descriptor.to_i, C::EVFILT_WRITE, C::EV_ADD | C::EV_ENABLE, 0, 0, index), 1, nil, 0, nil) < 0)
-				FFI.raise_if(C.kevent(@fd, C::EV_SET(ev, descriptor.to_i, C::EVFILT_READ, C::EV_ADD | C::EV_DISABLE, 0, 0, index), 1, nil, 0, nil) < 0)
-			}
-		else
-			descriptors.each_with_index {|descriptor, index|
-				index = FFI::Pointer.new(index)
+	def available (timeout = nil, &block)
+		return enum_for :available, timeout unless block
 
-				FFI.raise_if(C.kevent(@fd, C::EV_SET(ev, descriptor.to_i, C::EVFILT_WRITE, C::EV_ADD | C::EV_ENABLE, 0, 0, index), 1, nil, 0, nil) < 0)
-				FFI.raise_if(C.kevent(@fd, C::EV_SET(ev, descriptor.to_i, C::EVFILT_READ, C::EV_ADD | C::EV_ENABLE, 0, 0, index), 1, nil, 0, nil) < 0)
-			}
+		if timeout
+			@timeout[:tv_sec]  = timeout.to_i
+			@timeout[:tv_nsec] = (timeout - timeout.to_i) * 1000
 		end
 
-		@last = what
-	end
+		FFI.raise_if((length = C.kevent(@fd, nil, 0, @events, size, timeout ? @timeout : nil)) < 0)
 
-	def to (what)
-		result = []
+		if length == 0
+			yield :timeout, timeout
 
-		if what == :error
-			0.upto(@length - 1) {|n|
-				p     = C::Kevent.new(@events + (n * C::Kevent.size))
-				index = p[:udata].address
+			return self
+		end
 
-				if p != index && (p[:flags] & C::EV_ERROR).nonzero?
-					result << descriptors[index]
+		n    = 0
+		size = C::Kevent.size
+		while n < length
+			p        = C::Kevent.new(@events + (n * size))
+			fd       = p[:ident]
+			lucciola = self[fd]
+
+			if lucciola
+				if (p[:flags] & C::EV_ERROR).nonzero?
+					yield :error, lucciola
+				elsif p[:filter] == C::EVFILT_READ
+					yield :readable, lucciola
+				elsif p[:filter] == C::EVFILT_WRITE
+					yield :writable, lucciola
 				end
-			}
-		else
-			filter = case what
-				when :read  then C::EVFILT_READ
-				when :write then C::EVFILT_WRITE
+			elsif fd == @breaker.to_i
+				yield :break, @breaker.reason
+			else
+				raise "#{fd} isn't trapped here"
 			end
 
-			0.upto(@length - 1) {|n|
-				p     = C::Kevent.new(@events + (n * C::Kevent.size))
-				index = p[:udata].address
-
-				if index != C::MAX && p[:filter] == filter
-					result << descriptors[index]
-				end
-			}
-		end
-
-		result
-	end
-
-	def kevent (timeout = nil)
-		if timeout
-			timeout = C::TimeSpec.new.tap {|t|
-				t[:tv_sec]  = timeout.to_i
-				t[:tv_nsec] = (timeout - timeout.to_i) * 1000
-			}
+			n += 1
 		end
 
-		FFI.raise_if((@length = C.kevent(@fd, nil, 0, @events, size, timeout)) < 0)
-
-		@breaker.flush
+		self
 	end
 rescue Exception
 	def self.supported?

data/lib/barlume/lanterna/poll.rb

@@ -17,8 +17,6 @@
 # along with barlume. If not, see <http://www.gnu.org/licenses/>.
 #++
 
-require 'ffi'
-
 module Barlume; class Lanterna
 
 class Poll < Lanterna; begin
@@ -34,7 +32,7 @@ class Poll < Lanterna; begin
 				:revents, :short
 		end
 
-		attach_function :poll, [:pointer, :ulong, :int], :int
+		attach_function :poll, [:pointer, :ulong, :int], :int, :blocking => true
 
 		attach_function :malloc, [:size_t], :pointer
 		attach_function :realloc, [:pointer, :size_t], :pointer
@@ -72,101 +70,104 @@ class Poll < Lanterna; begin
 		pfd[:events] = C::POLLIN
 	end
 
-	def add (what)
-		super.tap {|l|
-			next unless l
-
+	def add (*)
+		super {|l|
 			@set.autorelease = false
-			@set = FFI::AutoPointer.new(C.realloc(@set, (descriptors.length + 1) * C::PollFD.size), C.method(:free))
+			@set = FFI::AutoPointer.new(C.realloc(@set, (@descriptors.length + 1) * C::PollFD.size), C.method(:free))
 
-			pfd = C::PollFD.new(@set + descriptors.length * C::PollFD.size)
+			pfd = C::PollFD.new(@set + (@descriptors.length * C::PollFD.size))
 			pfd[:fd] = l.to_i
-
-			@last = nil
 		}
 	end
 
-	def remove (what)
-		Lucciola.wrap(what).tap {|l|
-			index   = descriptors.index(l)
+	def remove (*)
+		super {|l|
+			index   = index_of(l)
 			offset  = (index + 1) * C::PollFD.size
 			pointer = @set + offset
 
-			pointer.write_bytes((pointer + C::PollFD.size).read_bytes((descriptors.length - index) * C::PollFD.size))
+			pointer.write_bytes((pointer + C::PollFD.size).read_bytes((@descriptors.length - index) * C::PollFD.size))
 
 			@set.autorelease = false
-			@set = FFI::AutoPointer.new(C.realloc(@set, (descriptors.length) * C::PollFD.size), C.method(:free))
-
-			super(l)
+			@set = FFI::AutoPointer.new(C.realloc(@set, @descriptors.length * C::PollFD.size), C.method(:free))
 		}
 	end
 
-	def available (timeout = nil)
-		set :both; poll timeout
+	def readable! (*)
+		super {|l|
+			pfd = C::PollFD.new(@set + ((index_of(l) + 1) * C::PollFD.size))
+			pfd[:events] |= C::POLLIN
+		}
+	end
 
-		Available.new(to(:read), to(:write), to(:error))
+	def no_readable! (*)
+		super {|l|
+			pfd = C::PollFD.new(@set + ((index_of(l) + 1) * C::PollFD.size))
+			pfd[:events] &= ~C::POLLIN
+		}
 	end
 
-	def readable (timeout = nil)
-		set :read; poll timeout
+	def writable! (*)
+		super {|l|
+			pfd = C::PollFD.new(@set + ((index_of(l) + 1) * C::PollFD.size))
+			pfd[:events] |= C::POLLOUT
+		}
+	end
 
-		if report_errors?
-			[to(:read), to(:error)]
-		else
-			to :read
-		end
+	def no_writable! (*)
+		super {|l|
+			pfd = C::PollFD.new(@set + ((index_of(l) + 1) * C::PollFD.size))
+			pfd[:events] &= ~C::POLLOUT
+		}
 	end
 
-	def writable (timeout = nil)
-		set :write; poll timeout
+	def available (timeout = nil, &block)
+		return enum_for :available, timeout unless block
 
-		if report_errors?
-			[to(:write), to(:error)]
-		else
-			to :write
-		end
-	end
+		FFI.raise_if((length = C.poll(@set, @descriptors.length + 1, timeout ? timeout * 1000 : -1)) < 0)
 
-	def set (what)
-		return if @last == what
+		if length == 0
+			yield :timeout, timeout
 
-		events = case what
-			when :both  then C::POLLIN | C::POLLOUT
-			when :read  then C::POLLIN
-			when :write then C::POLLOUT
+			return self
 		end
 
-		1.upto(descriptors.length) {|n|
-			pfd = C::PollFD.new(@set + (n * C::PollFD.size))
-			pfd[:events] = events
-		}
-
-		@last = what
-	end
+		if (C::PollFD.new(@set)[:revents] & C::POLLIN).nonzero?
+			yield :break, @breaker.reason
+		end
 
-	def to (what)
+		n      = 0
+		size   = C::PollFD.size
 		result = []
-		events = case what
-			when :read  then C::POLLIN
-			when :write then C::POLLOUT
-			when :error then C::POLLERR | C::POLLHUP
-		end
+		while n < @descriptors.length
+			p        = C::PollFD.new(@set + ((n + 1) * size))
+			events   = p[:revents]
+			fd       = p[:fd]
+			lucciola = self[fd]
+
+			if (events & (C::POLLERR | C::POLLHUP)).nonzero?
+				result << [:error, lucciola]
+			else
+				if (events & C::POLLIN).nonzero?
+					result << [:readable, lucciola]
+				end
+
+				if (events & C::POLLOUT).nonzero?
+					result << [:writable, lucciola]
+				end
+			end
 
-		1.upto(descriptors.length) {|n|
-			pfd = C::PollFD.new(@set + (n * C::PollFD.size))
+			n += 1
+		end
 
-			if (pfd[:revents] & events).nonzero?
-				result << descriptors[n - 1]
-			end
-		}
+		result.each(&block)
 
-		result
+		self
 	end
 
-	def poll (timeout = nil)
-		FFI.raise_if(C.poll(@set, descriptors.length + 1, timeout ? timeout * 1000 : -1) < 0)
-
-		@breaker.flush
+private
+	def index_of (what)
+		@descriptors.keys.index(what.to_i)
 	end
 rescue Exception
 	def self.supported?

data/lib/barlume/lanterna/port.rb

@@ -0,0 +1,211 @@
+#--
+# Copyleft meh. [http://meh.paranoid.pk | meh@paranoici.org]
+#
+# This file is part of barlume.
+#
+# barlume is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# barlume is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with barlume. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+module Barlume; class Lanterna
+
+class Port < Lanterna; begin
+	module C
+		extend FFI::Library
+
+		ffi_lib FFI::Library::LIBC
+
+		class PortEvent < FFI::Struct
+			layout \
+				:events, :int,
+				:source, :ushort,
+				:pad,    :ushort,
+				:object, :uintptr_t,
+				:user,   :pointer
+		end
+
+		class TimeSpec < FFI::Struct
+			layout \
+				:tv_sec,  :time_t,
+				:tv_nsec, :int
+		end
+
+		attach_function :port_create, [], :int
+		attach_function :port_associate, [:int, :int, :uintptr_t, :int, :pointer], :int
+		attach_function :port_dissociate, [:int, :int, :uintptr_t], :int
+		attach_function :port_send, [:int, :int, :pointer], :int
+		attach_function :port_sendn, [:pointer, :pointer, :uint, :int, :pointer], :int
+		attach_function :port_get, [:int, :pointer, :pointer], :int
+		attach_function :port_getn, [:int, :pointer, :uint, :pointer, :pointer], :int
+		attach_function :port_alert, [:int, :int, :int, :pointer], :int
+
+		SOURCE_AIO   = 1
+		SOURCE_TIMER = 2
+		SOURCE_USER  = 3
+		SOURCE_FD    = 4
+		SOURCE_ALERT = 5
+		SOURCE_MQ    = 6
+		SOURCE_FILE  = 7
+
+		POLLIN  = 0x001
+		POLLPRI = 0x002
+		POLLOUT = 0x004
+
+		POLLERR  = 0x008
+		POLLHUP  = 0x010
+		POLLNVAL = 0x020
+
+		POLLRDNORM = 0x040
+		POLLRDBAND = 0x080
+		POLLWRNORM = 0x100
+		POLLWRBAND = 0x200
+
+		POLLMSG    = 0x0400
+		POLLREMOVE = 0x1000
+		POLLRDHUP  = 0x2000
+	end
+
+	def self.supported?
+		true
+	end
+
+	def self.new (*)
+		super.tap {|c|
+			ObjectSpace.define_finalizer c, finalizer(c.instance_variable_get :@fd)
+		}
+	end
+
+	def self.finalizer (fd)
+		proc {
+			IO.for_fd(fd).close
+		}
+	end
+
+	attr_reader :size
+
+	def initialize
+		super
+
+		FFI.raise_if((@fd = C.port_create) < 0)
+		FFI.raise_if(C.port_associate(@fd, C::SOURCE_FD, @breaker.to_i, C::POLLIN, nil) < 0)
+
+		@timeout = C::TimeSpec.new
+		@length  = FFI::MemoryPointer.new :uint
+
+		self.size = 4096
+	end
+
+	def size= (n)
+		@events = FFI::MemoryPointer.new C::PortEvent.size, n
+		@size   = @events.size / C::PortEvent.size
+	end
+
+	def add (*)
+		super {|l|
+			FFI.raise_if(C.port_associate(@fd, C::SOURCE_FD, l.to_i, C::POLLIN, nil) < 0)
+		}
+	end
+
+	def remove (*)
+		super {|l|
+			begin
+				FFI.raise_if(C.port_dissociate(@fd, C::SOURCE_FD, l.to_i) < 0)
+			rescue Errno::EIDRM; end
+		}
+	end
+
+	def readable! (*)
+		super {|l|
+			FFI.raise_if(C.port_associate(@fd, C::SOURCE_FD, l.to_i, C::POLLIN | (l.writable? ? C::POLLOUT : 0), nil) < 0)
+		}
+	end
+
+	def no_readable! (*)
+		super {|l|
+			FFI.raise_if(C.port_associate(@fd, C::SOURCE_FD, l.to_i, (l.writable? ? C::POLLOUT : 0), nil) < 0)
+		}
+	end
+
+	def writable! (*)
+		super {|l|
+			FFI.raise_if(C.port_associate(@fd, C::SOURCE_FD, l.to_i, C::POLLOUT | (l.readable? ? C::POLLIN : 0), nil) < 0)
+		}
+	end
+
+	def no_writable! (*)
+		super {|l|
+			FFI.raise_if(C.port_associate(@fd, C::SOURCE_FD, l.to_i, (l.readable? ? C::POLLIN : 0), nil) < 0)
+		}
+	end
+
+	def available (timeout = nil, &block)
+		return enum_for :available, timeout unless block
+
+		if timeout
+			@timeout[:tv_sec]  = timeout.to_i
+			@timeout[:tv_nsec] = (timeout - timeout.to_i) * 1000
+		end
+
+		@length.write_uint 1
+
+		if C.port_getn(@fd, @events, size, @length, timeout ? @timeout : nil) < 0
+			FFI.raise_unless FFI.errno == Errno::ETIME::Errno
+
+			yield :timeout, timeout
+
+			return self
+		end
+
+		n      = 0
+		size   = C::PortEvent.size
+		length = @length.read_uint
+		while n < length
+			p        = C::PortEvent.new(@events + (n * size))
+			events   = p[:events]
+			fd       = p[:object]
+			lucciola = self[fd]
+
+			if lucciola
+				FFI.raise_if(C.port_associate(@fd, C::SOURCE_FD, lucciola.to_i, (lucciola.readable? ? C::POLLIN : 0) | (lucciola.writable? ? C::POLLOUT : 0), nil) < 0)
+
+				if (events & (C::POLLERR | C::POLLHUP)).nonzero?
+					yield :error, lucciola
+				else
+					if (events & C::POLLIN).nonzero?
+						yield :readable, lucciola
+					end
+
+					if (events & C::POLLOUT).nonzero?
+						yield :writable, lucciola
+					end
+				end
+			elsif fd == @breaker.to_i
+				FFI.raise_if(C.port_associate(@fd, C::SOURCE_FD, @breaker.to_i, C::POLLIN, nil) < 0)
+
+				yield :break, @breaker.reason
+			else
+				raise "#{fd} isn't trapped here"
+			end
+
+			n += 1
+		end
+
+		self
+	end
+rescue Exception
+	def self.supported?
+		false
+	end
+end; end
+
+end; end