diff --git a/lib/sbdb.rb b/lib/sbdb.rb
index 57e91c7..6a1ed32 100644
--- a/lib/sbdb.rb
+++ b/lib/sbdb.rb
@@ -10,11 +10,11 @@ module SBDB
 	RDONLY      = Bdb::DB_RDONLY
 	READONLY    = RDONLY
 
-	def btree( *p)   Btree.new *p   end
-	def hash( *p)    Hash.new *p    end
-	def recno( *p)   Recno.new *p   end
-	def queue( *p)   Queue.new *p   end 
-	def unknown( *p) Unknown.new *p end
+	def btree( *ps)   Btree.new *ps   end
+	def hash( *ps)    Hash.new *ps    end
+	def recno( *ps)   Recno.new *ps   end
+	def queue( *ps)   Queue.new *ps   end 
+	def unknown( *ps) Unknown.new *ps end
 	alias open_db unknown
 
 	def raise_barrier *ps, &e
diff --git a/lib/sbdb/cursor.rb b/lib/sbdb/cursor.rb
index 1a4a122..ed73a22 100644
--- a/lib/sbdb/cursor.rb
+++ b/lib/sbdb/cursor.rb
@@ -10,21 +10,37 @@ module SBDB
 		attr_reader :db
 
 		include Enumerable
-		def bdb_object()  @cursor  end
-		def close()  @cursor.close  end
-		def get( k, v, f)  @cursor.get( k, v, f)  end
-		def count()  @cursor.count  end
-		def first( k = nil, v = nil)  get k, v, FIRST  end
-		def last(  k = nil, v = nil)  get k, v, LAST   end 
-		def next(  k = nil, v = nil)  get k, v, NEXT   end 
-		def prev(  k = nil, v = nil)  get k, v, PREV   end
+		def bdb_object
+			@cursor
+		end
+		def close
+			@cursor.close
+		end
+		def get key, val, flg
+			@cursor.get key, val, flg
+		end
+		def count
+			@cursor.count
+		end
+		def first key = nil, val = nil
+			get key, val, FIRST
+		end
+		def last key = nil, val = nil
+			get key, val, LAST
+		end 
+		def next key = nil, val = nil
+			get key, val, NEXT
+		end 
+		def prev key = nil, val = nil
+			get key, val, PREV
+		end
 
-		def self.new *p
-			x = super *p
-			return x  unless block_given?
-			begin yield x
-			ensure x.close
-			end
+		def self.new *ps
+			ret = obj = super *ps
+			begin ret = yield obj
+			ensure obj.close
+			end  if block_given?
+			ret
 		end
 
 		def initialize ref
@@ -33,25 +49,25 @@ module SBDB
 				when Bdb::Db::Cursor  then [ref]
 				else [ref.bdb_object.cursor( nil, 0), ref]
 				end
-			if [Recno, Queue].any? {|t| t === @db }
-				def get k, v, f
-					l, w = @cursor.get( k, v, f)
-					l.nil? ? nil : [l.unpack('I')[0], w]
+			if [Recno, Queue].any? {|dbt| dbt === @db }
+				def get *ps
+					key, val = @cursor.get( *ps)
+					key.nil? ? nil : [key.unpack('I')[0], val]
 				end
 			end
 		end
 
-		def reverse k = nil, v = nil, &e
-			each k, v, LAST, PREV, &e
+		def reverse key = nil, val = nil, &exe
+			each key, val, LAST, PREV, &exe
 		end
 
-		def each k = nil, v = nil, f = nil, n = nil
-			return Enumerator.new( self, :each, k, v, f, n)  unless block_given?
-			n ||= NEXT
-			e = get k, v, f || FIRST
-			return  unless e
-			yield *e
-			yield *e  while e = get( k, v, n)
+		def each key = nil, val = nil, flg = nil, nxt = nil
+			return Enumerator.new( self, :each, key, val, flg, nxt)  unless block_given?
+			nxt ||= NEXT
+			ent = get key, val, flg || FIRST
+			return  unless ent
+			yield *ent
+			yield *ent  while ent = get( key, val, nxt)
 			nil
 		end
 	end
