nodewrap 0.5.0

data/ext/cached/ruby-1.8.6/nodeinfo.h

@@ -0,0 +1,64 @@
+#ifndef nodeinfo_h
+#define nodeinfo_h
+
+#include "ruby.h"
+#include "node.h"
+#include "nodewrap.h"
+
+enum Node_Elem_Name
+{
+  NEN_NONE,
+  NEN_1ST,
+  NEN_2ND,
+  NEN_AID,
+  NEN_ALEN,
+  NEN_ARGC,
+  NEN_ARGS,
+  NEN_BEG,
+  NEN_BODY,
+  NEN_CFLAG,
+  NEN_CFNC,
+  NEN_CLSS,
+  NEN_CNT,
+  NEN_COND,
+  NEN_CPATH,
+  NEN_CVAL,
+  NEN_DEFN,
+  NEN_ELSE,
+  NEN_END,
+  NEN_ENSR,
+  NEN_ENTRY,
+  NEN_FRML,
+  NEN_HEAD,
+  NEN_IBDY,
+  NEN_ITER,
+  NEN_LIT,
+  NEN_MID,
+  NEN_MODL,
+  NEN_NEXT,
+  NEN_NOEX,
+  NEN_NTH,
+  NEN_OPT,
+  NEN_ORIG,
+  NEN_RECV,
+  NEN_RESQ,
+  NEN_REST,
+  NEN_RVAL,
+  NEN_STATE,
+  NEN_STTS,
+  NEN_SUPER,
+  NEN_TAG,
+  NEN_TBL,
+  NEN_TVAL,
+  NEN_VALUE,
+  NEN_VAR,
+  NEN_VID,
+};
+
+VALUE dump_node_elem(enum Node_Elem_Name nen, NODE * n, VALUE node_hash);
+void load_node_elem(enum Node_Elem_Name nen, VALUE v, NODE * n, VALUE node_hash, VALUE id_hash);
+VALUE node_s_members(VALUE klass);
+void define_node_subclass_methods();
+
+#endif
+

data/ext/classpath.c

@@ -0,0 +1,42 @@
+#include "classpath.h"
+
+VALUE
+class2path(VALUE klass)
+{
+    VALUE path = rb_class_path(klass);
+    char *n = RSTRING_PTR(path);
+
+    if (n[0] == '#') {
+	rb_raise(rb_eTypeError, "can't dump anonymous %s %s",
+		 (TYPE(klass) == T_CLASS ? "class" : "module"),
+		 n);
+    }
+    if (rb_path2class(n) != rb_class_real(klass)) {
+	rb_raise(rb_eTypeError, "%s can't be referred", n);
+    }
+    return path;
+}
+
+VALUE
+path2class(const char *path)
+{
+    VALUE v = rb_path2class(path);
+
+    if (TYPE(v) != T_CLASS) {
+	rb_raise(rb_eArgError, "%s does not refer class", path);
+    }
+    return v;
+}
+
+VALUE
+path2module(const char *path)
+{
+    VALUE v = rb_path2class(path);
+
+    if (TYPE(v) != T_MODULE) {
+	rb_raise(rb_eArgError, "%s does not refer module", path);
+    }
+    return v;
+}
+
+

data/ext/classpath.c.rpp

@@ -0,0 +1,28 @@
+#include "classpath.h"
+
+#ruby <<END
+require 'ruby_source_dir'
+
+marshal_c_location = "#{RUBY_SOURCE_DIR}/marshal.c"
+File.open(marshal_c_location) do |marshal_c|
+  write = false
+  stopwrite = false
+  while (line = marshal_c.gets) != nil do
+    case line
+    when /^(path2class|path2module|class2path)/
+      puts "VALUE" if not write
+      write = true
+      stopwrite = false
+    when /^\}/
+      stopwrite = true if write
+    end
+    puts line if write
+    if stopwrite then
+      stopwrite = false
+      write = false
+      puts ''
+    end
+  end
+end
+END
+

data/ext/classpath.h

@@ -0,0 +1,17 @@
+#ifndef CLASSPATH_H
+#define CLASSPATH_H
+
+#include "ruby.h"
+
+VALUE class2path(
+
+);
+VALUE path2class(
+
+);
+VALUE path2module(
+
+);
+
+#endif
+

data/ext/classpath.h.rpp

