YkLib 0.1.0

data/lib/YkLib/Yk/file_aux2.rb

@@ -0,0 +1,919 @@
+
+
+
+require 'pathname'
+require 'Yk/__defun__'
+require 'Yk/__hook__'
+require 'Yk/io_aux'
+begin
+require 'tpty'
+rescue LoadError
+end
+
+
+(class << File; self; end).class_eval do
+	alias_method :__org_open_____, :open
+	at_exit do
+		FileUtils.rm_rf "#{ENV['HOME']}/.tmp/#{File.basename($0)}/instances/#{$$}"
+		FileUtils.rmdir("#{ENV['HOME']}/.tmp/#{File.basename($0)}/instances") rescue ""
+		FileUtils.rmdir("#{ENV['HOME']}/.tmp/#{File.basename($0)}") rescue ""
+	end
+	def open (f, mode = "r", perm = nil)
+		if f == ""
+			if !File.exist? "#{ENV['HOME']}/.tmp/#{File.basename($0)}/instances/#{$$}"
+				File.mkpath "#{ENV['HOME']}/.tmp/#{File.basename($0)}/instances/#{$$}"
+			end
+			f.replace("#{ENV['HOME']}/.tmp/#{File.basename($0)}/instances/#{$$}/tmp.#{rand(10000000000).to_s}")
+			tmode = true
+			fmode.delete = true
+		end
+		res = nil
+		fmode = mode.to_fmode
+		pid = nil
+		handleIO = Proc.new do |h|
+			pid && h.__defun__(:pid, pid)
+			if block_given?
+				begin
+					res = yield h
+				ensure
+					h.closed? || h.close
+					if pid
+						begin
+							Process.waitpid pid
+						rescue => e
+						end
+					end
+				end
+				if pid
+					res = !$?.exitstatus ? nil : res
+				else
+					res
+				end
+			else
+				res = h
+			end
+		end
+		fp = nil
+		doProg = Proc.new do |cmdLine|
+			if fmode.sys?
+				raise ArgumentError.new("cannot use popen with sysopen")
+			end
+			if !fmode.terminal?
+				fp, ff = nil
+				if fmode.readable? && fmode.writable?
+						fr, fout = IO.pipe
+						pid = fork do
+							fr.close
+							fw.close
+							STDIN.reopen fin
+							fmode.stdout? && STDOUT.reopen(fout)
+							fmode.stdout? && STDERR.reopen(fout)
+							exec *cmdLine
+						end
+						fin.close
+						fout.close
+						fr.set_write_io fw
+						fp = fr
+				else
+					fr, fw = IO.pipe
+					fcs = [] 
+					if fmode.writable?
+						fp, ff = fw, fr
+						fcs.push STDIN
+					else
+						fp, ff = fr, fw
+						fmode.stdout? && fcs.push(STDOUT)
+						fmode.stderr? && fcs.push(STDERR)
+					end
+					#fr.nonblock = true
+					#fw.nonblock = true
+					pid = fork do
+						fp.close
+						fcs.each do |fc|
+							fc.reopen ff
+						end
+						ff.close
+						exec *cmdLine
+					end
+					ff.close
+				end
+				handleIO.call fp
+			else
+				p
+				fp = nil
+				pty = TPty.new
+				if !pty || !(fp = pty.master)
+					p pty
+					Exception.new("cannot allocate pseudo tty")
+				end
+				p
+				fq = pty.slave
+				p fp
+				fp.set_raw
+				p
+				pid = fork do
+					p
+					Process.setsid
+			#Process.setpgrp
+					fqFile = "/proc/#{$$}/fd/#{pty.slave.to_i}".readlink
+					fq.reopen fqFile
+					STDIN.reopen fq
+					STDOUT.reopen fq
+					STDERR.reopen fq
+					fq.close
+					fp.close
+					p
+					exec *cmdLine
+					p :failed
+				end
+				p pid
+				fq.close
+				trap :WINCH do
+				end
+				handleIO.call fp
+			end
+		end
+		if f.is_a? Array
+			doProg.call f
+		elsif f.is_a? String
+			f = f.clone
+			case f
+			when "|-"
+				f = "-"
+				fmode.pmode = :program
+				fmode.writable = true
+			when "-|"
+				f = "-"
+				fmode.pmode = :program
+				fmode.readable = true
+			when "|-|"
+				f = "-"
+				fmode.pmode = :program
+				fmode.readable = true
+				fmode.writable = true
+			when "-"
+				fmode.pmode = :program
+			else
+				if f =~ /^\|/
+					f.sub!(/^\|/, "")
+					fmode.writable = true; fmode.pmode = :program
+				end
+				if f =~ /^\|/
+					f.sub!(/^\|/, "")
+					fmode.readable = true; fmode.pmode = :program
+				end
+			end
+			File.pipe?(f) && fmode.pmode = :pipe
+			case fmode.pmode
+			when :program, :terminal
+				doProg.call [f]
+			else
+				writeFile = nil
+				getFp = Proc.new do |m|
+					if fmode.sys?
+						IO.for_fd IO.sysopen(f, m.to_i, perm)
+					else
+						__org_open_____ f, m.to_i, perm
+					end
+				end
+				if fmode.pmode == :pipe
+					if !IO::PIPE_LOCKABLE && fmode.lock? 
+						raise ArgumentError.new("cannot lock pipe in this system")
+					end
+					if !File.exist?(f) && fmode.creatable?
+						begin
+							File.mkfifo(f)
+						rescue Exception => e
+						end
+					end
+					if !File.pipe?(f)
+						raise ArgumentError.new("cannot crate pipe #{f}, non-pipe file already exists.")
+					end
+					if fmode.writable? && fmode.readable?
+						hasPipeWriter = true
+						writeFile = "#{f}.__write__"
+						File.pipe?(f) && (File.pipe?(writeFile) || File.mkfifo(writeFile))
+						openWithWrite = Proc.new do |a, b|
+							fp = __org_open_____(a, fmode.to_i, perm)
+							fp.set_write_io __org_open_____(b, fmode.to_i, perm)
+						end
+						if fmode.truncate?
+							openWithWrite.call(f, writeFile)
+						else
+							openWithWrite.call(writeFile, f)
+						end
+					else
+						if fmode.writable? && !fmode.readable? && fmode.nonblock?
+							fmode2 = fmode.clone
+							fmode2.readable = true
+							fp = getFp.call fmode2
+							fp.fmode = fmode
+						else
+							fp = getFp.call fmode
+						end
+					end
+				else
+					fp = getFp.call fmode
+				end
+				if fmode.delete?
+					fp.__hook__ :close, f, writeFile do |_org_h, _f_h, _f_h2|
+						_org_h.call
+						File.exist?(_f_h) && File.delete(_f_h)
+						_f_h2 and File.exist?(_f_h2) && File.delete(_f_h2)
+					end
+				end
+				fmode.lock? and fp.flock fmode.to_flock
+				fmode.truncate? and (fp.truncate(0) rescue nil)
+				handleIO.call fp
+			end
+			if tmode
+				fp.__defun__ :to_s, f.clone
+			end
+		end
+		res
+	end
+end
+
+
+require 'Yk/file_aux_old'
+
+
+class File
+	def self.readable_file? (f)
+		!FileTest.blockdev?(f) && !FileTest.directory?(f) && FileTest.readable?(f)
+	end
+	def self.writable_file? (f)
+		if !File.exist? f
+			File.directory?(tmp = File.dirname(f)) && File.writable?(tmp)
+		else
+			!FileTest.blockdev?(f) && !FileTest.directory?(f) && FileTest.writable?(f)
+		end
+	end
+	def self.executable_file? (f)
+		FileTest.executable?(f) && File.file?(f)
+	end
+#	def self.realpath (f)
+#		Pathname.new(f).realpath.to_s
+#	end
+	def self.relative_path (f, d = ".")
+		f = Pathname.new(f)
+		d = Pathname.new(d)
+		f.relative_path_from(d).to_s
+	end
+	def self.normalize_path (pth, defdir = nil)
+		pth = File.expand_path(pth, defdir)
+		if pth =~ /^\/+/
+			pth = "/" + $'
+		end
+		if pth =~ /\/+$/
+			pth = $`
+		end
+		pth
+	end
+	def self.is_in (f, d, cd = nil)
+		f = File.normalize_path(f, cd)
+		d = File.normalize_path(d, cd)
+		if f =~ /^#{Regexp.escape d}(\/|$)/
+			$'
+		else
+			false
+		end
+	end
+	def self.is_in? (f, d, cd = nil)
+		f = File.normalize_path(f, cd)
+		d = File.normalize_path(d, cd)
+		if f =~ /^#{Regexp.escape d}(\/|$)/
+			$'
+		else
+			false
+		end
+	end
+	def self.sibling (f, g)
+		if f =~ /\/[^\/]+$/
+			$` + "/" + g
+		else
+			g
+		end
+	end
+	def self.resymlink (src, dst)
+		if File.symlink? dst
+			if File.readlink(dst) == src
+				return
+			else
+				FileUtils.rm_f dst
+				File.symlink src, dst
+			end
+		else
+			File.symlink src, dst
+		end
+	end
+	def self.resolv_link (l)
+		if File.symlink? l
+			lk = File.readlink(l)
+		else
+			return l
+		end
+		if lk =~ /^\//
+			lk
+		else
+			File.dirname(l) + "/" + File.readlink(l)
+		end
+	end
+	def self.fifo? (f)
+		File.pipe?(f)
+	end
+	def self.lexist? (arg)
+		File.symlink?(arg) || File.exist?(arg)
+	end
+	def self.exist? (arg)
+		File.symlink?(arg) || File.exist?(arg)
+	end
+	def self.lmtime (arg)
+		File.lstat(arg).mtime
+	end
+	def self.mknod (name, type = nil, devn = nil, mode = nil)
+		if type
+	    	if mode
+	        	mode = "-m #{mode.to_s(8)}"
+		    else
+	    	    mode = ""
+		    end	
+			minor = devn & 0xff
+			major = devn >> 8
+			tp = type.chr
+			system "mknod #{name} #{tp} #{mode} #{major} #{minor}"
+		else
+			if system "mksock #{name}"
+				if mode
+					File.chmod mode, name
+				end
+			else
+				raise Exception.new("cannot create socket `#{name}'")
+			end
+		end
+	end
+	def self.mkfifo (name, mode = nil)
+		if mode
+			mode = "-m #{mode.to_s(8)}"
+		else
+			mode = ""
+		end
+		if !system "mkfifo #{mode} #{name}"
+			raise Exception.new("cannot create fifo `#{name}'")
+		end
+	end
+	def self.mksock (name, mode = nil)
+		if !system "mksock #{name}"
+			raise Exception.new("cannot create socket `#{name}'")
+		end
+		if mode
+			FileUtils.chmod mode, name
+		end
+	end
+	def self.partial_path (name, sub)
+		arr = name.split(/\/+/)
+		while arr.size != 0 && arr[-1] == ""
+			arr.pop
+		end
+		arr[sub].join("/")
+	end
+	def self.delext (name, ext = nil)
+		if !ext
+			if name =~ /\.[^\.]*$/ && $` != ""
+				return name.sub(/\.[^\.]*$/, "")
+			else
+				return name
+			end
+		end
+		if ext[0] != ?.
+			raise ArgumentError.new("'#{ext}' is not extension. Please add '.' before it.")
+		end
+		name = name.clone
+		name.sub! /#{Regexp.escape ext}$/, ""
+		name
+	end
+	def self.which (arg)
+		`which #{arg}`.chomp
+	end
+end
+
+
+class Dir
+	def self.lrecursive (d)
+		recursive d, false do |e|
+			yield e
+		end
+	end
+	def self.recursive (d, fl = true, orgSz = nil, *exList)
+		ret = []
+		if d != "/" && d =~ /\/+$/
+			d = $`
+		end
+		if orgSz == nil
+			if d == "/"
+				orgSz = 1
+			else
+				orgSz = d.size + 1
+			end
+		end
+		if !File.directory?(d)
+			return block_given? ? 0 : ret
+		end
+		getRealPath = Proc.new do |a|
+			File.realpath(a) rescue a
+		end
+		if exList[-1].is_a? Hash
+			h = exList.pop
+		else
+			h = Hash.new
+		end
+		exList.each do |e|
+			h[getRealPath.call(e)] = true
+		end
+		pth = getRealPath.call(d)
+		if h[pth]
+			return block_given? ? 0 : ret 
+		end
+		h[pth] = true
+		cnt = 0
+		begin
+			Dir.foreach d do |f|
+				if f != "." && f != ".."
+					if d[-1] == ?/
+						f = d + f
+					else
+						f = d + "/" + f
+					end
+					if (fl || !File.symlink?(f)) && File.directory?(f)
+						cnt += Dir.recursive f, fl, orgSz, h do |g|
+							def g.dir
+								File.dirname(self)
+							end
+							def g.base
+								File.basename(self)
+							end
+							def g.dir?
+								File.directory?(self)
+							end
+							g.__defun__ :recbase, g do |tmp|
+								tmp[orgSz .. -1]
+							end
+							if block_given?
+								yield g
+							else
+								ret.push g
+							end
+						end
+					elsif File.exist?(f) || !fl
+						def f.dir
+							File.dirname(self)
+						end
+						def f.base
+							File.basename(self)
+						end
+						def f.dir?
+							File.directory?(self)
+						end
+						f.__defun__ :recbase, f do |tmp|
+							tmp[orgSz .. -1]
+						end
+						if block_given?
+							yield f
+						else
+							ret.push f
+						end
+						cnt += 1
+					end
+				end
+			end
+		rescue
+			return block_given? ? 0 : []
+		end
+		return block_given? ? cnt : ret
+	end
+	def self.each (d)
+		Dir.foreach d do |f|
+			next if f == "." || f == ".."
+			if d[-1] != ?/
+				g = d + "/" + f
+			else
+				g = d + f
+			end
+			def g.dir
+				File.dirname(self)
+			end
+			def g.base
+				File.basename(self)
+			end
+			def g.dir?
+				File.directory?(self)
+			end
+			yield g
+		end
+	end
+end
+
+
+require 'fileutils'
+
+
+module FileUtils
+  class Entry_
+	begin
+		begin
+			File.lchmod(0644, "/")
+		rescue NotImplementedError
+			def File.lchmod (*args)
+			end
+		end
+	rescue
+	end
+	begin
+		begin 
+			File.lchown(0, 0, "/")
+		rescue NotImplementedError
+			def File.lchown (*args)
+			end
+		end
+	rescue
+	end
+    def lcopy_metadata(path)
+      st = lstat()
+		if !File.symlink? path
+	      File.utime st.atime, st.mtime, path
+		end
+      begin
+        File.lchown st.uid, st.gid, path
+      rescue Errno::EPERM
+        # clear setuid/setgid
+	    File.lchmod st.mode & 01777, path
+      else
+        File.lchmod st.mode, path
+      end
+    end
+  def mknod (name, type = nil, devn = nil, mode = nil)
+		File.mknod(name, type, devn, mode)
+	end
+	def mkfifo (name, mode = nil)
+		File.mkfifo(name, mode)
+	end
+  end
+  def copy_entry(src, dest, preserve = false, dereference_root = false)
+    Entry_.new(src, nil, dereference_root).traverse do |ent|
+      destent = Entry_.new(dest, ent.rel, false)
+      ent.copy destent.path
+      ent.lcopy_metadata destent.path if preserve
+    end
+  end
+  def copy_stat(src, dest, preserve = true, dereference_root = false)
+    Entry_.new(src, nil, dereference_root).traverse do |ent|
+      destent = Entry_.new(dest, ent.rel, false)
+      ent.lcopy_metadata destent.path if preserve
+    end
+  end
+  def cp_stat(src, path)
+	  st = File.lstat(src)
+	  if !File.symlink? path
+        File.utime st.atime, st.mtime, path
+      end
+      begin
+        File.lchown st.uid, st.gid, path
+      rescue Errno::EPERM
+        # clear setuid/setgid
+        File.lchmod st.mode & 01777, path
+      else
+        File.lchmod st.mode, path
+      end
+  end
+	module_function :copy_entry
+	module_function :copy_stat
+	module_function :cp_stat
+end
+
+
+class File
+	class CannotGetLock < Exception
+	end
+	def try_lock_ex
+		if !flock File::LOCK_EX | File::LOCK_NB
+			false
+		else
+			true
+		end
+	end
+	def try_lock_sh
+		if !flock File::LOCK_SH | File::LOCK_NB
+			false
+		else
+			true
+		end
+	end
+	def lock_ex
+		flock File::LOCK_EX
+	end
+	def lock_sh
+		flock File::LOCK_SH
+	end
+	def unlock
+		flock File::LOCK_UN
+	end
+	def lock (mode = "e")
+		case mode
+		when "e"
+			flock File::LOCK_EX
+		when "s"
+			flock File::LOCK_SH
+		when "l"
+			flock(fmode.writable? ? File::LOCK_EX : File::LOCK_SH)
+		else
+			raise ArgumentError.new("illeagal mode, '#{mode}'")
+		end
+	end
+	def self.__lock_failed (file)
+		require 'Yk/shellquote'
+		pidList = []
+		if File.executable?("/usr/sbin/lsof") && File.executable?("/usr/bin/lsp")
+			IO.popen "/usr/sbin/lsof #{file.condSQuote} 2> /dev/null"  do |r|
+				r.each_line do |ln|
+					pid = ln.strip.split[1]
+					if pid =~ /\d+/
+						pidList.push pid
+					end
+				end
+			end
+			require 'Yk/proclist'
+			ProcList.refresh
+			curProc = ProcList.current
+			pidList = pidList.select do |e|
+				if pc = ProcList.pid(e)
+					if pc.isFamilyOf?(curProc)
+						next false
+					end
+					next true
+				end
+				next false
+			end
+			if pidList.size > 0
+				system "/usr/bin/lsp -a -K #{pidList.join(' ')}"
+			end
+		end
+	end
+	def self.try_lock_ex (name)
+	    fr = File.open name, File::RDONLY|File::CREAT|File::NONBLOCK
+	    if !fr.flock File::LOCK_EX | File::LOCK_NB
+	    	$DEBUG && __lock_failed(name)
+	    	if block_given?
+	    		raise File::CannotGetLock.new("failed to get exclusive lock '#{name}'")
+	    	end
+			return nil
+		end
+	    if block_given?
+	        begin
+	            yield fr
+	        ensure
+	            fr.close
+	        end
+	    else
+	    	fr
+	    end
+	end
+	def self.setpid (name)
+	    fw = File.open name, File::RDWR|File::CREAT|File::NONBLOCK
+		same = fw.read.chomp == $$.to_s
+	    if !fw.flock(File::LOCK_EX | File::LOCK_NB) && !same
+	    	$DEBUG && __lock_failed(name)
+	    	fw.close
+	    	raise File::CannotGetLock.new("failed to get exclusive lock '#{name}'")
+		end
+		fw.pos = 0
+		if !same
+			fw.truncate(0)
+			fw.write $$.to_i
+			fw.flush
+			fw.flock File::LOCK_SH
+		else
+			Dir.foreach "/proc/#{$$}/fd" do |ent|
+				next if ent !~ /^\d+$/
+				if File.symlink?(s = "/proc/#{$$}/fd/#{ent}")
+					if File.readlink(s) == File.normalize_path(name)
+						fw.close
+						fw = IO.for_fd(ent.to_i)
+						break
+					end
+				end
+			end
+		end
+	    if block_given?
+	        begin
+	            yield fw
+	        ensure
+	            File.delete name
+				!fw.closed? && fw.close
+	        end
+	    else
+	    	at_exit do
+	    		File.delete(name) if File.exist?(name)
+	    		!fw.closed? && fw.close
+	    	end
+	    end
+	end
+	def self.try_lock_sh (name)
+	    fr = File.open name, File::RDONLY|File::CREAT|File::NONBLOCK
+	    if !fr.flock File::LOCK_SH | File::LOCK_NB
+	    	$DEBUG && __lock_failed(name)
+	    	if block_given?
+	    		raise File::CannotGetLock.new("failed to get shared lock '#{name}'")
+	    	end
+			return nil
+		end
+	    if block_given? 
+	        begin 
+	            yield fr
+	        ensure 
+	            fr.close 
+	        end
+	    else
+	    	fr
+	    end
+	end
+	def self.lock_ex (name)
+		fr = File.open name, File::RDONLY|File::CREAT|File::NONBLOCK
+		fr.flock File::LOCK_EX
+		if block_given?
+			begin
+				yield
+			ensure
+				fr.close
+			end
+		else
+			fr
+		end
+	end
+	def self.lock_sh (name)
+		fr = File.open name, File::RDONLY|File::CREAT|File::NONBLOCK
+		fr.flock File::LOCK_SH
+		if block_given?
+			begin
+				yield
+			ensure
+				fr.close
+			end
+		else
+			fr
+		end
+	end
+end
+
+
+class << Object.new
+	def self.rewriteIOMethods (cls, rewrite_methods)
+		cls.class_eval do
+			rms = rewrite_methods.sort_by do |a|
+				-a.size
+			end
+			def self.getLabelAndFm (e, extra = "")
+				case e.to_sym
+				when :write, :writeln
+					fmode = IO::FMode.new extra
+					fmode.writable = true
+					fmode.readable = false
+					fmode.creatable = true
+					if !fmode.append?
+						fmode.truncate = true
+					end
+				when :rewrite_each_line, :ref_each_line, :addlines, :addline, :dellines, :delline
+					fmode = IO::FMode.new extra
+					fmode.readable = true
+					fmode.writable = true
+					fmode.creatable = true
+					fmode.truncate = false
+				when :writeln_readln
+					fmode = IO::FMode.new extra
+					fmode.readable = true
+					fmode.writable = true
+					fmode.creatable = true
+					fmode.truncate = true
+				else
+					fmode = IO::FMode.new extra
+				end
+				["__#{e}_____".to_sym, fmode]
+			end
+			rms.each do |e|
+				e = e.to_sym
+				self.__hook__ e, *getLabelAndFm(e) do |org, tlabel, fmode|
+					#STDERR.write caller.inspect + "\n"
+					#STDERR.flush
+					#STDERR.write org.class.inspect + "\n"
+					#STDERR.flush
+					#STDERR.write org.inspect + "\n"
+					#STDERR.flush
+					path = org.args.shift
+					#STDERR.write path + "\n"
+					#STDERR.write fmode.inspect + "\n"
+					File.open path, fmode do |fp|
+						fp.method(tlabel).call(*org.args, &org.block)
+					end
+				end
+			end
+			self.__hook__ :method_missing do |org|
+				name = org.args[0]
+				if name != :__hk_org_method_B_missing
+					if name.to_s =~ /^(#{rms.join('|')})_/ && (lb, fm = getLabelAndFm($1, $') rescue false)
+						File.open org.args[1], fm do |fp|
+							fp.method(lb).call(*org.args[2..-1], &org.block)
+						end
+					else
+						org.call
+					end
+				else
+					__reraise_method_missing name
+				end
+			end
+			self.__hook__ :respond_to? do |org|
+				name = org.args[0]
+				if name.to_s =~ /^(#{rms.join('|')})_/ && (fm = IO::FMode.new($') rescue false)
+					true
+				else
+					org.call
+				end
+			end
+		end
+	end
+	rewriteIOMethods(IO, 
+		%w{
+			read gets readline readlines foreach write
+			readln writeln read_each_line rewrite_each_line ref_each_line
+			writeln_readln print println printf printfln addline delline addlines dellines
+		}
+	)
+end
+
+
+class IO
+	def __read_____ (length = nil, offset = nil)
+		pos = offset if offset
+		read length
+	end
+	def __readlines_____ (rs = $/)
+		readlines rs
+	end
+	def __readline_____ (rs = $/)
+		readline rs
+	end
+	def __gets_____ (rs = $/)
+		gets rs
+	end
+	def __readln_____ (rs = $/)
+		readln rs
+	end
+	def __read_each_line_____ (rs = $/, &bl)
+		read_each_line rs, &bl
+	end
+	def __foreach_____ (rs = $/)
+		each_line rs do |ln|
+			yield ln
+		end
+	end
+	def __write_____ (*args)
+		write *args
+	end
+	def __writeln_____ (*args)
+		writeln *args
+	end
+	def __rewrite_each_line_____ (&bl)
+		rewrite_each_line(&bl)
+	end
+	def __ref_each_line_____ (&bl)
+		ref_each_line(&bl)
+	end
+	def __writeln_readln_____ (*args)
+		writeln_readln *args
+	end
+	def __print_____ (*args)
+		print *args
+	end
+	def __println_____ (*args)
+		println *args
+	end
+	def __printf_____ (*args)
+		printf *args
+	end
+	def __printfln_____ (*args)
+		println *args
+	end
+	def __addline_____ (*args)
+		addline *args
+	end
+	def __addlines_____ (*args)
+		addlines *args
+	end
+	def __delline_____ (*args)
+		delline *args
+	end
+	def __dellines_____ (*args)
+		dellines *args
+	end
+end
+
+
+