diff --git a/lib/sbdb/db.rb b/lib/sbdb/db.rb
index 2aff0fe..112ceb5 100644
--- a/lib/sbdb/db.rb
+++ b/lib/sbdb/db.rb
@@ -18,37 +18,37 @@ module SBDB
 		include Enumerable
 		def bdb_object()  @db  end
 		def sync()  @db.sync  end
-		def close( f = nil)  @db.close f || 0  end
-		def cursor( &e)  Cursor.new self, &e  end
+		def close( flg = nil)  @db.close flg || 0  end
+		def cursor( &exe)  Cursor.new self, &exe  end
 
-		def at k, txn = nil
-			@db.get _txn(txn), k.nil? ? nil : k.to_s, nil, 0
+		def at key, txn = nil
+			@db.get _txn(txn), key.nil? ? nil : key.to_s, nil, 0
 		rescue Bdb::KeyEmpty
 			return nil
 		end
 		alias [] at
 
-		def put k, v, txn = nil
-			if v.nil?
-				@db.del _txn(txn), k.to_s, 0
+		def put key, val, txn = nil
+			if val.nil?
+				@db.del _txn(txn), key.to_s, 0
 			else
-				@db.put _txn(txn), k.nil? ? nil : k.to_s, v.to_s, 0
+				@db.put _txn(txn), key.nil? ? nil : key.to_s, val.to_s, 0
 			end
 		end
-		
-		def []= k, v
-			put k, v
+
+		def []= key, val
+			put key, val
 		end
 
-		def delete k, txn = nil
-			@db.del _txn(txn), k.to_s
+		def delete key, txn = nil
+			@db.del _txn(txn), key.to_s
 		end
 		alias del delete
 
 		class << self
 			def new *ps, &exe
 				ret = obj = super( *ps)
-				begin ret = e.call obj
+				begin ret = exe.call obj
 				ensure
 					SBDB::raise_barrier obj.method(:sync)
 					SBDB::raise_barrier obj.method(:close)
@@ -58,9 +58,9 @@ module SBDB
 			alias open new
 		end
 
-		def _txn t
-			t ||= @txn
-			t && t.bdb_object
+		def _txn txn
+			txn ||= @txn
+			txn && t.bdb_object
 		end
 
 		def initialize file, *args
@@ -79,17 +79,17 @@ module SBDB
 			end
 		end
 
-		def each k = nil, v = nil, &e
-			cursor{|c|c.each k, v, &e}
+		def each key = nil, val = nil, &exe
+			cursor{|c|c.each key, val, &exe}
 		end
 
-		def reverse k = nil, v = nil, &e
-			cursor{|c|c.reverse k, v, &e}
+		def reverse key = nil, val = nil, &exe
+			cursor{|c|c.reverse key, val, &exe}
 		end
 
 		def to_hash k = nil, v = nil
 			h = {}
-			each( k, v) {|k, v| h[ k] = v }
+			each( key, val, h.method(:[]=))
 			h
 		end
 
@@ -99,9 +99,9 @@ module SBDB
 	end
 
 	class Unknown < DB
-		def self.new file, *p, &e
-			dbt = super( file, *p) {|db| db.bdb_object.get_type }
-			TYPES[dbt] ? TYPES[dbt].new( file, *p, &e) : super( file, *p, &e)
+		def self.new file, *ps, &exe
+			dbt = super( file, *ps) {|db| db.bdb_object.get_type }
+			TYPES[dbt] ? TYPES[dbt].new( file, *ps, &exe) : super( file, *ps, &exe)
 		end
 	end
 
@@ -114,15 +114,15 @@ module SBDB
 	TYPES[DB::HASH] = Hash
 
 	module Arrayisch
-		def [] k
-			super [k].pack('I')
+		def [] key
+			super [key].pack('I')
 		end
 
-		def []= k, v
-			super [k].pack('I'), v
+		def []= key, v
+			super [key].pack('I'), val
 		end
 
-		def push v, txn = nil
+		def push val, txn = nil
 			@db.put _txn(txn), "\0\0\0\0", v, Bdb::DB_APPEND
 		end
 	end