@@ -0,0 +1,35 @@
+#ifndef CLASSPATH_H
+#define CLASSPATH_H
+
+#include "ruby.h"
+
+#ruby <<END
+require 'ruby_source_dir'
+
+defn = nil
+marshal_c_location = "#{RUBY_SOURCE_DIR}/marshal.c"
+File.open(marshal_c_location) do |marshal_c|
+  write = false
+  while (line = marshal_c.gets) != nil do
+    case line
+    when /^(path2class|path2module|class2path)/
+      record_defn = true
+      defn = []
+    when /^\{/
+      if record_defn then
+        record_defn = false
+        puts "VALUE #{defn[0].sub(/\(.*/, '')}("
+        vars = defn[1..-1].map { |d| d.sub(/;.*/, '') }
+        puts vars.join(",\n")
+        puts ");"
+      end
+    end
+    if record_defn then
+      defn << line.chomp
+    end
+  end
+end
+END
+
+#endif
+

data/ext/evalinfo.h

@@ -0,0 +1,21 @@
+#ifndef evalinfo__h_
+#define evalinfo__h_
+
+#include "ruby_version.h"
+
+#ifdef RUBY_HAS_YARV
+#include "yarvcore.h"
+#else
+#include "env.h"
+#endif
+
+struct METHOD {
+    VALUE klass, rklass;
+    VALUE recv;
+    ID id, oid;
+    NODE *body;
+};
+
+
+#endif
+

data/ext/evalinfo.h.rpp

@@ -0,0 +1,49 @@
+#ifndef evalinfo__h_
+#define evalinfo__h_
+
+#include "ruby_version.h"
+
+#ifdef RUBY_HAS_YARV
+#include "yarvcore.h"
+#else
+#include "env.h"
+#endif
+
+#ruby <<END
+  require 'ruby_source_dir'
+  proc_c_location = "#{RUBY_SOURCE_DIR}/proc.c"
+  vm_c_location = "#{RUBY_SOURCE_DIR}/vm.c"
+  eval_c_location = "#{RUBY_SOURCE_DIR}/eval.c"
+
+  [ proc_c_location, vm_c_location, eval_c_location ].each do |file|
+    next if not File.exist?(file)
+
+    File.open(file) do |eval_c|
+      write = false
+      stopwrite = false
+      while (line = eval_c.gets) != nil do
+        case line
+        when /^struct (METHOD|BLOCK)/
+          write = true
+          stopwrite = false
+        when /^compile_error/
+          puts 'static void'
+          write = true
+          stopwrite = false
+        when /^\}/
+          stopwrite = true if write
+        end
+        puts line if write
+        if stopwrite then
+          stopwrite = false
+          write = false
+          puts ''
+        end
+      end
+    end
+  end
+  nil
+END
+
+#endif
+

data/ext/extconf.rb

@@ -0,0 +1,68 @@
+require 'mkmf'
+
+cmdline_ruby_source_path = arg_config('--ruby-source-path')
+configured_ruby_source_dir = nil
+begin
+  require 'ruby_source_dir'
+  configured_ruby_source_dir = RUBY_SOURCE_DIR
+rescue InstallError
+end
+
+rb_files = Dir['*.rb']
+
+rpp_files = Dir['*.rpp']
+generated_files = rpp_files.map { |f| f.sub(/\.rpp$/, '') }
+
+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}") }
+$CFLAGS << ' -Wall -g'
+create_makefile('nodewrap')
+
+append_to_makefile = ''
+
+# (nil and not configured => cached
+# '' => cached
+# not configured => cached
+
+if (not cmdline_ruby_source_path and not configured_ruby_source_dir) or \
+   cmdline_ruby_source_path == '' then
+
+rpp_files.each do |rpp_file|
+dest_file = rpp_file.sub(/\.rpp$/, '')
+append_to_makefile << <<END
+#{dest_file}: #{rpp_file} #{rb_files.join(' ')}
+	@$(RUBY) -rftools -e 'File.copy("cached/ruby-#{RUBY_VERSION}/#{dest_file}", ".", true)'
+END
+end
+
+else
+
+rpp_files.each do |rpp_file|
+dest_file = rpp_file.sub(/\.rpp$/, '')
+append_to_makefile << <<END
+#{dest_file}: #{rpp_file} #{rb_files.join(' ')}
+	$(RUBY) rubypp.rb #{rpp_file} #{dest_file}
+END
+end
+
+
+end
+
+generated_headers = generated_files.select { |x| x =~ /\.h$/ }
+append_to_makefile << <<END
+$(OBJS): #{generated_headers.join(' ')}
+clean: clean_generated_files
+clean_generated_files:
+	@$(RM) #{generated_files.join(' ')}
+END
+
+File.open('Makefile', 'a') do |makefile|
+  makefile.puts(append_to_makefile)
+end
+

data/ext/generate.rb

