groonga 0.0.1

data/ext/rb-grn.h

@@ -0,0 +1,346 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#ifndef __RB_GRN_H__
+#define __RB_GRN_H__
+
+#include <ruby.h>
+
+#include <groonga.h>
+
+#if defined(__cplusplus)
+#  define RB_GRN_BEGIN_DECLS extern "C" {
+#  define RB_GRN_END_DECLS }
+#else
+#  define RB_GRN_BEGIN_DECLS
+#  define RB_GRN_END_DECLS
+#endif
+
+RB_GRN_BEGIN_DECLS
+
+#if __GNUC__ >= 4
+#  define RB_GRN_GNUC_NULL_TERMINATED __attribute__((__sentinel__))
+#else
+#  define RB_GRN_GNUC_NULL_TERMINATED
+#endif
+
+#if defined(RUBY_GRN_PLATFORM_WIN32) && !defined(RB_GRN_PLATFORM_WIN32)
+#  define RB_GRN_PLATFORM_WIN32 RUBY_GRN_PLATFORM_WIN32
+#endif
+
+#if defined(RUBY_GRN_STATIC_COMPILATION) && !defined(RB_GRN_STATIC_COMPILATION)
+#  define RB_GRN_STATIC_COMPILATION RUBY_GRN_STATIC_COMPILATION
+#endif
+
+#if defined(RB_GRN_PLATFORM_WIN32) && !defined(RB_GRN_STATIC_COMPILATION)
+#  ifdef RB_GRN_COMPILATION
+#    define RB_GRN_VAR __declspec(dllexport)
+#  else
+#    define RB_GRN_VAR extern __declspec(dllimport)
+#  endif
+#else
+#  define RB_GRN_VAR extern
+#endif
+
+#define RB_GRN_MAJOR_VERSION 0
+#define RB_GRN_MINOR_VERSION 0
+#define RB_GRN_MICRO_VERSION 1
+
+typedef int rb_grn_boolean;
+#define RB_GRN_FALSE (0)
+#define RB_GRN_TRUE (!RB_GRN_FALSE)
+
+#define RB_GRN_QUERY_DEFAULT_MAX_EXPRESSIONS 32
+
+#include <stdint.h>
+
+typedef struct {
+  int32_t tv_sec;
+  int32_t tv_usec;
+} grn_timeval;
+
+
+RB_GRN_VAR VALUE rb_eGrnError;
+RB_GRN_VAR VALUE rb_cGrnObject;
+RB_GRN_VAR VALUE rb_cGrnDatabase;
+RB_GRN_VAR VALUE rb_cGrnTable;
+RB_GRN_VAR VALUE rb_mGrnTableKeySupport;
+RB_GRN_VAR VALUE rb_cGrnHash;
+RB_GRN_VAR VALUE rb_cGrnPatriciaTrie;
+RB_GRN_VAR VALUE rb_cGrnArray;
+RB_GRN_VAR VALUE rb_cGrnTableCursor;
+RB_GRN_VAR VALUE rb_mGrnTableCursorKeySupport;
+RB_GRN_VAR VALUE rb_cGrnHashCursor;
+RB_GRN_VAR VALUE rb_cGrnPatriciaTrieCursor;
+RB_GRN_VAR VALUE rb_cGrnArrayCursor;
+RB_GRN_VAR VALUE rb_cGrnType;
+RB_GRN_VAR VALUE rb_cGrnProcedure;
+RB_GRN_VAR VALUE rb_cGrnColumn;
+RB_GRN_VAR VALUE rb_cGrnFixSizeColumn;
+RB_GRN_VAR VALUE rb_cGrnVarSizeColumn;
+RB_GRN_VAR VALUE rb_cGrnIndexColumn;
+RB_GRN_VAR VALUE rb_cGrnAccessor;
+RB_GRN_VAR VALUE rb_cGrnRecord;
+RB_GRN_VAR VALUE rb_cGrnQuery;
+RB_GRN_VAR VALUE rb_cGrnLogger;
+RB_GRN_VAR VALUE rb_cGrnSnippet;
+
+void           rb_grn_init_utils                    (VALUE mGrn);
+void           rb_grn_init_exception                (VALUE mGrn);
+void           rb_grn_init_encoding                 (VALUE mGrn);
+void           rb_grn_init_context                  (VALUE mGrn);
+void           rb_grn_init_object                   (VALUE mGrn);
+void           rb_grn_init_database                 (VALUE mGrn);
+void           rb_grn_init_table                    (VALUE mGrn);
+void           rb_grn_init_table_key_support        (VALUE mGrn);
+void           rb_grn_init_array                    (VALUE mGrn);
+void           rb_grn_init_hash                     (VALUE mGrn);
+void           rb_grn_init_patricia_trie            (VALUE mGrn);
+void           rb_grn_init_table_cursor             (VALUE mGrn);
+void           rb_grn_init_table_cursor_key_support (VALUE mGrn);
+void           rb_grn_init_array_cursor             (VALUE mGrn);
+void           rb_grn_init_hash_cursor              (VALUE mGrn);
+void           rb_grn_init_patricia_trie_cursor     (VALUE mGrn);
+void           rb_grn_init_type                     (VALUE mGrn);
+void           rb_grn_init_procedure                (VALUE mGrn);
+void           rb_grn_init_column                   (VALUE mGrn);
+void           rb_grn_init_accessor                 (VALUE mGrn);
+void           rb_grn_init_record                   (VALUE mGrn);
+void           rb_grn_init_query                    (VALUE mGrn);
+void           rb_grn_init_logger                   (VALUE mGrn);
+void           rb_grn_init_snippet                  (VALUE mGrn);
+
+VALUE          rb_grn_rc_to_exception               (grn_rc rc);
+const char    *rb_grn_rc_to_message                 (grn_rc rc);
+void           rb_grn_rc_check                      (grn_rc rc,
+						     VALUE related_object);
+
+grn_ctx       *rb_grn_context_ensure                (VALUE context);
+VALUE          rb_grn_context_get_default           (void);
+VALUE          rb_grn_context_to_exception          (grn_ctx *context,
+						     VALUE related_object);
+void           rb_grn_context_check                 (grn_ctx *context,
+						     VALUE related_object);
+
+const char    *rb_grn_inspect                       (VALUE object);
+void           rb_grn_scan_options                  (VALUE options, ...)
+                                                     RB_GRN_GNUC_NULL_TERMINATED;
+rb_grn_boolean rb_grn_equal_option                  (VALUE option,
+						     const char *key);
+
+VALUE          rb_grn_object_alloc                  (VALUE klass);
+void           rb_grn_object_initialize             (VALUE self,
+						     grn_ctx *context,
+						     grn_obj *object);
+VALUE          rb_grn_object_array_reference        (VALUE object,
+						     VALUE rb_id);
+VALUE          rb_grn_object_close                  (VALUE object);
+VALUE          rb_grn_object_inspect_object         (VALUE inspected,
+						     grn_ctx *context,
+						     grn_obj *object);
+VALUE          rb_grn_object_inspect_object_content (VALUE inspected,
+						     grn_ctx *context,
+						     grn_obj *object);
+VALUE          rb_grn_object_inspect_header         (VALUE object,
+						     VALUE inspected);
+VALUE          rb_grn_object_inspect_content        (VALUE object,
+						     VALUE inspected);
+VALUE          rb_grn_object_inspect_footer         (VALUE object,
+						     VALUE inspected);
+
+VALUE          rb_grn_table_s_create                (int argc,
+						     VALUE *argv,
+						     VALUE klass,
+						     grn_obj_flags key_store);
+grn_ctx       *rb_grn_table_cursor_ensure_context   (VALUE cursor,
+						     VALUE rb_context);
+VALUE          rb_grn_table_cursor_close            (VALUE object);
+
+VALUE          rb_grn_record_new                    (VALUE table,
+						     grn_id id);
+
+
+#define RB_GRN_INTERN(string)         (ID2SYM(rb_intern(string)))
+
+#define RVAL2CBOOL(object)            (RTEST(object))
+#define CBOOL2RVAL(boolean)           ((boolean) ? Qtrue : Qfalse)
+
+#define RVAL2GRNENCODING(object, context) \
+                                      (rb_grn_encoding_from_ruby_object(object, context))
+#define GRNENCODING2RVAL(encoding)    (rb_grn_encoding_to_ruby_object(encoding))
+
+#define RVAL2GRNCONTEXT(object)       (rb_grn_context_from_ruby_object(object))
+#define GRNCONTEXT2RVAL(context)      (rb_grn_context_to_ruby_object(context))
+
+#define RVAL2GRNOBJECT(rb_object, context) \
+                                      (rb_grn_object_from_ruby_object(rb_object, context))
+#define GRNOBJECT2RVAL(klass, context, object, owner) \
+    (rb_grn_object_to_ruby_object(klass, context, object, owner))
+#define GRNOBJECT2RCLASS(object)      (rb_grn_object_to_ruby_class(object))
+
+#define RVAL2GRNDB(object)            (rb_grn_database_from_ruby_object(object))
+#define GRNDB2RVAL(context, db, owner) \
+    (rb_grn_database_to_ruby_object(context, db, owner))
+
+#define RVAL2GRNTABLE(object, context)(rb_grn_table_from_ruby_object(object, context))
+#define GRNTABLE2RVAL(context, table, owner) \
+    (rb_grn_table_to_ruby_object(context, table, owner))
+
+#define RVAL2GRNTABLECURSOR(object)   (rb_grn_table_cursor_from_ruby_object(object))
+#define GRNTABLECURSOR2RVAL(klass, context, cursor) \
+                                      (rb_grn_table_cursor_to_ruby_object(klass, context, cursor))
+#define GRNTABLECURSOR2RCLASS(object) (rb_grn_table_cursor_to_ruby_class(object))
+
+#define RVAL2GRNCOLUMN(object, context) \
+    (rb_grn_column_from_ruby_object(object, context))
+#define GRNCOLUMN2RVAL(klass, context, column, owner) \
+    (rb_grn_column_to_ruby_object(klass, context, column, owner))
+
+#define RVAL2GRNQUERY(object)         (rb_grn_query_from_ruby_object(object))
+#define GRNQUERY2RVAL(context, column)(rb_grn_query_to_ruby_object(context, column))
+
+#define RVAL2GRNSELECTOPERATOR(object)(rb_grn_select_operator_from_ruby_object(object))
+
+#define RVAL2GRNLOGGER(object)        (rb_grn_logger_from_ruby_object(object))
+
+#define RVAL2GRNBULK(object, context, bulk) \
+    (rb_grn_bulk_from_ruby_object(object, context, bulk))
+#define RVAL2GRNBULK_WITH_TYPE(object, context, bulk, type) \
+    (rb_grn_bulk_from_ruby_object_with_type(object, context, bulk, type))
+#define GRNBULK2RVAL(context, bulk, related_object) \
+    (rb_grn_bulk_to_ruby_object(context, bulk, related_object))
+
+#define RVAL2GRNVECTOR(object, context, vector)	\
+    (rb_grn_vector_from_ruby_object(object, context, vector))
+#define GRNVECTOR2RVAL(context, vector) \
+    (rb_grn_vector_to_ruby_object(context, vector))
+
+#define RVAL2GRNUVECTOR(object, context, uvector) \
+    (rb_grn_uvector_from_ruby_object(object, context, uvector))
+#define GRNUVECTOR2RVAL(context, uvector) \
+    (rb_grn_uvector_to_ruby_object(context, uvector))
+
+#define GRNVALUE2RVAL(context, value, range, related_object) \
+    (rb_grn_value_to_ruby_object(context, value, range, related_object))
+
+#define RVAL2GRNID(object, context, table, related_object) \
+    (rb_grn_id_from_ruby_object(object, context, table, related_object))
+
+#define GRNKEY2RVAL(context, key, key_size, table, related_object) \
+    (rb_grn_key_to_ruby_object(context, key, key_size, table, related_object))
+#define RVAL2GRNKEY(object, context, key, domain, related_object) \
+    (rb_grn_key_from_ruby_object(object, context, key, domain, related_object))
+
+
+grn_encoding   rb_grn_encoding_from_ruby_object     (VALUE object,
+						     grn_ctx *context);
+VALUE          rb_grn_encoding_to_ruby_object       (grn_encoding encoding);
+
+grn_ctx       *rb_grn_context_from_ruby_object      (VALUE object);
+VALUE          rb_grn_context_to_ruby_object        (grn_ctx *context);
+
+grn_obj       *rb_grn_object_from_ruby_object       (VALUE object,
+						     grn_ctx **context);
+VALUE          rb_grn_object_to_ruby_object         (VALUE klass,
+						     grn_ctx *context,
+						     grn_obj *object,
+						     rb_grn_boolean owner);
+VALUE          rb_grn_object_to_ruby_class          (grn_obj *object);
+
+grn_obj       *rb_grn_database_from_ruby_object     (VALUE object);
+VALUE          rb_grn_database_to_ruby_object       (grn_ctx *context,
+						     grn_obj *db,
+						     rb_grn_boolean owner);
+
+grn_obj       *rb_grn_table_from_ruby_object        (VALUE object,
+						     grn_ctx **context);
+VALUE          rb_grn_table_to_ruby_object          (grn_ctx *context,
+						     grn_obj *table,
+						     rb_grn_boolean owner);
+
+grn_table_cursor *
+               rb_grn_table_cursor_from_ruby_object (VALUE object);
+VALUE          rb_grn_table_cursor_to_ruby_object   (VALUE klass,
+						     grn_ctx *context,
+						     grn_table_cursor *cursor);
+VALUE          rb_grn_table_cursor_to_ruby_class    (grn_table_cursor *cursor);
+
+grn_obj       *rb_grn_column_from_ruby_object       (VALUE object,
+						     grn_ctx **context);
+VALUE          rb_grn_column_to_ruby_object         (VALUE klass,
+						     grn_ctx *context,
+						     grn_obj *column,
+						     rb_grn_boolean owner);
+
+grn_query     *rb_grn_query_from_ruby_object        (VALUE object);
+VALUE          rb_grn_query_to_ruby_object          (grn_ctx *context,
+						     grn_query *query);
+
+grn_sel_operator
+               rb_grn_select_operator_from_ruby_object
+                                                    (VALUE object);
+
+grn_logger_info *
+               rb_grn_logger_from_ruby_object       (VALUE object);
+
+grn_obj       *rb_grn_bulk_from_ruby_object         (VALUE object,
+						     grn_ctx *context,
+						     grn_obj *bulk);
+grn_obj       *rb_grn_bulk_from_ruby_object_with_type
+                                                    (VALUE object,
+						     grn_ctx *context,
+						     grn_obj *bulk,
+						     grn_id type);
+VALUE          rb_grn_bulk_to_ruby_object           (grn_ctx *context,
+						     grn_obj *bulk,
+						     VALUE related_object);
+grn_obj       *rb_grn_vector_from_ruby_object       (VALUE object,
+						     grn_ctx *context,
+						     grn_obj *vector);
+VALUE          rb_grn_vector_to_ruby_object         (grn_ctx *context,
+						     grn_obj *vector);
+grn_obj       *rb_grn_uvector_from_ruby_object      (VALUE object,
+						     grn_ctx *context,
+						     grn_obj *uvector);
+VALUE          rb_grn_uvector_to_ruby_object        (grn_ctx *context,
+						     grn_obj *uvector);
+
+VALUE          rb_grn_value_to_ruby_object          (grn_ctx *context,
+						     grn_obj *value,
+						     grn_obj *range,
+						     VALUE related_object);
+
+grn_id         rb_grn_id_from_ruby_object           (VALUE object,
+						     grn_ctx *context,
+						     grn_obj *table,
+						     VALUE related_object);
+
+VALUE          rb_grn_key_to_ruby_object            (grn_ctx *context,
+						     const void *key,
+						     int key_size,
+						     grn_obj *table,
+						     VALUE related_object);
+grn_obj       *rb_grn_key_from_ruby_object          (VALUE rb_key,
+						     grn_ctx *context,
+						     grn_obj *key,
+						     grn_id domain_id,
+						     VALUE related_object);
+
+RB_GRN_END_DECLS
+
+#endif

