ruby-internal 0.6.0

data/ext/internal/vm/vm.c

@@ -0,0 +1,55 @@
+#include <ruby.h>
+
+#ifdef RUBY_VM
+
+#include "vm_core.h"
+
+extern rb_vm_t * ruby_current_vm;
+
+/*
+ * call-seq:
+ *   RubyVM.current => RubyVM
+ *
+ * Returns the current ruby VM.
+ */
+static VALUE vm_current(VALUE klass)
+{
+  return ruby_current_vm->self;
+}
+
+/*
+ * call-seq:
+ *   ruby_vm.top_self
+ *
+ * Returns the VM's "top self".
+ */
+static VALUE vm_top_self(VALUE self)
+{
+  rb_vm_t * vm;
+  
+  Data_Get_Struct(self, rb_vm_t, vm);
+
+  return vm->top_self;
+}
+
+#endif
+
+void Init_vm(void)
+{
+#ifdef RUBY_VM
+  VALUE rb_cRubyVM;
+
+  if(!rb_const_defined(rb_cObject, rb_intern("RubyVM")))
+  {
+    rb_define_const(
+        rb_cObject,
+        "RubyVM",
+        rb_const_get(rb_cObject, rb_intern("VM")));
+  }
+
+  rb_cRubyVM = rb_define_class("RubyVM", rb_cObject);
+  rb_define_singleton_method(rb_cRubyVM, "current", vm_current, 0);
+  rb_define_method(rb_cRubyVM, "top_self", vm_top_self, 0);
+#endif
+}
+

data/ext/mkmf-ruby-internal.rb

@@ -0,0 +1,111 @@
+require 'mkmf'
+
+using_cached_files = enable_config('cached-files')
+if using_cached_files then
+  # if --enable-cached-files was specified on the command line, then use cached
+  # files
+  USING_CACHED_FILES = true
+else
+  ruby_source_path = arg_config('--ruby-source-path')
+  if ruby_source_path.nil? then
+    class SetupError < StandardError; end
+
+    # if the user did not specify the source dir, then see if we have one
+    # configured
+    begin
+      require 'ruby_source_dir'
+      # if we got here, then we successfuly loaded the configuration
+    rescue SetupError
+      # otherwise, assume we are using cached files
+      USING_CACHED_FILES = true
+    end
+  else
+    # the user did specify the source path
+    USING_CACHED_FILES = false
+    RUBY_SOURCE_DIR = ruby_source_path
+  end
+end
+
+def create_ruby_internal_makefile(name)
+  rb_files = Dir['*.rb']
+  rpp_files = Dir['*.rpp']
+  generated_files = rpp_files.map { |f| f.sub(/\.rpp$/, '') }
+
+  # Append the generated C files to the list of source files
+  srcs = Dir['*.c']
+  generated_files.each do |f|
+    if f =~ /\.c$/ then
+      srcs << f
+    end
+  end
+  srcs.uniq!
+  $objs = srcs.map { |f| f.sub(/\.c$/, ".#{$OBJEXT}") }
+
+  # Turn on warnings and debugging by default on gcc
+  if CONFIG['CC'] == 'gcc' then
+    $CFLAGS << ' -Wall -g'
+  end
+
+  create_makefile(name)
+
+  append_to_makefile = ''
+
+  base_dir = File.dirname(__FILE__)
+
+  if USING_CACHED_FILES then
+
+    subdir = File.expand_path(File.dirname($0))
+    subdir = subdir.gsub(File.expand_path(base_dir), '')
+    cached_dir = File.join('cached', "ruby-#{RUBY_VERSION}")
+
+    # -- Using cached files --
+    rpp_files.each do |rpp_file|
+      dest_file = rpp_file.sub(/\.rpp$/, '')
+      src_file = File.join(base_dir, cached_dir, subdir, File.basename(dest_file))
+      append_to_makefile << <<END
+#{dest_file}: #{src_file}
+\t@$(RUBY) -e 'begin; require "fileutils"; rescue LoadError; require "ftools"; FileUtils = File end; FileUtils.copy("#{src_file}", ".", :verbose => true)'
+END
+    end
+  else
+    # -- Generating files --
+    rpp_files.each do |rpp_file|
+      dest_file = rpp_file.sub(/\.rpp$/, '')
+      append_to_makefile << <<END
+#{dest_file}: #{rpp_file} #{rb_files.join(' ')}
+\t$(RUBY) #{base_dir}/rubypp.rb #{rpp_file} #{dest_file}
+END
+    end
+
+  end
+
+  # Dependencies
+  # TODO: we could be smarter about this
+  generated_headers = generated_files.select { |x| x =~ /\.h$/ }
+  generated_incs = generated_files.select { |x| x =~ /\.inc$/ }
+  append_to_makefile << <<END
+$(OBJS): #{generated_headers.join(' ')} #{generated_incs.join(' ')}
+clean: clean_generated_files
+clean_generated_files:
+\t@$(RM) #{generated_files.join(' ')}
+generated_files: #{generated_files.join(' ')}
+END
+
+  # Append it all to the makefile
+  File.open('Makefile', 'a') do |makefile|
+    makefile.puts(append_to_makefile)
+  end
+end
+
+base_dir = File.dirname(__FILE__)
+$CPPFLAGS << " -I#{base_dir}"
+
+ruby_version_code = RUBY_VERSION.gsub(/\./, '').to_i
+if ruby_version_code >= 190 then
+  if USING_CACHED_FILES then
+    $CPPFLAGS << " -I#{base_dir}/internal/yarv-headers"
+  else
+    $CPPFLAGS << " -I#{RUBY_SOURCE_DIR}"
+  end
+end
+

