plugins/org.eclipse.dltk.ruby.launching/scripts/builtin.rb - dltk/org.eclipse.dltk.ruby - Git at Google

 ###############################################################################
 # Copyright (c) 2005, 2007 IBM Corporation and others.
 #
 # This program and the accompanying materials are made available under the
 # terms of the Eclipse Public License v. 2.0 which is available at
 # http://www.eclipse.org/legal/epl-2.0.
 #
 # SPDX-License-Identifier: EPL-2.0
 #

 ###############################################################################

 class DLTKBuiltinGeneratorSet
   include Enumerable

   # Creates a new set containing the given objects.
   def self.[](*ary)
     new(ary)
   end

   # Creates a new set containing the elements of the given enumerable
   # object.
   #
   # If a block is given, the elements of enum are preprocessed by the
   # given block.
   def initialize(enum = nil, &block) # :yields: o
     @hash ||= Hash.new

     enum.nil? and return

     if block
       enum.each { |o| add(block[o]) }
     else
       merge(enum)
     end
   end

   # Copy internal hash.
   def initialize_copy(orig)
     @hash = orig.instance_eval{@hash}.dup
   end

   # Returns the number of elements.
   def size
     @hash.size
   end
   alias length size

   # Returns true if the set contains no elements.
   def empty?
     @hash.empty?
   end

   # Removes all elements and returns self.
   def clear
     @hash.clear
     self
   end

   # Replaces the contents of the set with the contents of the given
   # enumerable object and returns self.
   def replace(enum)
     if enum.class == self.class
       @hash.replace(enum.instance_eval { @hash })
     else
       enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
       clear
       enum.each { |o| add(o) }
     end

     self
   end

   # Converts the set to an array.  The order of elements is uncertain.
   def to_a
     @hash.keys
   end

   def flatten_merge(set, seen = DLTKBuiltinGeneratorSet.new)
     set.each { |e|
       if e.is_a?(DLTKBuiltinGeneratorSet)
 	if seen.include?(e_id = e.object_id)
 	  raise ArgumentError, "tried to flatten recursive Set"
 	end

 	seen.add(e_id)
 	flatten_merge(e, seen)
 	seen.delete(e_id)
       else
 	add(e)
       end
     }

     self
   end
   protected :flatten_merge

   # Returns a new set that is a copy of the set, flattening each
   # containing set recursively.
   def flatten
     self.class.new.flatten_merge(self)
   end

   # Equivalent to Set#flatten, but replaces the receiver with the
   # result in place.  Returns nil if no modifications were made.
   def flatten!
     if detect { |e| e.is_a?(DLTKBuiltinGeneratorSet) }
       replace(flatten())
     else
       nil
     end
   end

   # Returns true if the set contains the given object.
   def include?(o)
     @hash.include?(o)
   end
   alias member? include?

   # Returns true if the set is a superset of the given set.
   def superset?(set)
     set.is_a?(DLTKBuiltinGeneratorSet) or raise ArgumentError, "value must be a set"
     return false if size < set.size
     set.all? { |o| include?(o) }
   end

   # Returns true if the set is a proper superset of the given set.
   def proper_superset?(set)
     set.is_a?(DLTKBuiltinGeneratorSet) or raise ArgumentError, "value must be a set"
     return false if size <= set.size
     set.all? { |o| include?(o) }
   end

   # Returns true if the set is a subset of the given set.
   def subset?(set)
     set.is_a?(DLTKBuiltinGeneratorSet) or raise ArgumentError, "value must be a set"
     return false if set.size < size
     all? { |o| set.include?(o) }
   end

   # Returns true if the set is a proper subset of the given set.
   def proper_subset?(set)
     set.is_a?(DLTKBuiltinGeneratorSet) or raise ArgumentError, "value must be a set"
     return false if set.size <= size
     all? { |o| set.include?(o) }
   end

   # Calls the given block once for each element in the set, passing
   # the element as parameter.
   def each
     @hash.each_key { |o| yield(o) }
     self
   end

   # Adds the given object to the set and returns self.  Use +merge+ to
   # add several elements at once.
   def add(o)
     @hash[o] = true
     self
   end
   alias << add

   # Adds the given object to the set and returns self.  If the
   # object is already in the set, returns nil.
   def add?(o)
     if include?(o)
       nil
     else
       add(o)
     end
   end

   # Deletes the given object from the set and returns self.  Use +subtract+ to
   # delete several items at once.
   def delete(o)
     @hash.delete(o)
     self
   end

   # Deletes the given object from the set and returns self.  If the
   # object is not in the set, returns nil.
   def delete?(o)
     if include?(o)
       delete(o)
     else
       nil
     end
   end

   # Deletes every element of the set for which block evaluates to
   # true, and returns self.
   def delete_if
     @hash.delete_if { |o,| yield(o) }
     self
   end

   # Do collect() destructively.
   def collect!
     set = self.class.new
     each { |o| set << yield(o) }
     replace(set)
   end
   alias map! collect!

   # Equivalent to Set#delete_if, but returns nil if no changes were
   # made.
   def reject!
     n = size
     delete_if { |o| yield(o) }
     size == n ? nil : self
   end

   # Merges the elements of the given enumerable object to the set and
   # returns self.
   def merge(enum)
     if enum.is_a?(DLTKBuiltinGeneratorSet)
       @hash.update(enum.instance_eval { @hash })
     else
       enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
       enum.each { |o| add(o) }
     end

     self
   end

   # Deletes every element that appears in the given enumerable object
   # and returns self.
   def subtract(enum)
     enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
     enum.each { |o| delete(o) }
     self
   end

   # Returns a new set built by merging the set and the elements of the
   # given enumerable object.
   def |(enum)
     enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
     dup.merge(enum)
   end
   alias + |		##
   alias union |		##

   # Returns a new set built by duplicating the set, removing every
   # element that appears in the given enumerable object.
   def -(enum)
     enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
     dup.subtract(enum)
   end
   alias difference -	##

   # Returns a new set containing elements common to the set and the
   # given enumerable object.
   def &(enum)
     enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
     n = self.class.new
     enum.each { |o| n.add(o) if include?(o) }
     n
   end
   alias intersection &	##

   # Returns a new set containing elements exclusive between the set
   # and the given enumerable object.  (set ^ enum) is equivalent to
   # ((set | enum) - (set & enum)).
   def ^(enum)
     enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
     n = DLTKBuiltinGeneratorSet.new(enum)
     each { |o| if n.include?(o) then n.delete(o) else n.add(o) end }
     n
   end

   # Returns true if two sets are equal.  The equality of each couple
   # of elements is defined according to Object#eql?.
   def ==(set)
     equal?(set) and return true

     set.is_a?(DLTKBuiltinGeneratorSet) && size == set.size or return false

     hash = @hash.dup
     set.all? { |o| hash.include?(o) }
   end

   def hash	# :nodoc:
     @hash.hash
   end

   def eql?(o)	# :nodoc:
     return false unless o.is_a?(DLTKBuiltinGeneratorSet)
     @hash.eql?(o.instance_eval{@hash})
   end

   # Classifies the set by the return value of the given block and
   # returns a hash of {value => set of elements} pairs.  The block is
   # called once for each element of the set, passing the element as
   # parameter.
   #
   # e.g.:
   #
   #   require 'set'
   #   files = Set.new(Dir.glob("*.rb"))
   #   hash = files.classify { |f| File.mtime(f).year }
   #   p hash    # => {2000=>#<Set: {"a.rb", "b.rb"}>,
   #             #     2001=>#<Set: {"c.rb", "d.rb", "e.rb"}>,
   #             #     2002=>#<Set: {"f.rb"}>}
   def classify # :yields: o
     h = {}

     each { |i|
       x = yield(i)
       (h[x] ||= self.class.new).add(i)
     }

     h
   end

   # Divides the set into a set of subsets according to the commonality
   # defined by the given block.
   #
   # If the arity of the block is 2, elements o1 and o2 are in common
   # if block.call(o1, o2) is true.  Otherwise, elements o1 and o2 are
   # in common if block.call(o1) == block.call(o2).
   #
   # e.g.:
   #
   #   require 'set'
   #   numbers = Set[1, 3, 4, 6, 9, 10, 11]
   #   set = numbers.divide { |i,j| (i - j).abs == 1 }
   #   p set     # => #<Set: {#<Set: {1}>,
   #             #            #<Set: {11, 9, 10}>,
   #             #            #<Set: {3, 4}>,
   #             #            #<Set: {6}>}>
   def divide(&func)
     if func.arity == 2
       require 'tsort'

       class << dig = {}		# :nodoc:
 	include TSort

 	alias tsort_each_node each_key
 	def tsort_each_child(node, &block)
 	  fetch(node).each(&block)
 	end
       end

       each { |u|
 	dig[u] = a = []
 	each{ |v| func.call(u, v) and a << v }
       }

       set = DLTKBuiltinGeneratorSet.new()
       dig.each_strongly_connected_component { |css|
 	set.add(self.class.new(css))
       }
       set
     else
 	DLTKBuiltinGeneratorSet.new(classify(&func).values)
     end
   end

   InspectKey = :__inspect_key__         # :nodoc:

   # Returns a string containing a human-readable representation of the
   # set. ("#<Set: {element1, element2, ...}>")
   def inspect
     ids = (Thread.current[InspectKey] ||= [])

     if ids.include?(object_id)
       return sprintf('#<%s: {...}>', self.class.name)
     end

     begin
       ids << object_id
       return sprintf('#<%s: {%s}>', self.class, to_a.inspect[1..-2])
     ensure
       ids.pop
     end
   end

   def pretty_print(pp)	# :nodoc:
     pp.text sprintf('#<%s: {', self.class.name)
     pp.nest(1) {
       pp.seplist(self) { |o|
 	pp.pp o
       }
     }
     pp.text "}>"
   end

   def pretty_print_cycle(pp)	# :nodoc:
     pp.text sprintf('#<%s: {%s}>', self.class.name, empty? ? '' : '...')
   end
 end

 class DLTKBuiltinGenerator

 def collectMethod(hash, methodName, arity)
 	hash.add methodName + '###' + arity.to_s
 end

 def put_methods!(metaclass)
 	result = DLTKBuiltinGeneratorSet.new
 	modules = metaclass.included_modules

 	methods = metaclass.public_instance_methods(false)
 	for mod in modules do; methods -= mod.public_instance_methods(true); end

 	$data << "\t\npublic\n"
 	for method in methods do
 		arity = metaclass.instance_method(method).arity
 		collectMethod(result, method.to_s, arity)
 		put_rdoc(metaclass.name + "." + method.to_s)
 		$data << <<-"END"
 	def #{method.to_s}(#{generateArgs(arity)})
 	end

 END
 	end

 	methods = metaclass.protected_instance_methods(false)
 	for mod in modules do;
 		if mod.respond_to?(:protected_instance_methods) then
 			methods -= mod.protected_instance_methods(true)
 			end
 	end

 	$data << "\t\nprotected\n"
 	for method in methods do
 		put_rdoc(metaclass.name + "." + method.to_s)
 		arity = metaclass.instance_method(method).arity
 		collectMethod(result, method.to_s, arity)
 		$data << <<-"END"
 	def #{method.to_s}(#{generateArgs(arity)})
 	end

 END
 	end


 	methods = metaclass.private_instance_methods(false)
 	for mod in modules do;
 		if mod.respond_to?(:private_instance_methods) then
 			methods -= mod.private_instance_methods(true)
 		end
 	end

 	$data << "\t\nprivate\n"
 	for method in methods do
 		put_rdoc(metaclass.name + "." + method.to_s)
 		arity = metaclass.instance_method(method).arity
 		collectMethod(result, method.to_s, arity)
 		$data << <<-"END"
 	def #{method.to_s}(#{generateArgs(arity)})
 	end

 END
 	end

 	return result

 end

 def generateArgs(arity)
 	if arity < 0 then
 		return "*args"
 	end
 	result = ""
 	for i in 1..arity do
 		result <<  "arg" + i.to_s
 		if i != arity then
 			result << ", "
 		end
 	end
 	result
 end

 def put_singleton_methods!(metaclass, instanceMethods)
 #	if (metaclass.is_a?(Class))
 #		$data << <<-"END2"
 #		class << self
 #		END2
 #	else
 #		$data << "\t\tprivate\n"
 #	end
 #	ms = (metaclass.public_methods(false) - Class.instance_methods(false)).each { |m|
 	ms = (metaclass.singleton_methods(false)).each { |m|
 		arity = metaclass.method(m).arity
 		if (!instanceMethods.include?(m.to_s + '###' + arity.to_s)) then
 			$data << <<-"END2"
 	def self.#{m.to_s}(#{generateArgs(arity)})
 	end

 			END2
 		end
 	}
 #	if (metaclass.is_a?(Class))
 #		$data << <<-"END2"
 #		end
 #		END2
 #	end
 end

 def put_included_modules!(metaclass)

 	ms = (metaclass.included_modules -
 			((metaclass.is_a?(Class) &&
 			metaclass.superclass &&
 				metaclass.superclass.included_modules) || []))

 	for in_mod in ms do
 		$data << <<-"END"
 	include #{in_mod.name}
 		END
 	end

 end

 def put_singleton_included_modules!(metaclass)
 	$data << <<-"END2"
 	class << ::#{metaclass.name}
 	END2

 	sup = (class << metaclass; superclass; end)
 #	ms = ((class << metaclass; included_modules; end) -
 #			((sup && sup.included_modules) || []))
 	ms = (class << metaclass; included_modules; end)


 	for in_mod in ms do
 		$data << <<-"END"
 		include #{in_mod.name}
 		END
 	end

 	$data << <<-"END2"
 	end
 	END2

 end

 def put_constants(metaclass)
 	#return
 	consts = DLTKBuiltinGeneratorSet.new(metaclass.constants)
 	ancestors = metaclass.ancestors
 	for m in ancestors
 		if m != metaclass
 			consts -= DLTKBuiltinGeneratorSet.new(m.constants)
 		end
 	end
 	for c in consts
 		v = metaclass.const_get(c)
 		if !@classesAndModules.include?(v)
 			$data << c.to_s + '=' + v.class.to_s + ".new\n"
 		end
 	end
 end

 def put_superclass!(metaclass)
 	return if metaclass.superclass.nil?
 	$data << <<-"END"
 		#{const_for(metaclass)}.setSuperClass(#{const_for(metaclass.superclass)});
 	END
 end

 #def put_singleton_superclass!(metaclass)
 #	$data << <<-"END"
 #		#{const_for_singleton(metaclass)}.setSuperClass(#{const_for(metaclass.class)});
 #	END
 #end


 def dumpClass(klass)
 	name = klass.name
 	if name == "NameError::message" || name == "fatal" then
 		return
 	end
 	sc = klass.superclass
 	if sc then scname = " < ::" + sc.name else scname = "" end
 #	methods = klass.instance_methods(false)
 	put_rdoc(name)
 	$data << <<-"END"

 class #{name} #{scname}
 	END
 	put_included_modules!(klass)
 	if sc then
 		# skip Object - they are generated later
 		put_constants(klass)
 	end
 	put_singleton_included_modules!(klass)
 	instanceMethods = put_methods!(klass)
 	put_singleton_methods!(klass, instanceMethods)
 	$data << <<-"END"
 end

 	END
 end

 def put_rdoc(name)
 	return
 	print "Getting doc for " + name + "\n"
 	rdoc = `d:\\instantrails\\ruby\\bin\\ri.bat \"#{name}\" -f html`
 	rdoc.to_a.each { |line|
 		$data << "#" + line
 	}
 end

 def dumpModule(klass)
 	name = klass.name
 	#	methods = klass.instance_methods(false)
 	put_rdoc(name)
 	$data << <<-"END"

 module #{name}
 	END
 	put_included_modules!(klass)
 	put_constants(klass)
 	instanceMethods = put_methods!(klass)
 	put_singleton_methods!(klass, instanceMethods)
 	$data << <<-"END"
 end

 	END
 end

 def dumpVariables
 	$data << "# Global variables\n"
 	global_variables.each { |var|
 		$data << <<-"END"
 #{var.to_s} = #{var.to_s}
 		END
 	}
 end


 def process_all
 	classes = DLTKBuiltinGeneratorSet.new
 	known_modules = DLTKBuiltinGeneratorSet.new
 	ObjectSpace.each_object do |o|
 		if (o.respond_to?('name')) then
 			className = o.name
 			if className == 'DLTKBuiltinGenerator' || className == 'DLTKBuiltinGeneratorSet' || className == nil then
 				next
 			end
 		end
 		classes << o if o.is_a?(Class)
 		known_modules << o if o.is_a?(Module)
 	end
 	@classesAndModules = known_modules + classes
 	known_modules = (known_modules - classes).to_a
 	classes = classes.to_a.sort { |a,b| a.name <=> b.name }

 	classes.each { |c|
 		$data = ""
 		dumpClass(c)
 		filename = c.name
 		pos = filename.index(':')
 		if pos then
 			filename = filename.slice(0..pos-1)
 			#puts "sliced " + filename
 		end
 		file = filename + ".rb"
 		puts "#### DLTK RUBY BUILTINS ####" + file + "\n"
 		puts $data
 		#File.open(file, 'a') {|f| f.write $data}
 	}
 	known_modules.each { |c|
 		$data = ""
 		dumpModule(c)
 		filename = c.name
 		pos = filename.index(':')
 		if pos then
 			filename = filename.slice(0..pos-1)
 			#puts "sliced " + filename
 		end
 		file = filename + ".rb"
 		puts "#### DLTK RUBY BUILTINS ####" + file + "\n"
 		puts $data
 		#File.open(file, 'a') {|f| f.write $data}
 	}

 	ccc = []
 	Module.constants.each { |x|
 		ccc << x.to_s
 	}
 	ccc.delete('DLTKBuiltinGenerator')
 	ccc.delete('DLTKBuiltinGeneratorSet')
 	known_modules.each { |x|
 		ccc.delete(x.to_s)
 	}
 	classes.each { |x|
 		ccc.delete(x.to_s)
 	}

 	puts "#### DLTK RUBY BUILTINS ####constants.rb\n\n\n"
 	ccc.each { |bar|
 		puts "#{bar} = #{Module.const_get(bar).class.to_s}.new"
 	}

 end

 end

 g = DLTKBuiltinGenerator.new
 g.process_all

 # vim: noexpandtab tabstop=4 sts=0 sw=4
	###############################################################################
	# Copyright (c) 2005, 2007 IBM Corporation and others.
	#
	# This program and the accompanying materials are made available under the
	# terms of the Eclipse Public License v. 2.0 which is available at
	# http://www.eclipse.org/legal/epl-2.0.
	#
	# SPDX-License-Identifier: EPL-2.0
	#

	###############################################################################

	class DLTKBuiltinGeneratorSet
	include Enumerable

	# Creates a new set containing the given objects.
	def self.[](*ary)
	new(ary)
	end

	# Creates a new set containing the elements of the given enumerable
	# object.
	#
	# If a block is given, the elements of enum are preprocessed by the
	# given block.
	def initialize(enum = nil, &block) # :yields: o
	@hash \|\|= Hash.new

	enum.nil? and return

	if block
	enum.each { \|o\| add(block[o]) }
	else
	merge(enum)
	end
	end

	# Copy internal hash.
	def initialize_copy(orig)
	@hash = orig.instance_eval{@hash}.dup
	end

	# Returns the number of elements.
	def size
	@hash.size
	end
	alias length size

	# Returns true if the set contains no elements.
	def empty?
	@hash.empty?
	end

	# Removes all elements and returns self.
	def clear
	@hash.clear
	self
	end

	# Replaces the contents of the set with the contents of the given
	# enumerable object and returns self.
	def replace(enum)
	if enum.class == self.class
	@hash.replace(enum.instance_eval { @hash })
	else
	enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
	clear
	enum.each { \|o\| add(o) }
	end

	self
	end

	# Converts the set to an array. The order of elements is uncertain.
	def to_a
	@hash.keys
	end

	def flatten_merge(set, seen = DLTKBuiltinGeneratorSet.new)
	set.each { \|e\|
	if e.is_a?(DLTKBuiltinGeneratorSet)
	if seen.include?(e_id = e.object_id)
	raise ArgumentError, "tried to flatten recursive Set"
	end

	seen.add(e_id)
	flatten_merge(e, seen)
	seen.delete(e_id)
	else
	add(e)
	end
	}

	self
	end
	protected :flatten_merge

	# Returns a new set that is a copy of the set, flattening each
	# containing set recursively.
	def flatten
	self.class.new.flatten_merge(self)
	end

	# Equivalent to Set#flatten, but replaces the receiver with the
	# result in place. Returns nil if no modifications were made.
	def flatten!
	if detect { \|e\| e.is_a?(DLTKBuiltinGeneratorSet) }
	replace(flatten())
	else
	nil
	end
	end

	# Returns true if the set contains the given object.
	def include?(o)
	@hash.include?(o)
	end
	alias member? include?

	# Returns true if the set is a superset of the given set.
	def superset?(set)
	set.is_a?(DLTKBuiltinGeneratorSet) or raise ArgumentError, "value must be a set"
	return false if size < set.size
	set.all? { \|o\| include?(o) }
	end

	# Returns true if the set is a proper superset of the given set.
	def proper_superset?(set)
	set.is_a?(DLTKBuiltinGeneratorSet) or raise ArgumentError, "value must be a set"
	return false if size <= set.size
	set.all? { \|o\| include?(o) }
	end

	# Returns true if the set is a subset of the given set.
	def subset?(set)
	set.is_a?(DLTKBuiltinGeneratorSet) or raise ArgumentError, "value must be a set"
	return false if set.size < size
	all? { \|o\| set.include?(o) }
	end

	# Returns true if the set is a proper subset of the given set.
	def proper_subset?(set)
	set.is_a?(DLTKBuiltinGeneratorSet) or raise ArgumentError, "value must be a set"
	return false if set.size <= size
	all? { \|o\| set.include?(o) }
	end

	# Calls the given block once for each element in the set, passing
	# the element as parameter.
	def each
	@hash.each_key { \|o\| yield(o) }
	self
	end

	# Adds the given object to the set and returns self. Use +merge+ to
	# add several elements at once.
	def add(o)
	@hash[o] = true
	self
	end
	alias << add

	# Adds the given object to the set and returns self. If the
	# object is already in the set, returns nil.
	def add?(o)
	if include?(o)
	nil
	else
	add(o)
	end
	end

	# Deletes the given object from the set and returns self. Use +subtract+ to
	# delete several items at once.
	def delete(o)
	@hash.delete(o)
	self
	end

	# Deletes the given object from the set and returns self. If the
	# object is not in the set, returns nil.
	def delete?(o)
	if include?(o)
	delete(o)
	else
	nil
	end
	end

	# Deletes every element of the set for which block evaluates to
	# true, and returns self.
	def delete_if
	@hash.delete_if { \|o,\| yield(o) }
	self
	end

	# Do collect() destructively.
	def collect!
	set = self.class.new
	each { \|o\| set << yield(o) }
	replace(set)
	end
	alias map! collect!

	# Equivalent to Set#delete_if, but returns nil if no changes were
	# made.
	def reject!
	n = size
	delete_if { \|o\| yield(o) }
	size == n ? nil : self
	end

	# Merges the elements of the given enumerable object to the set and
	# returns self.
	def merge(enum)
	if enum.is_a?(DLTKBuiltinGeneratorSet)
	@hash.update(enum.instance_eval { @hash })
	else
	enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
	enum.each { \|o\| add(o) }
	end

	self
	end

	# Deletes every element that appears in the given enumerable object
	# and returns self.
	def subtract(enum)
	enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
	enum.each { \|o\| delete(o) }
	self
	end

	# Returns a new set built by merging the set and the elements of the
	# given enumerable object.
	def \|(enum)
	enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
	dup.merge(enum)
	end
	alias + \| ##
	alias union \| ##

	# Returns a new set built by duplicating the set, removing every
	# element that appears in the given enumerable object.
	def -(enum)
	enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
	dup.subtract(enum)
	end
	alias difference - ##

	# Returns a new set containing elements common to the set and the
	# given enumerable object.
	def &(enum)
	enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
	n = self.class.new
	enum.each { \|o\| n.add(o) if include?(o) }
	n
	end
	alias intersection & ##

	# Returns a new set containing elements exclusive between the set
	# and the given enumerable object. (set ^ enum) is equivalent to
	# ((set \| enum) - (set & enum)).
	def ^(enum)
	enum.is_a?(Enumerable) or raise ArgumentError, "value must be enumerable"
	n = DLTKBuiltinGeneratorSet.new(enum)
	each { \|o\| if n.include?(o) then n.delete(o) else n.add(o) end }
	n
	end

	# Returns true if two sets are equal. The equality of each couple
	# of elements is defined according to Object#eql?.
	def ==(set)
	equal?(set) and return true

	set.is_a?(DLTKBuiltinGeneratorSet) && size == set.size or return false

	hash = @hash.dup
	set.all? { \|o\| hash.include?(o) }
	end

	def hash # :nodoc:
	@hash.hash
	end

	def eql?(o) # :nodoc:
	return false unless o.is_a?(DLTKBuiltinGeneratorSet)
	@hash.eql?(o.instance_eval{@hash})
	end

	# Classifies the set by the return value of the given block and
	# returns a hash of {value => set of elements} pairs. The block is
	# called once for each element of the set, passing the element as
	# parameter.
	#
	# e.g.:
	#
	# require 'set'
	# files = Set.new(Dir.glob("*.rb"))
	# hash = files.classify { \|f\| File.mtime(f).year }
	# p hash # => {2000=>#<Set: {"a.rb", "b.rb"}>,
	# # 2001=>#<Set: {"c.rb", "d.rb", "e.rb"}>,
	# # 2002=>#<Set: {"f.rb"}>}
	def classify # :yields: o
	h = {}

	each { \|i\|
	x = yield(i)
	(h[x] \|\|= self.class.new).add(i)
	}

	h
	end

	# Divides the set into a set of subsets according to the commonality
	# defined by the given block.
	#
	# If the arity of the block is 2, elements o1 and o2 are in common
	# if block.call(o1, o2) is true. Otherwise, elements o1 and o2 are
	# in common if block.call(o1) == block.call(o2).
	#
	# e.g.:
	#
	# require 'set'
	# numbers = Set[1, 3, 4, 6, 9, 10, 11]
	# set = numbers.divide { \|i,j\| (i - j).abs == 1 }
	# p set # => #<Set: {#<Set: {1}>,
	# # #<Set: {11, 9, 10}>,
	# # #<Set: {3, 4}>,
	# # #<Set: {6}>}>
	def divide(&func)
	if func.arity == 2
	require 'tsort'

	class << dig = {} # :nodoc:
	include TSort

	alias tsort_each_node each_key
	def tsort_each_child(node, &block)
	fetch(node).each(&block)
	end
	end

	each { \|u\|
	dig[u] = a = []
	each{ \|v\| func.call(u, v) and a << v }
	}

	set = DLTKBuiltinGeneratorSet.new()
	dig.each_strongly_connected_component { \|css\|
	set.add(self.class.new(css))
	}
	set
	else
	DLTKBuiltinGeneratorSet.new(classify(&func).values)
	end
	end

	InspectKey = :__inspect_key__ # :nodoc:

	# Returns a string containing a human-readable representation of the
	# set. ("#<Set: {element1, element2, ...}>")
	def inspect
	ids = (Thread.current[InspectKey] \|\|= [])

	if ids.include?(object_id)
	return sprintf('#<%s: {...}>', self.class.name)
	end

	begin
	ids << object_id
	return sprintf('#<%s: {%s}>', self.class, to_a.inspect[1..-2])
	ensure
	ids.pop
	end
	end

	def pretty_print(pp) # :nodoc:
	pp.text sprintf('#<%s: {', self.class.name)
	pp.nest(1) {
	pp.seplist(self) { \|o\|
	pp.pp o
	}
	}
	pp.text "}>"
	end

	def pretty_print_cycle(pp) # :nodoc:
	pp.text sprintf('#<%s: {%s}>', self.class.name, empty? ? '' : '...')
	end
	end

	class DLTKBuiltinGenerator

	def collectMethod(hash, methodName, arity)
	hash.add methodName + '###' + arity.to_s
	end

	def put_methods!(metaclass)
	result = DLTKBuiltinGeneratorSet.new
	modules = metaclass.included_modules

	methods = metaclass.public_instance_methods(false)
	for mod in modules do; methods -= mod.public_instance_methods(true); end

	$data << "\t\npublic\n"
	for method in methods do
	arity = metaclass.instance_method(method).arity
	collectMethod(result, method.to_s, arity)
	put_rdoc(metaclass.name + "." + method.to_s)
	$data << <<-"END"
	def #{method.to_s}(#{generateArgs(arity)})
	end

	END
	end

	methods = metaclass.protected_instance_methods(false)
	for mod in modules do;
	if mod.respond_to?(:protected_instance_methods) then
	methods -= mod.protected_instance_methods(true)
	end
	end

	$data << "\t\nprotected\n"
	for method in methods do
	put_rdoc(metaclass.name + "." + method.to_s)
	arity = metaclass.instance_method(method).arity
	collectMethod(result, method.to_s, arity)
	$data << <<-"END"
	def #{method.to_s}(#{generateArgs(arity)})
	end

	END
	end


	methods = metaclass.private_instance_methods(false)
	for mod in modules do;
	if mod.respond_to?(:private_instance_methods) then
	methods -= mod.private_instance_methods(true)
	end
	end

	$data << "\t\nprivate\n"
	for method in methods do
	put_rdoc(metaclass.name + "." + method.to_s)
	arity = metaclass.instance_method(method).arity
	collectMethod(result, method.to_s, arity)
	$data << <<-"END"
	def #{method.to_s}(#{generateArgs(arity)})
	end

	END
	end

	return result

	end

	def generateArgs(arity)
	if arity < 0 then
	return "*args"
	end
	result = ""
	for i in 1..arity do
	result << "arg" + i.to_s
	if i != arity then
	result << ", "
	end
	end
	result
	end

	def put_singleton_methods!(metaclass, instanceMethods)
	# if (metaclass.is_a?(Class))
	# $data << <<-"END2"
	# class << self
	# END2
	# else
	# $data << "\t\tprivate\n"
	# end
	# ms = (metaclass.public_methods(false) - Class.instance_methods(false)).each { \|m\|
	ms = (metaclass.singleton_methods(false)).each { \|m\|
	arity = metaclass.method(m).arity
	if (!instanceMethods.include?(m.to_s + '###' + arity.to_s)) then
	$data << <<-"END2"
	def self.#{m.to_s}(#{generateArgs(arity)})
	end

	END2
	end
	}
	# if (metaclass.is_a?(Class))
	# $data << <<-"END2"
	# end
	# END2
	# end
	end

	def put_included_modules!(metaclass)

	ms = (metaclass.included_modules -
	((metaclass.is_a?(Class) &&
	metaclass.superclass &&
	metaclass.superclass.included_modules) \|\| []))

	for in_mod in ms do
	$data << <<-"END"
	include #{in_mod.name}
	END
	end

	end

	def put_singleton_included_modules!(metaclass)
	$data << <<-"END2"
	class << ::#{metaclass.name}
	END2

	sup = (class << metaclass; superclass; end)
	# ms = ((class << metaclass; included_modules; end) -
	# ((sup && sup.included_modules) \|\| []))
	ms = (class << metaclass; included_modules; end)


	for in_mod in ms do
	$data << <<-"END"
	include #{in_mod.name}
	END
	end

	$data << <<-"END2"
	end
	END2

	end

	def put_constants(metaclass)
	#return
	consts = DLTKBuiltinGeneratorSet.new(metaclass.constants)
	ancestors = metaclass.ancestors
	for m in ancestors
	if m != metaclass
	consts -= DLTKBuiltinGeneratorSet.new(m.constants)
	end
	end
	for c in consts
	v = metaclass.const_get(c)
	if !@classesAndModules.include?(v)
	$data << c.to_s + '=' + v.class.to_s + ".new\n"
	end
	end
	end

	def put_superclass!(metaclass)
	return if metaclass.superclass.nil?
	$data << <<-"END"
	#{const_for(metaclass)}.setSuperClass(#{const_for(metaclass.superclass)});
	END
	end

	#def put_singleton_superclass!(metaclass)
	# $data << <<-"END"
	# #{const_for_singleton(metaclass)}.setSuperClass(#{const_for(metaclass.class)});
	# END
	#end



	def dumpClass(klass)
	name = klass.name
	if name == "NameError::message" \|\| name == "fatal" then
	return
	end
	sc = klass.superclass
	if sc then scname = " < ::" + sc.name else scname = "" end
	# methods = klass.instance_methods(false)
	put_rdoc(name)
	$data << <<-"END"

	class #{name} #{scname}
	END
	put_included_modules!(klass)
	if sc then
	# skip Object - they are generated later
	put_constants(klass)
	end
	put_singleton_included_modules!(klass)
	instanceMethods = put_methods!(klass)
	put_singleton_methods!(klass, instanceMethods)
	$data << <<-"END"
	end

	END
	end

	def put_rdoc(name)
	return
	print "Getting doc for " + name + "\n"
	rdoc = `d:\\instantrails\\ruby\\bin\\ri.bat \"#{name}\" -f html`
	rdoc.to_a.each { \|line\|
	$data << "#" + line
	}
	end

	def dumpModule(klass)
	name = klass.name
	# methods = klass.instance_methods(false)
	put_rdoc(name)
	$data << <<-"END"

	module #{name}
	END
	put_included_modules!(klass)
	put_constants(klass)
	instanceMethods = put_methods!(klass)
	put_singleton_methods!(klass, instanceMethods)
	$data << <<-"END"
	end

	END
	end

	def dumpVariables
	$data << "# Global variables\n"
	global_variables.each { \|var\|
	$data << <<-"END"
	#{var.to_s} = #{var.to_s}
	END
	}
	end


	def process_all
	classes = DLTKBuiltinGeneratorSet.new
	known_modules = DLTKBuiltinGeneratorSet.new
	ObjectSpace.each_object do \|o\|
	if (o.respond_to?('name')) then
	className = o.name
	if className == 'DLTKBuiltinGenerator' \|\| className == 'DLTKBuiltinGeneratorSet' \|\| className == nil then
	next
	end
	end
	classes << o if o.is_a?(Class)
	known_modules << o if o.is_a?(Module)
	end
	@classesAndModules = known_modules + classes
	known_modules = (known_modules - classes).to_a
	classes = classes.to_a.sort { \|a,b\| a.name <=> b.name }

	classes.each { \|c\|
	$data = ""
	dumpClass(c)
	filename = c.name
	pos = filename.index(':')
	if pos then
	filename = filename.slice(0..pos-1)
	#puts "sliced " + filename
	end
	file = filename + ".rb"
	puts "#### DLTK RUBY BUILTINS ####" + file + "\n"
	puts $data
	#File.open(file, 'a') {\|f\| f.write $data}
	}
	known_modules.each { \|c\|
	$data = ""
	dumpModule(c)
	filename = c.name
	pos = filename.index(':')
	if pos then
	filename = filename.slice(0..pos-1)
	#puts "sliced " + filename
	end
	file = filename + ".rb"
	puts "#### DLTK RUBY BUILTINS ####" + file + "\n"
	puts $data
	#File.open(file, 'a') {\|f\| f.write $data}
	}

	ccc = []
	Module.constants.each { \|x\|
	ccc << x.to_s
	}
	ccc.delete('DLTKBuiltinGenerator')
	ccc.delete('DLTKBuiltinGeneratorSet')
	known_modules.each { \|x\|
	ccc.delete(x.to_s)
	}
	classes.each { \|x\|
	ccc.delete(x.to_s)
	}

	puts "#### DLTK RUBY BUILTINS ####constants.rb\n\n\n"
	ccc.each { \|bar\|
	puts "#{bar} = #{Module.const_get(bar).class.to_s}.new"
	}

	end

	end

	g = DLTKBuiltinGenerator.new
	g.process_all

	# vim: noexpandtab tabstop=4 sts=0 sw=4