data/ext/rb-groonga.c

@@ -0,0 +1,98 @@
+/* -*- c-file-style: "ruby" -*- */
+/*
+  Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License version 2.1 as published by the Free Software Foundation.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+#include "rb-grn.h"
+
+extern grn_ctx grn_gctx;
+
+static void
+finish_groonga (VALUE data)
+{
+    grn_ctx *context;
+
+    context = grn_gctx.next;
+    while (RB_GRN_TRUE) {
+	grn_ctx *next_context = context->next;
+
+	grn_ctx_fin(context);
+	if (next_context == &grn_gctx)
+	    break;
+	context = next_context;
+    }
+    grn_fin();
+}
+
+void
+Init_groonga (void)
+{
+    VALUE mGrn;
+    VALUE cGrnBuildVersion, cGrnBindingsVersion;
+
+    mGrn = rb_define_module("Groonga");
+
+    cGrnBuildVersion = rb_ary_new3(3,
+				   INT2NUM(GRN_MAJOR_VERSION),
+				   INT2NUM(GRN_MINOR_VERSION),
+				   INT2NUM(GRN_MICRO_VERSION));
+    rb_obj_freeze(cGrnBuildVersion);
+    /*
+     * ビルドしたgroongaのバージョン。<tt>[メジャーバージョン,
+     * マイナーバージョン, マイクロバージョン]</tt>の配列。
+     */
+    rb_define_const(mGrn, "BUILD_VERSION", cGrnBuildVersion);
+
+    /* FIXME: API to get runtime groonga version doesn't exist */
+
+    /*
+     * 利用しているgroongaのバージョン（にしたい。現在は
+     * BUILD_VERSIONと同じ）。<tt>[メジャーバージョ
+     * ン, マイナーバージョン, マイクロバージョン]</tt>の配列。
+     */
+    rb_define_const(mGrn, "VERSION", cGrnBuildVersion);
+
+    cGrnBindingsVersion = rb_ary_new3(3,
+				      INT2NUM(RB_GRN_MAJOR_VERSION),
+				      INT2NUM(RB_GRN_MINOR_VERSION),
+				      INT2NUM(RB_GRN_MICRO_VERSION));
+    rb_obj_freeze(cGrnBindingsVersion);
+    /*
+     * Ruby/groongaのバージョン。<tt>[メジャーバージョン, マ
+     * イナーバージョン, マイクロバージョン]</tt>の配列。
+     */
+    rb_define_const(mGrn, "BINDINGS_VERSION", cGrnBindingsVersion);
+
+    rb_grn_init_utils(mGrn);
+    rb_grn_init_exception(mGrn);
+    rb_grn_init_encoding(mGrn);
+    rb_grn_init_context(mGrn);
+    rb_grn_init_object(mGrn);
+    rb_grn_init_database(mGrn);
+    rb_grn_init_table(mGrn);
+    rb_grn_init_table_cursor(mGrn);
+    rb_grn_init_type(mGrn);
+    rb_grn_init_procedure(mGrn);
+    rb_grn_init_column(mGrn);
+    rb_grn_init_accessor(mGrn);
+    rb_grn_init_record(mGrn);
+    rb_grn_init_query(mGrn);
+    rb_grn_init_logger(mGrn);
+    rb_grn_init_snippet(mGrn);
+
+    rb_grn_rc_check(grn_init(), Qnil);
+    rb_set_end_proc(finish_groonga, Qnil);
+}