data/ext/ruby_source_dir.rb

@@ -0,0 +1,24 @@
+wd = Dir.pwd()
+metaconfig_dir = File.join(File.dirname(__FILE__), '..')
+Dir.chdir metaconfig_dir
+begin
+  require 'setup.rb'
+  require 'rbconfig'
+  config = ConfigTable.new(Config::CONFIG)
+  config.load_standard_entries
+  config.load_script 'metaconfig'
+  config.load_savefile
+ensure
+  Dir.chdir(wd)
+end
+
+RUBY_SOURCE_DIR = config['ruby-source-path']
+RUBY_INCLUDE_DIR = config['ruby-include-path']
+USING_CACHED_FILES = config['cached-files'] == 'yes'
+
+if __FILE__ == $0 then
+  puts "Using cached files: #{USING_CACHED_FILES}"
+  puts "Ruby source dir: #{RUBY_SOURCE_DIR}"
+  puts "Ruby include dir: #{RUBY_INCLUDE_DIR}"
+end
+

data/ext/rubypp.rb

@@ -0,0 +1,97 @@
+class Preprocessor
+  def initialize(input, output, filename)
+    @input = input
+    @output = output
+    @filename = filename
+    @linenum = 1
+  end
+
+  def getline
+    line = @input.gets
+    @linenum += 1 if not line.nil?
+    return line
+  end
+
+  def preprocess
+    success = false
+    begin
+      loop do
+        line = getline
+        break if line.nil?
+        case line
+        when /(.*[^\\]|^)\#\{(.*?)\}(.*)/
+          puts "#{$1}#{evaluate($2, @linenum)}#{$3}"
+        when /^\#ruby\s+<<(.*)/
+          marker = $1
+          str = ''
+          evalstart = @linenum
+          loop do
+            line = getline
+            if line.nil? then
+              raise "End of input without #{marker}"
+            end
+            break if line.chomp == marker
+            str << line
+          end
+          result = evaluate(str, evalstart)
+          puts result if not result.nil?
+        when /^\#ruby\s+(.*)/
+          str = line = $1
+          while line[-1] == ?\\
+            str.chop!
+            line = getline
+            break if line.nil?
+            line.chomp!
+            str << line
+          end
+          result = evaluate(str, @linenum)
+          puts result if not result.nil?
+        else
+          puts line
+        end
+      end
+      success = true
+    ensure
+      if not success then
+        $stderr.puts "Error on line #{@linenum}:"
+      end
+    end
+  end
+
+  def evaluate(str, linenum)
+    result = eval(str, TOPLEVEL_BINDING, @filename, linenum)
+    success = true
+    return result
+  end
+
+  def puts(line)
+    @output.puts(line)
+  end
+end
+
+def puts(line)
+  $preprocessor.puts(line)
+end
+
+def rubypp(input_file, output_file)
+  input = input_file ? File.open(input_file) : $stdin
+  output = output_file ? File.open(output_file, 'w') : $stdout
+
+  success = false
+  begin
+    $preprocessor = Preprocessor.new(input, output, input_file || "(stdin)")
+    $preprocessor.preprocess()
+    success = true
+  ensure
+    if not success then
+      File.unlink(output_file) rescue Errno::ENOENT
+    end
+  end
+end
+
+if __FILE__ == $0 then
+  input_file = ARGV[0]
+  output_file = ARGV[1]
+  rubypp(input_file, output_file)
+end
+

data/generate_rdoc.rb