diff --git a/lib/sbdb/environment.rb b/lib/sbdb/environment.rb
index cb178ed..9eb21ed 100644
--- a/lib/sbdb/environment.rb
+++ b/lib/sbdb/environment.rb
@@ -27,28 +27,28 @@ module SBDB
 		# returns the Bdb-object.
 		def bdb_object()  @env  end
 		# Opens a Btree in this Environment
-		def btree file, *p, &e
-			open Btree, file, *p, &e
+		def btree file, *ps, &exe
+			open Btree, file, *ps, &exe
 		end 
 		# Opens a Hash in this Environment
-		def hash file, *p, &e
-			open Hash, file, *p, &e
+		def hash file, *ps, &exe
+			open Hash, file, *ps, &exe
 		end 
 		# Opens a Recno in this Environment
-		def recno file, *p, &e
-			open Recno, file, *p, &e
+		def recno file, *ps, &exe
+			open Recno, file, *ps, &exe
 		end 
 		# Opens a Queue in this Environment
-		def queue file, *p, &e
-			open Queue, file, *p, &e
+		def queue file, *ps, &exe
+			open Queue, file, *ps, &exe
 		end 
 		# Opens a DB of unknown type in this Environment
-		def unknown file, *p, &e
-			open Unknown, file, *p, &e
+		def unknown file, *ps, &exe
+			open Unknown, file, *ps, &exe
 		end 
 
-		def transaction flags = nil, &e
-			SBDB::Transaction.new self, flags, &e
+		def transaction flg = nil, &exe
+			SBDB::Transaction.new self, flg, &exe
 		end
 		alias txn transaction
 
@@ -73,17 +73,17 @@ module SBDB
 		end
 
 		def self.new *args
-			obj = r = super( *args)
-			begin r = yield obj
+			obj = ret = super( *args)
+			begin ret = yield obj
 			ensure SBDB::raise_barrier obj.method(:close)
 			end  if block_given?
-			r
+			ret
 		end
 
 		# Close the Environment.
 		# First you should close all databases!
 		def close
-			@dbs.each{|k, db|db.close}
+			@dbs.each{|key, db|db.close}
 			@env.close
 		end
 
@@ -93,10 +93,10 @@ module SBDB
 
 		# Opens a Database.
 		# see SBDB::DB, SBDB::Btree, SBDB::Hash, SBDB::Recno, SBDB::Queue
-		def open type, file, *p, &e
-			p.push ::Hash.new  unless ::Hash === p.last
-			p.last[:env] = self
-			(type || SBDB::Unkown).new file, *p, &e
+		def open type, file, *ps, &exe
+			ps.push ::Hash.new  unless ::Hash === ps.last
+			ps.last[:env] = self
+			(type || SBDB::Unkown).new file, *ps, &exe
 		end
 		alias db open
 		alias open_db open
@@ -105,14 +105,14 @@ module SBDB
 		# it returns the old instance.
 		# If you use this, never use close. It's possible somebody else use it too.
 		# The Databases, which are opened, will close, if the Environment will close.
-		def [] file, *p, &e
-			p.push ::Hash.new  unless ::Hash === p.last
-			p.last[:env] = self
-			name, flags, type =
-					String === p[0] ? p[0] : p.last[:name],
-					Fixnum === p[1] ? p[1] : p.last[:flags],
-					Fixnum === p[2] ? p[2] : p.last[:type]
-			@dbs[ [file, name, flags | CREATE]] ||= (type || SBDB::Unknown).new file, *p, &e
+		def [] file, *ps, &exe
+			ps.push ::Hash.new  unless ::Hash === ps.last
+			ps.last[:env] = self
+			name, flg, type =
+					String === ps[0] ? ps[0] : ps.last[:name],
+					Fixnum === ps[1] ? ps[1] : ps.last[:flags],
+					Fixnum === ps[2] ? ps[2] : ps.last[:type]
+			@dbs[ [file, name, flg | CREATE]] ||= (type || SBDB::Unknown).new file, *ps, &exe
 		end
 	end
 	Env = Environment