@@ -0,0 +1,201 @@
+require 'rbconfig'
+require 'ruby_source_dir'
+
+class Pattern
+  attr_reader :search_files
+
+  def initialize(*search_files)
+    @search_files = search_files
+  end
+
+  def matches_start(str)
+    return false
+  end
+
+  def matches_end(str)
+    return true
+  end
+
+  def dump(captured, out)
+    captured.each do |line|
+      out.puts line
+    end
+    out.puts ''
+  end
+end
+
+class FunctionDefinitionPattern < Pattern
+  def initialize(return_type, name, *search_files)
+    @return_type = return_type
+    @name = name
+    super(*search_files)
+  end
+
+  def matches_start(str)
+    return str =~ /^#{@name}/
+  end
+
+  def matches_end(str)
+    return str =~ /^\}/
+  end
+
+  def dump(captured, out)
+    out.puts @return_type
+    super(captured, out)
+  end
+end
+
+def FunctionDefinition(return_type, name, *search_files)
+  return FunctionDefinitionPattern.new(return_type, name, *search_files)
+end
+
+class FunctionDeclarationPattern < Pattern
+  def initialize(name, *search_files)
+    @name = name
+    super(*search_files)
+  end
+end
+
+def FunctionDeclaration(name, *search_files)
+  return FunctionDeclarationPattern.new(name, *search_files)
+end
+
+class StructPattern < Pattern
+  def initialize(name, *search_files)
+    @name = name
+    super(*search_files)
+  end
+end
+
+def Struct(name, *search_files)
+  return StructPattern.new(name, *search_files)
+end
+
+class IncludePattern < Pattern
+  def initialize(name, use_quotes=false)
+    @name = name
+    @use_quotes = false
+    super()
+  end
+
+  def dump(captured, out)
+    if @use_quotes then
+      out.puts "#include \"#{@name}\""
+    else
+      out.puts "#include <#{@name}>"
+    end
+  end
+end
+
+def Include(name, use_quotes=false)
+  return IncludePattern.new(name, use_quotes)
+end
+
+class IfDefPattern
+  def initialize(name, iftrue, iffalse)
+    @name = name
+    @iftrue = iftrue
+    @iffalse = iffalse
+    super()
+  end
+
+  def matches_start(str)
+    return @iftrue.matches_start(str) || @iffalse.matches_start(str)
+  end
+
+  def matches_end(str)
+    return @iftrue.matches_end(str) || @iffalse.matches_end(str)
+  end
+
+  def dump(captured, out)
+    out.puts "#ifdef #{@name}"
+    @iftrue.dump(captured, out)
+    out.puts "#else"
+    @iffalse.dump(captured, out)
+    out.puts "#endif"
+  end
+end
+
+def IfDefined(name, iftrue, iffalse)
+  return IfDefPattern.new(name, iftrue, iffalse)
+end
+
+class BlankLinePattern < Pattern
+  def initialize()
+    super()
+  end
+
+  def dump(captured, out)
+    out.puts
+  end
+end
+
+def BlankLine
+  return BlankLinePattern.new
+end
+
+
+def generate(patterns, io, out)
+  found = {}
+  using = {}
+  captured = {}
+
+  while (line = io.gets) != nil do
+    patterns.each do |pattern|
+      if pattern.matches_start(line) then
+        found[pattern] = true
+        using[pattern] = true
+      end
+
+      if using[pattern] then
+        captured[pattern] ||= []
+        captured[pattern] << line
+      end
+
+      if using[pattern] and pattern.matches_end(line) then
+        using.delete(pattern)
+      end
+    end
+  end
+
+  patterns.each do |pattern|
+    pattern.dump(captured[pattern], out)
+  end
+end
+
+
+
+G = {
+  'classpath.c' => [
+    Include('classpath.h', true),
+    BlankLine(),
+    FunctionDefinition('VALUE', 'path2class', 'marshal.c'),
+    FunctionDefinition('VALUE', 'path2module', 'marshal.c'),
+    FunctionDefinition('VALUE', 'class2path', 'marshal.c'),
+  ],
+  'classpath.h' => [
+    Include('ruby.h'),
+    FunctionDeclaration('path2class', 'marshal.c'),
+    FunctionDeclaration('path2module', 'marshal.c'),
+    FunctionDeclaration('class2path', 'marshal.c'),
+  ],
+  'global_entry.h' => [
+    Include('ruby.h'),
+    Struct('global_entry', 'variable.c'),
+  ],
+  'evalinfo.h' => [
+    Include('ruby_version.h'),
+    IfDefined(
+        'RUBY_HAS_YARV',
+        [ Include('yarvcore.h') ],
+        [ Include('env.h') ]
+    ),
+    Struct('METHOD', 'eval.c', 'proc.c'),
+    Struct('BLOCK', 'eval.c'),
+  ],
+}
+
+File.open("#{RUBY_SOURCE_DIR}/marshal.c") do |marshal_c|
+  generate(G['classpath.c'], marshal_c, $stdout)
+end
+