@@ -0,0 +1,33 @@
+require 'find'
+
+def list_files(dir, pattern)
+  arr = []
+  Find.find(dir) do |filename|
+    if filename =~ pattern then
+      arr.push(filename)
+    end
+  end
+  return arr
+end
+
+def generate_rdoc(*options)
+  begin
+    require 'rdoc/rdoc'
+  rescue LoadError
+    puts "WARNING: RDoc not installed; skipping generation of docs"
+    return
+  end
+
+  r = RDoc::RDoc.new
+  rdoc_files = []
+  rdoc_files.concat [ 'README' ]
+  rdoc_files.concat list_files('lib', /\.rb$/) if File.exist?('lib')
+  rdoc_files.concat list_files('ext', /\.c$/)  if File.exist?('ext')
+  rdoc_files.reject! { |file| file =~ %r{^ext/cached/} }
+  r.document(options + rdoc_files)
+end
+
+if __FILE__ == $0 then
+  generate_rdoc(*ARGV)
+end
+

data/lib/internal/binding.rb

@@ -0,0 +1 @@
+require 'internal/binding/binding'

data/lib/internal/classtree.rb

@@ -0,0 +1,55 @@
+require 'internal/object'
+require 'internal/module'
+
+class Object
+  def classtree(s = '', prefix = '', obj=self, graphed={})
+    # if Module == obj.class.class then
+    #   s << "included module "
+    # elsif obj.singleton? then
+    #   s << "singleton class "
+    # elsif Class === obj then
+    #   s << "class "
+    # end
+    s << "#{obj}"
+    if graphed[obj] then
+      s << " (*)\n"
+      return s
+    end
+    s << "\n"
+    graphed[obj] = true
+    return if Kernel == obj
+    subtree = (Module === obj) && (obj.real_superclass)
+    s << "#{prefix}#{subtree ? '|-' : '+-'}class = "
+    classtree(s, prefix + (subtree ? '| ' : '  '), obj.real_class, graphed)
+    if subtree then
+      s << "#{prefix}+-super = "
+      classtree(s, prefix + '  ', obj.real_superclass, graphed)
+    end
+    return s
+  end
+end
+
+if __FILE__ == $0 then
+  module M
+  end
+
+  class Foo
+    class << self; end
+    include M
+  end
+
+  class Bar < Foo
+  end
+
+  class Baz
+    class << self; @foo = 1; end
+    def self.foo; end
+  end
+
+  b = Bar.new
+  b.classtree($stderr)
+
+  b = Baz.new
+  b.classtree($stderr)
+end
+

data/lib/internal/debug.rb

@@ -0,0 +1,16 @@
+require 'internal/node'
+require 'internal/node/as_expression'
+require 'internal/node/pp'
+
+module Nodewrap
+  def printdebug(&block)
+    puts "#{caller[0]}: #{block.body.as_expression} => #{block.call}"
+  end
+end
+
+if __FILE__ == $0 then
+  include Nodewrap
+  a = 41
+  printdebug { a + 1 }
+end
+

data/lib/internal/method.rb

@@ -0,0 +1 @@
+require 'internal/method/method'

data/lib/internal/method/as_code.rb

@@ -0,0 +1,33 @@
+require 'internal/node/as_code'
+require 'internal/vm/iseq/as_code'
+require 'internal/method'
+require 'internal/method/signature'
+
+module MethodAsCode
+  def as_code(indent=0, name=nil)
+    sig = self.signature
+    if self.body.respond_to?(:body) then
+      # YARV
+      body_expression = self.body.body.as_code(indent+1)
+    else
+      # pre-YARV
+      body_expression = self.body ? self.body.as_code(indent+1) : ''
+    end
+    name ||= sig.name
+    s = "#{'  '*indent}def #{name}(#{sig.param_list})\n"
+    if body_expression then
+      s += "#{body_expression}\n"
+    end
+    s += "#{'  '*indent}end"
+    return s
+  end
+end
+
+class Method
+  include MethodAsCode
+end
+
+class UnboundMethod
+  include MethodAsCode
+end
+

data/lib/internal/method/as_expression.rb

@@ -0,0 +1,34 @@
+require 'internal/node/as_expression'
+require 'internal/vm/iseq/as_expression'
+require 'internal/method/signature'
+require 'internal/method'
+
+module MethodAsExpression
+  # It doesn't entirely make sense to have Method#as_expression, because
+  # a method definition isn't an expression.  We have one anyway, to be
+  # consistent with Proc.
+  def as_expression
+    sig = self.signature
+    if self.body.respond_to?(:body) then
+      # YARV
+      body_expression = self.body.body.as_expression
+    else
+      # pre-YARV
+      body_expression = self.body.as_expression
+    end
+    if body_expression then
+      return "def #{sig.name}(#{sig.param_list}); #{body_expression}; end"
+    else
+      return "def #{sig.name}(#{sig.param_list}); end"
+    end
+  end
+end
+
+class Method
+  include MethodAsExpression
+end
+
+class UnboundMethod
+  include MethodAsExpression
+end
+