data/extconf.rb

@@ -0,0 +1,171 @@
+#!/usr/bin/env ruby
+#
+# Copyright (C) 2009  Kouhei Sutou <kou@clear-code.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License version 2.1 as published by the Free Software Foundation.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'English'
+require 'mkmf'
+require 'pkg-config'
+require 'fileutils'
+
+checking_for(checking_message("GCC")) do
+  if macro_defined?("__GNUC__", "")
+    $CFLAGS += ' -Wall'
+    true
+  else
+    false
+  end
+end
+
+package_name = "groonga"
+module_name = "groonga"
+ext_dir_name = "ext"
+src_dir = File.join(File.expand_path(File.dirname(__FILE__)), ext_dir_name)
+major, minor, micro = 0, 0, 4
+
+def install_groonga_locally(major, minor, micro)
+  require 'open-uri'
+  require 'shellwords'
+
+  tar_gz = "groonga-#{major}.#{minor}.#{micro}.tar.gz"
+  base_dir = File.join(File.dirname(__FILE__), "vendor")
+  install_dir = File.expand_path(File.join(base_dir, "local"))
+  FileUtils.mkdir_p(base_dir)
+
+  Dir.chdir(base_dir) do
+    url = "http://groonga.org/files/groonga/#{tar_gz}"
+    message("downloading %s...", url)
+    open(url, "rb") do |input|
+      File.open(tar_gz, "wb") do |output|
+        while (buffer = input.read(1024))
+          output.print(buffer)
+        end
+      end
+    end
+    message(" done\n")
+
+    message("extracting...")
+    if xsystem("tar xfz #{tar_gz}")
+      message(" done\n")
+    else
+      message(" failed\n")
+      exit 1
+    end
+
+    groonga_source_dir = "groonga-#{major}.#{minor}.#{micro}"
+    Dir.chdir(groonga_source_dir) do
+      message("configuring...")
+      if xsystem("./configure --prefix=#{Shellwords.escape(install_dir)}")
+        message(" done\n")
+      else
+        message(" failed\n")
+        exit 1
+      end
+
+      message("building (maybe long time)...")
+      if xsystem("make")
+        message(" done\n")
+      else
+        message(" failed\n")
+        exit 1
+      end
+
+      message("installing...")
+      if xsystem("make install")
+        message(" done\n")
+      else
+        message(" failed\n")
+        exit 1
+      end
+    end
+  end
+
+  pkg_config_dir = File.join(install_dir, "lib", "pkgconfig")
+  PackageConfig.prepend_default_path(pkg_config_dir)
+
+  lib_dir = File.join(install_dir, "lib")
+  $LDFLAGS += " -Wl,-rpath,#{Shellwords.escape(lib_dir)}"
+end
+
+unless PKGConfig.have_package(package_name, major, minor, micro)
+  install_groonga_locally(major, minor, micro)
+  PKGConfig.have_package(package_name, major, minor, micro) or exit 1
+end
+
+real_version = PKGConfig.modversion(package_name)
+real_major, real_minor, real_micro = real_version.split(/\./)
+$defs << "-DGRN_MAJOR_VERSION=#{real_major}"
+$defs << "-DGRN_MINOR_VERSION=#{real_minor}"
+$defs << "-DGRN_MICRO_VERSION=#{real_micro}"
+
+have_header("ruby/st.h") unless have_macro("HAVE_RUBY_ST_H", "ruby.h")
+have_func("rb_errinfo", "ruby.h")
+have_type("enum ruby_value_type", "ruby.h")
+
+create_makefile(module_name, src_dir)
+
+makefile = File.read("Makefile")
+File.open("Makefile", "w") do |f|
+  objs = []
+  co = nil
+  makefile.each_line do |line|
+    case line
+    when /^DLLIB\s*=\s*/
+      dllib = $POSTMATCH
+      f.puts("DLLIB = #{ext_dir_name}/#{dllib}")
+      f.puts("IMPLIB = #{ext_dir_name}/libruby-#{dllib.gsub(/\..+?$/, '.lib')}")
+    when /^(SRCS)\s*=\s*/
+      name = $1
+      vars = $POSTMATCH.split.collect {|var| "$(srcdir)/#{var}"}.join(" ")
+      f.puts("#{name} = #{vars}")
+    when /^(OBJS|CLEANLIBS|CLEANOBJS)\s*=\s*/
+      name = $1
+      vars = $POSTMATCH.split.collect {|var| "#{ext_dir_name}/#{var}"}
+      objs = vars if name == "OBJS"
+      vars = vars.join(" ")
+      f.puts("#{name} = #{vars}")
+    when /^\t\$\(CC\)/
+      if PKGConfig.msvc?
+        output_option = "-Fo"
+      else
+        output_option = "-o"
+      end
+      unless /#{Regexp.escape(output_option)}/ =~ line
+        line = "#{line.chomp} #{output_option}$@"
+      end
+      co = line
+      f.puts(line)
+    else
+      f.puts(line)
+    end
+  end
+
+  if co and !objs.empty?
+    f.puts
+    if PKGConfig.msvc?
+      f.puts "{$(srcdir)}.c{#{ext_dir_name}}.obj:"
+      f.puts co
+    else
+      objs.each do |obj|
+        f.puts "#{obj}: $(srcdir)/#{File.basename(obj).sub(/\..+?$/, '.c')}"
+        f.puts co
+      end
+    end
+  end
+end
+
+FileUtils.mkdir_p(ext_dir_name)