Fresh start

17 files changed, 10239 insertions, 0 deletions

diff --git a/jni/ruby/win32/Makefile.sub b/jni/ruby/win32/Makefile.sub
new file mode 100644
index 0000000..668f9e1
--- /dev/null
+++ b/jni/ruby/win32/Makefile.sub
@@ -0,0 +1,1174 @@
+# -*- makefile -*-
+
+SHELL = $(COMSPEC)
+ECHO1 = $(V:1=@:)
+RUNCMD = $(COMSPEC) /c
+MKFILES = Makefile verconf.mk
+NULL = nul
+CHDIR = cd
+PATH_SEPARATOR = ;
+TZ =				# skip timezone tests
+PWD = $(MAKEDIR)
+
+!ifndef MFLAGS
+MFLAGS=-l
+!endif
+
+!ifndef CROSS_COMPILING
+CROSS_COMPILING = no
+!endif
+!ifndef LARGEFILE_SUPPORT
+LARGEFILE_SUPPORT = 1
+!endif
+!ifndef win_srcdir
+win_srcdir = $(srcdir)/win32
+!endif
+
+#### Start of system configuration section. ####
+
+!if defined(pathlist)
+PATH = $(pathlist:;=/bin;)$(PATH)
+INCLUDE = $(pathlist:;=/include;)
+LIB = $(pathlist:;=/lib;)
+!endif
+
+## variables may be overridden by $(compile_dir)/Makefile
+!ifndef srcdir
+srcdir = ..
+!endif
+!ifndef RUBY_BASE_NAME
+RUBY_BASE_NAME = ruby
+!endif
+!ifndef RUBY_INSTALL_NAME
+RUBY_INSTALL_NAME = $(PROGRAM_PREFIX)$(RUBY_BASE_NAME)$(PROGRAM_SUFFIX)
+!endif
+!if !defined(RUBYW_INSTALL_NAME) || "$(RUBYW_INSTALL_NAME)" == "$(RUBY_INSTALL_NAME)"
+RUBYW_INSTALL_NAME = $(RUBY_INSTALL_NAME:ruby=rubyw)
+!endif
+!if "$(RUBYW_INSTALL_NAME)" == "$(RUBY_INSTALL_NAME)"
+RUBYW_INSTALL_NAME = $(RUBY_INSTALL_NAME)w
+!endif
+STUBPROGRAM = rubystub$(EXEEXT)
+!if !defined(icondirs) && defined(ICONDIRS)
+icondirs=$(ICONDIRS)
+!endif
+!if defined(icondirs)
+icondirs=$(icondirs:\=/)
+iconinc=-I$(icondirs: = -I)
+!endif
+###############
+
+.SUFFIXES: .def .lib
+
+!if !defined(CC)
+CC = cl
+!endif
+!if !defined(CPP) || "$(CPP)" == "cl"
+CPP = $(CC) -E
+!endif
+!if !defined(YACC)
+YACC = bison
+!endif
+AR = lib -nologo
+PURIFY =
+AUTOCONF = autoconf
+IFCHANGE = $(COMSPEC) /C $(srcdir:/=\)\win32\ifchange.bat
+RM = $(COMSPEC) /C $(srcdir:/=\)\win32\rm.bat
+RMDIR = $(COMSPEC) /C $(srcdir:/=\)\win32\rmdirs.bat
+RMDIRS = $(COMSPEC) /C $(srcdir:/=\)\win32\rmdirs.bat
+RMALL = $(COMSPEC) /C $(srcdir:/=\)\win32\rm.bat -r
+MAKEDIRS = $(COMSPEC) /E:ON /C $(srcdir:/=\)\win32\makedirs.bat
+CP = copy > nul
+MV = move > nul
+!if !defined(BASERUBY)
+BASERUBY = ruby
+!endif
+!if !defined(TEST_RUNNABLE)
+TEST_RUNNABLE = yes
+!endif
+
+!if !defined(MACHINE)
+MACHINE = x86
+!endif
+!if "$(MACHINE)" == "x86"
+!if !defined(PROCESSOR_LEVEL)
+PROCESSOR_LEVEL = 5
+!endif
+!if 6 < $(PROCESSOR_LEVEL)
+PROCESSOR_LEVEL = 6
+!endif
+!if $(MSC_VER) < 1400
+PROCESSOR_FLAG = -G$(PROCESSOR_LEVEL)
+!endif
+CPU = i$(PROCESSOR_LEVEL)86
+ARCH = i386
+!else
+CPU = $(MACHINE)
+ARCH = $(MACHINE)
+!endif
+!if !defined(DEBUGFLAGS)
+DEBUGFLAGS = -Zi
+!endif
+!if !defined(OPTFLAGS)
+!if $(MSC_VER) < 1400
+OPTFLAGS = -O2b2xg-
+!else
+OPTFLAGS = -O2sy-
+!endif
+!endif
+!if !defined(PLATFORM)
+PLATFORM = mswin32
+!endif
+!if !defined(RT)
+!error RT not defined.  Retry from configure pass.
+!endif
+!ifdef NTVER
+ARCHDEFS = -D_WIN32_WINNT=$(NTVER) $(ARCHDEFS)
+!endif
+!if !defined(PLATFORM_DIR)
+PLATFORM_DIR = win32
+!endif
+
+arch = $(ARCH)-$(PLATFORM)
+sitearch = $(ARCH)-$(RT)
+!if !defined(ruby_version)
+ruby_version = $(MAJOR).$(MINOR).$(TEENY)
+!endif
+
+!ifndef RUBY_SO_NAME
+RUBY_SO_NAME = $(RT)-$(RUBY_BASE_NAME)$(MAJOR)$(MINOR)$(TEENY)
+!if "$(ARCH)" != "i386"
+RUBY_SO_NAME = $(ARCH)-$(RUBY_SO_NAME)
+!endif
+!endif
+!ifndef RUBY_PLATFORM
+RUBY_PLATFORM = $(arch)
+!endif
+
+!if !defined(prefix)
+prefix = /usr
+!endif
+!if !defined(exec_prefix)
+exec_prefix = $(prefix)
+!endif
+!if !defined(libdir)
+libdir = $(exec_prefix)/lib
+!endif
+!if !defined(datadir)
+datadir = $(prefix)/share
+!endif
+!ifndef EXTOUT
+EXTOUT = .ext
+!endif
+!ifndef TESTUI
+TESTUI = console
+!endif
+!ifndef TESTS
+TESTS =
+!endif
+!ifndef CAPITARGET
+! ifdef DOXYGEN
+CAPITARGET = capi
+! else
+CAPITARGET = nodoc
+! endif
+!endif
+!ifndef DOCTARGETS
+! if "$(RDOCTARGET)" == "rdoc" || "$(RDOCTARGET)" == ""
+DOCTARGETS = $(DOCTARGETS) rdoc
+! endif
+! if "$(CAPITARGET)" == "capi"
+DOCTARGETS = $(DOCTARGETS) capi
+! endif
+!endif
+!ifndef INSTALLDOC
+! if "$(DOCTARGETS)" != ""
+INSTALLDOC = all
+! else
+INSTALLDOC = nodoc
+DOCTARGETS = nodoc
+! endif
+!endif
+
+OUTFLAG       = -Fe
+COUTFLAG      = -Fo
+!if !defined(RUNTIMEFLAG)
+RUNTIMEFLAG   = -MD
+!endif
+!if !defined(COMPILERFLAG)
+COMPILERFLAG  = -Zm600
+!endif
+!if !defined(WARNFLAGS)
+!if $(MSC_VER) >= 1400
+WARNFLAGS = -W2 -wd4996 -we4028 -we4142
+!else
+WARNFLAGS = -W2
+!endif
+!endif
+WERRORFLAG = -WX
+!if !defined(CFLAGS)
+CFLAGS = $(RUNTIMEFLAG) $(DEBUGFLAGS) $(WARNFLAGS) $(OPTFLAGS) $(PROCESSOR_FLAG) $(COMPILERFLAG)
+!endif
+!if !defined(CXXFLAGS)
+CXXFLAGS = $(CFLAGS)
+!endif
+!if !defined(LDFLAGS)
+LDFLAGS = -incremental:no -debug -opt:ref -opt:icf
+!endif
+!if !defined(XLDFLAGS)
+XLDFLAGS = -stack:$(STACK)
+!endif
+!if !defined(RFLAGS)
+RFLAGS = -r
+!endif
+!if !defined(EXTLIBS)
+EXTLIBS =
+!endif
+!if !defined(EXTSOLIBS)
+EXTSOLIBS =
+!endif
+!if !defined(LIBS)
+LIBS = user32.lib advapi32.lib shell32.lib ws2_32.lib
+!if $(MSC_VER) >= 1400
+LIBS = $(LIBS) iphlpapi.lib
+!endif
+LIBS = $(LIBS) imagehlp.lib shlwapi.lib $(EXTLIBS)
+!endif
+!if !defined(MISSING)
+MISSING = crypt.obj ffs.obj langinfo.obj lgamma_r.obj strlcat.obj strlcpy.obj win32/win32.obj win32/file.obj setproctitle.obj
+!if $(RT_VER) < 120
+MISSING = $(MISSING) acosh.obj cbrt.obj erf.obj tgamma.obj
+!endif
+!endif
+DLNOBJ = dln.obj
+
+ARFLAGS = -machine:$(MACHINE) -out:
+CC = $(CC) -nologo
+LD = $(CC)
+LDSHARED = $(LD) -LD
+XCFLAGS = -DRUBY_EXPORT -I. -I$(arch_hdrdir) -I$(hdrdir) -I$(srcdir) -I$(srcdir)/missing $(XCFLAGS)
+!if $(MSC_VER) >= 1400
+# Prevents VC++ 2005 (cl ver 14) warnings
+MANIFESTTOOL = mt -nologo
+LDSHARED_0 = @if exist $(@).manifest $(MINIRUBY) -run -e wait_writable -- -n 10 $@
+LDSHARED_1 = @if exist $(@).manifest $(MANIFESTTOOL) -manifest $(@).manifest -outputresource:$(@);2
+LDSHARED_2 = @if exist $(@).manifest @$(RM) $(@:/=\).manifest
+!endif
+CPPFLAGS = $(DEFS) $(ARCHDEFS) $(CPPFLAGS)
+
+DLDFLAGS = $(LDFLAGS) -dll
+SOLIBS =
+RCFILES = $(RUBY_INSTALL_NAME).rc $(RUBYW_INSTALL_NAME).rc $(RUBY_SO_NAME).rc
+!ifndef RCFLAGS
+!if $(MSC_VER) >= 1600
+RCFLAGS=-nologo
+!endif
+!endif
+
+LIBRUBY_LDSHARED = $(LDSHARED)
+LIBRUBY_DLDFLAGS = $(EXTLDFLAGS) -implib:dummy.lib -def:$(RUBYDEF)
+
+EXEEXT = .exe
+EXECUTABLE_EXTS = ".exe",".com",".cmd",".bat"
+!if !defined(PROGRAM)
+PROGRAM=$(RUBY_INSTALL_NAME)$(EXEEXT)
+!endif
+!if !defined(WPROGRAM) && defined(RUBYW_INSTALL_NAME)
+WPROGRAM=$(RUBYW_INSTALL_NAME)$(EXEEXT)
+!endif
+RUBYDEF = $(RUBY_SO_NAME).def
+!if "$(CROSS_COMPILING)" == "yes"
+MINIRUBY = $(RUBY) -I$(MAKEDIR) -r$(arch)-fake
+RUNRUBY = $(MINIRUBY)
+!else
+MINIRUBY = .\miniruby$(EXEEXT) -I$(srcdir)/lib -I.
+RUNRUBY = .\$(PROGRAM) -I$(srcdir)/lib -I"$(EXTOUT)/$(arch)" -I.
+!endif
+MINIRUBY = $(MINIRUBY) $(MINIRUBYOPT)
+RUNRUBY = $(RUNRUBY) "$(srcdir)/tool/runruby.rb" --extout="$(EXTOUT)" $(RUNRUBYOPT) -- $(RUN_OPTS)
+!if "$(CROSS_COMPILING)" == "yes"
+XRUBY = $(MINIRUBY)
+!else
+XRUBY = $(RUNRUBY)
+!endif
+BTESTRUBY = $(MINIRUBY)
+!ifndef RUBY
+RUBY = ruby
+!endif
+
+DTRACE_EXT = dmyh
+
+!if !defined(STACK)
+!if "$(ARCH)" == "x64" || "$(ARCH)" == "ia64"
+STACK = 0x400000
+!else
+STACK = 0x200000
+!endif
+!if defined(STACK_COMMIT)
+STACK = $(STACK),$(STACK_COMMIT)
+!endif
+!endif
+ORGLIBPATH = $(LIB)
+
+#### End of system configuration section. ####
+
+LIBRUBY_A     = $(RUBY_SO_NAME)-static.lib
+LIBRUBY_SO    = $(RUBY_SO_NAME).dll
+LIBRUBY       = $(RUBY_SO_NAME).lib
+LIBRUBYARG    = $(LIBRUBY)
+LIBRUBY_RELATIVE = yes
+
+THREAD_MODEL  = win32
+
+!if "$(CROSS_COMPILING)" == "yes"
+PREP          = $(arch)-fake.rb
+!else
+PREP          = miniruby$(EXEEXT)
+!endif
+
+!if !defined(EXTSTATIC)
+EXTSTATIC     =
+!endif
+
+OBJEXT = obj
+ASMEXT = asm
+
+INSTALLED_LIST= .installed.list
+
+SRC_FILE = $(<:\=/)
+OS_SRC_FILE = $(<:/=\)
+DEST_FILE = $(@:\=/)
+OS_DEST_FILE = $(@:/=\)
+
+!if !defined(WINMAINOBJ)
+WINMAINOBJ    = winmain.$(OBJEXT)
+!endif
+ARCHMINIOBJS  = dmydln.$(OBJEXT) miniruby.res
+LIBOBJS       = $(MISSING) $(LIBOBJS)
+
+!ifndef COMMON_LIBS
+COMMON_LIBS  = m
+!endif
+!ifndef COMMON_MACROS
+COMMON_MACROS = WIN32_LEAN_AND_MEAN WIN32
+!endif
+!ifndef COMMON_HEADERS
+COMMON_HEADERS = winsock2.h ws2tcpip.h windows.h
+!endif
+
+!if "$(EXTSTATIC)" == "static"
+ENCOBJS = enc/encinit.$(OBJEXT) enc/libenc.lib enc/libtrans.lib
+EXTOBJS = ext/extinit.$(OBJEXT)
+! if !defined(ENCSTATIC)
+ENCSTATIC = static
+! endif
+!else
+ENCOBJS = dmyenc.$(OBJEXT)
+EXTOBJS = dmyext.$(OBJEXT)
+!endif
+
+arch_hdrdir = $(EXTOUT)/include/$(arch)
+top_srcdir = $(srcdir)
+hdrdir = $(srcdir)/include
+VPATH = $(arch_hdrdir)/ruby;$(hdrdir)/ruby;$(srcdir);$(srcdir)/enc;$(srcdir)/missing;$(win_srcdir)
+
+!if exist($(srcdir)/.svn)
+VCS = svn
+VCSUP = $(VCS) up $(SVNUPOPTIONS)
+!else if exist($(srcdir)/.git/svn)
+VCS = git svn
+VCSUP = $(VCS) rebase $(GITSVNREBASEOPTIONS)
+!else if exist($(srcdir)/.git)
+VCS = git
+VCSUP = $(VCS) pull $(GITPULLOPTIONS)
+!else
+VCSUP = rem
+!endif
+ruby_pc = $(RUBY_BASE_NAME)-$(MAJOR).$(MINOR).pc
+
+MESSAGE_BEGIN = @for %I in (
+MESSAGE_END = ) do @echo.%~I
+ECHO_BEGIN = @echo.
+ECHO_END =
+
+all: $(srcdir)/win32/Makefile.sub $(win_srcdir)/Makefile.sub $(srcdir)/common.mk
+prog: config
+
+ruby: $(PROGRAM)
+rubyw: $(WPROGRAM)
+stub: $(STUBPROGRAM)
+
+!if !exist(newline.c) && exist($(srcdir)/newline.c)
+NEWLINE_C = $(srcdir)/newline.c
+!else
+NEWLINE_C = newline.c
+!endif
+!if !exist(miniprelude.c) && exist($(srcdir)/miniprelude.c)
+MINIPRELUDE_C = $(srcdir)/miniprelude.c
+!else
+MINIPRELUDE_C = miniprelude.c
+!endif
+!if !exist(prelude.c) && exist($(srcdir)/prelude.c)
+PRELUDE_C = $(srcdir)/prelude.c
+!else
+PRELUDE_C = prelude.c
+!endif
+RBCONFIG      = ./.rbconfig.time
+
+!include $(srcdir)/common.mk
+!if exist(verconf.mk)
+! include verconf.mk
+!endif
+
+!ifdef SCRIPTPROGRAMS
+!else if [echo>scriptbin.mk SCRIPTPROGRAMS = \]
+!else if [for %I in ($(srcdir:/=\)\bin\*) do @echo>>scriptbin.mk %~nI.exe \]
+!else if [echo.>>scriptbin.mk]
+!else if [echo.>>scriptbin.mk]
+!endif
+!if [for %I in ($(srcdir:/=\)\bin\*) do @for %J in (\
+"%~nI.exe: $$(srcdir)/bin/%~nI" \
+"	$$(ECHO) generating $$(@)" \
+"	$$(Q) copy /y /b $$(STUBPROGRAM) $$(@) > nul" \
+"	$$(Q) echo.>>$$(@)" \
+"	$$(Q) echo.>>$$(@)" \
+"	$$(Q) copy /b $$(@)+$$(srcdir:/=\)\bin\%~nI $$(@) > nul" \
+"" \
+) do @echo.%~J>>scriptbin.mk]
+!else
+! include scriptbin.mk
+! if [del scriptbin.mk > nul]
+! endif
+!endif
+
+scriptbin: $(SCRIPTPROGRAMS)
+
+$(SCRIPTPROGRAMS): $(STUBPROGRAM)
+
+up::
+	@cd "$(srcdir:/=\)" && set LC_TIME=C && $(VCSUP)
+
+update-mspec:
+!if exist($(srcdir)/spec/mspec)
+	@echo updating mspec ...
+	@cd $(srcdir:/=\)\spec\mspec && git pull
+!else
+	@echo retrieving mspec ...
+	@cd $(srcdir:/=\) && git clone $(MSPEC_GIT_URL) spec/mspec
+!endif
+
+update-rubyspec: update-mspec
+!if exist($(srcdir)/spec/rubyspec)
+	@echo updating rubyspec ...
+	@cd $(srcdir:/=\)\spec\rubyspec && git pull
+!else
+	@echo retrieving rubyspec ...
+	@cd $(srcdir:/=\) && git clone $(RUBYSPEC_GIT_URL) spec/rubyspec
+!endif
+
+test-rubyspec-precheck:
+!if !exist($(srcdir)/spec/rubyspec/.)
+	@echo No rubyspec here.  make update-rubyspec first.
+	@exit 1
+!endif
+
+$(MKFILES): $(srcdir)/common.mk $(srcdir)/version.h \
+	    $(win_srcdir)/Makefile.sub $(win_srcdir)/configure.bat \
+	    $(win_srcdir)/setup.mak $(win_srcdir)/enc-setup.mak \
+	    $(srcdir)/enc/Makefile.in
+	$(COMSPEC) /C $(win_srcdir:/=\)\configure.bat $(configure_args)
+	@fc Makefile Makefile.old > nul && echo Makefile unchanged || \
+	(echo $(MKFILES) was updated, re-run $(MAKE). & exit 1)
+
+RUBY_CONFIG_H = $(arch_hdrdir)/ruby/config.h
+CONFIG_H = ./.config.h.time
+
+config: config.status
+
+config.status: $(CONFIG_H)
+
+BANG = !
+
+!if exist($(RUBY_CONFIG_H))
+!include $(RUBY_CONFIG_H)
+!endif
+
+guard = INCLUDE_RUBY_CONFIG_H
+
+$(CONFIG_H): $(MKFILES) $(srcdir)/win32/Makefile.sub $(win_srcdir)/Makefile.sub
+	@echo Creating config.h
+!if !exist("$(arch_hdrdir)")
+	@md $(arch_hdrdir:/=\)
+!endif
+!if !exist("$(arch_hdrdir)/ruby")
+	@md $(arch_hdrdir:/=\)\ruby
+!endif
+	@$(IFCHANGE) "--timestamp=$(@:/=\)" $(RUBY_CONFIG_H:/=\) <<
+#ifndef $(guard)
+#define $(guard) 1
+#if _MSC_VER != $(MSC_VER)
+#error MSC version unmatch: _MSC_VER: $(MSC_VER) is expected.
+#endif
+#define RUBY_MSVCRT_VERSION $(RT_VER)
+#define STDC_HEADERS 1
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_SYS_STAT_H 1
+#define HAVE_STDLIB_H 1
+#define HAVE_STDDEF_H 1
+#define HAVE_STRING_H 1
+#define HAVE_MEMORY_H 1
+!if $(MSC_VER) >= 1400
+#define HAVE_LONG_LONG 1
+!endif
+#define HAVE_OFF_T 1
+#define SIZEOF_INT 4
+#define SIZEOF_SHORT 2
+#define SIZEOF_LONG 4
+!if $(MSC_VER) >= 1400
+#define SIZEOF_LONG_LONG 8
+!else
+#define SIZEOF_LONG_LONG 0
+!endif
+#define SIZEOF___INT64 8
+#define _INTEGRAL_MAX_BITS 64
+!if $(LARGEFILE_SUPPORT)
+#define SIZEOF_OFF_T 8
+!else
+#define SIZEOF_OFF_T 4
+!endif
+!if "$(ARCH)" == "x64" || "$(ARCH)" == "ia64"
+#define SIZEOF_VOIDP 8
+!else
+#define SIZEOF_VOIDP 4
+!endif
+#define SIZEOF_FLOAT 4
+#define SIZEOF_DOUBLE 8
+#define SIGNEDNESS_OF_TIME_T -1
+!if $(RT_VER) >= 80
+#define SIZEOF_TIME_T 8
+#define TIMET2NUM(v) LL2NUM(v)
+#define NUM2TIMET(v) NUM2LL(v)
+!else
+#define SIZEOF_TIME_T 4
+#define TIMET2NUM(v) LONG2NUM(v)
+#define NUM2TIMET(v) NUM2LONG(v)
+!endif
+#define CLOCKID2NUM(v) INT2NUM(v)
+#define NUM2CLOCKID(v) NUM2INT(v)
+#define SIZEOF_CLOCK_T 4
+#define SIZEOF_RLIM_T 0
+!if "$(ARCH)" == "x64" || "$(ARCH)" == "ia64"
+#define SIZEOF_SIZE_T 8
+#define SIZEOF_PTRDIFF_T 8
+#define SIZEOF_INTPTR_T 8
+#define SIZEOF_UINTPTR_T 8
+!else
+#define SIZEOF_SIZE_T 4
+#define SIZEOF_PTRDIFF_T 4
+#define SIZEOF_INTPTR_T 4
+#define SIZEOF_UINTPTR_T 4
+!endif
+!if $(MSC_VER) < 1400
+#define SIZE_MAX UINT_MAX
+!endif
+#define HAVE_PROTOTYPES 1
+#define TOKEN_PASTE(x,y) x##y
+#define HAVE_STDARG_PROTOTYPES 1
+!if $(MSC_VER) > 1100
+#define NORETURN(x) __declspec(noreturn) x
+!endif
+!if $(MSC_VER) >= 1300
+#define DEPRECATED(x) __declspec(deprecated) x
+#define NOINLINE(x) __declspec(noinline) x
+!endif
+#define FUNC_STDCALL(x) __stdcall x
+#define FUNC_CDECL(x) __cdecl x
+#define FUNC_FASTCALL(x) __fastcall x
+!if $(MSC_VER) >= 1500
+#define RUBY_FUNCTION_NAME_STRING __FUNCTION__
+#define PACKED_STRUCT(x) __pragma(pack(push, 1)) x __pragma(pack(pop))
+!else
+#define PACKED_STRUCT(x) x
+!endif
+!if "$(ARCH)" == "x86" || "$(ARCH)" == "x64" || "$(ARCH)" == "ia64"
+#define PACKED_STRUCT_UNALIGNED(x) PACKED_STRUCT(x)
+!else
+#define PACKED_STRUCT_UNALIGNED(x) x
+!endif
+#define RUBY_EXTERN extern __declspec(dllimport)
+#define HAVE_DECL_SYS_NERR 1
+#define HAVE_LIMITS_H 1
+#define HAVE_FCNTL_H 1
+#define HAVE_SYS_UTIME_H 1
+#define HAVE_FLOAT_H 1
+#define HAVE_TIME_H 1
+#define rb_pid_t int
+#define rb_gid_t int
+#define rb_uid_t int
+#define HAVE_STRUCT_STAT_ST_RDEV 1
+#define HAVE_ST_RDEV 1
+#define HAVE_STRUCT_TIMEVAL 1
+!if $(MSC_VER) >= 1600
+#define HAVE_STDINT_H 1
+!else
+#define int8_t signed char
+#define uint8_t unsigned char
+#define int16_t short
+#define uint16_t unsigned short
+#define int32_t int
+#define uint32_t unsigned int
+#define int64_t __int64
+#define uint64_t unsigned __int64
+#define INT8_MIN _I8_MIN
+#define INT8_MAX _I8_MAX
+#define UINT8_MAX _UI8_MAX
+#define INT16_MIN _I16_MIN
+#define INT16_MAX _I16_MAX
+#define UINT16_MAX _UI16_MAX
+#define INT32_MIN _I32_MIN
+#define INT32_MAX _I32_MAX
+#define UINT32_MAX _UI32_MAX
+#define INT64_MIN _I64_MIN
+#define INT64_MAX _I64_MAX
+#define UINT64_MAX _UI64_MAX
+!endif
+#define HAVE_INT8_T 1
+#define HAVE_UINT8_T 1
+#define SIZEOF_INT8_T 1
+#define SIZEOF_UINT8_T 1
+#define HAVE_INT16_T 1
+#define HAVE_UINT16_T 1
+#define SIZEOF_INT16_T 2
+#define SIZEOF_UINT16_T 2
+#define HAVE_INT32_T 1
+#define HAVE_UINT32_T 1
+#define SIZEOF_INT32_T 4
+#define SIZEOF_UINT32_T 4
+#define HAVE_INT64_T 1
+#define HAVE_UINT64_T 1
+#define SIZEOF_INT64_T 8
+#define SIZEOF_UINT64_T 8
+#define HAVE_INTPTR_T 1
+#define HAVE_UINTPTR_T 1
+#define HAVE_SSIZE_T 1
+!if "$(ARCH)" == "x64" || "$(ARCH)" == "ia64"
+#define ssize_t __int64
+!else
+#define ssize_t int
+!endif
+#define PRI_LL_PREFIX "I64"
+#define PRI_PIDT_PREFIX PRI_INT_PREFIX
+#define GETGROUPS_T int
+#define RETSIGTYPE void
+#define TYPEOF_TIMEVAL_TV_SEC long
+!if $(RT_VER) >= 120
+#define HAVE_ACOSH 1
+#define HAVE_ASINH 1
+#define HAVE_ATANH 1
+#define HAVE_CBRT 1
+#define HAVE_LOG2 1
+#define log2(x) log2(x)
+#define HAVE_ERF 1
+#define HAVE_ERFC 1
+#define HAVE_ROUND 1
+#define HAVE_TGAMMA 1
+#define HAVE_NEXTAFTER 1
+!endif
+#define HAVE_ALLOCA 1
+#define HAVE_DUP2 1
+#define HAVE_MEMCMP 1
+#define HAVE_MEMMOVE 1
+#define HAVE_MKDIR 1
+#define HAVE_CLOCK_GETTIME 1
+#define HAVE_CLOCK_GETRES 1
+#define HAVE_SPAWNV 1
+#define HAVE_STRCASECMP 1
+#define HAVE_STRNCASECMP 1
+#define HAVE_STRERROR 1
+#define HAVE_STRFTIME 1
+#define HAVE_STRCHR 1
+#define HAVE_STRSTR 1
+#define HAVE_STRTOD 1
+#define HAVE_STRTOL 1
+#define HAVE_STRTOUL 1
+#define HAVE_FLOCK 1
+#define HAVE_ISNAN 1
+#define HAVE_FINITE 1
+#define HAVE_HYPOT 1
+#define HAVE_FMOD 1
+#define HAVE_FREXP 1
+#define HAVE_MODF 1
+#define HAVE_WAITPID 1
+#define HAVE_FSYNC 1
+#define HAVE_GETCWD 1
+#define HAVE_TRUNCATE 1
+#define HAVE_FTRUNCATE 1
+#define HAVE_TIMES 1
+#define HAVE_FCNTL 1
+#define HAVE_LINK 1
+#define HAVE__SETJMP 1
+#define HAVE_TELLDIR 1
+#define HAVE_SEEKDIR 1
+#define HAVE_MKTIME 1
+#define HAVE_COSH 1
+#define HAVE_SINH 1
+#define HAVE_TANH 1
+#define HAVE_SIGNBIT 1
+#define HAVE_TZNAME 1
+#define HAVE_DAYLIGHT 1
+#define HAVE_GMTIME_R 1
+#define HAVE_TYPE_NET_LUID 1
+#define SETPGRP_VOID 1
+#define RSHIFT(x,y) ((x)>>(int)y)
+#define HAVE_RB_FD_INIT 1
+#define RUBY_SETJMP(env) _setjmp(env)
+#define RUBY_LONGJMP(env,val) longjmp(env,val)
+#define RUBY_JMP_BUF jmp_buf
+#define inline __inline
+#define NEED_IO_SEEK_BETWEEN_RW 1
+!if "$(MACHINE)" == "x86" || "$(ARCH)" == "x64" || "$(ARCH)" == "ia64"
+#define STACK_GROW_DIRECTION -1
+!endif
+#define CANONICALIZATION_FOR_MATHN 1
+#define DEFAULT_KCODE KCODE_NONE
+!if "$(ENABLE_DEBUG_ENV)" == "yes"
+#define RUBY_DEBUG_ENV 1
+!endif
+#define LOAD_RELATIVE 1
+#define DLEXT ".so"
+!if "$(EXTSTATIC)" == "static"
+#define EXTSTATIC 1
+!endif
+#define EXECUTABLE_EXTS $(EXECUTABLE_EXTS)
+#define RUBY_COREDLL "$(RT)"
+#define LIBRUBY_SO "$(LIBRUBY_SO)"
+#define RUBY_PLATFORM "$(arch)"
+#define RUBY_SITEARCH "$(sitearch)"
+#if 0
+$(BANG)if "$(RUBY_SO_NAME)"!="$$(RUBY_SO_NAME)" || "$(ARCH)-$(PLATFORM)"!="$$(ARCH)-$$(PLATFORM)"
+config.h: nul
+$(BANG)endif
+#endif
+#endif /* $(guard) */
+<<
+
+#!if exist($(RUBY_CONFIG_H))
+#! if exist(config_h.bak)
+#	@del $(RUBY_CONFIG_H:.h=_h).bak
+#! endif
+#	@copy $(RUBY_CONFIG_H) $(RUBY_CONFIG_H:.h=_h).bak
+#!endif
+#!if exist($(RUBY_CONFIG_H))
+#	@echo NMAKE will abort if config.h is changed, then restart NMAKE.
+#	@fc.exe $(RUBY_CONFIG_H) $(RUBY_CONFIG_H:.h=_h).bak > nul
+#	@echo $(RUBY_CONFIG_H) unchanged.
+#	@del $(RUBY_CONFIG_H)
+#	@ren $(RUBY_CONFIG_H:.h=_h).bak $(RUBY_CONFIG_H)
+#!endif
+
+EXECUTABLE_EXTS = $(EXECUTABLE_EXTS:"=) # "
+EXECUTABLE_EXTS = $(EXECUTABLE_EXTS:,= )
+
+config.status: $(MKFILES) $(srcdir)/win32/Makefile.sub $(win_srcdir)/Makefile.sub $(srcdir)/common.mk
+	@echo Creating $@
+	@exit <<$@
+# Generated automatically by Makefile.sub.
+s,@SHELL@,$$(COMSPEC),;t t
+s,@BUILD_FILE_SEPARATOR@,\,;t t
+s,@PATH_SEPARATOR@,;,;t t
+s,@CFLAGS@,$(CFLAGS),;t t
+s,@WERRORFLAG@,$(WERRORFLAG),;t t
+s,@DEFS@,$(DEFS),;t t
+s,@CPPFLAGS@,$(CPPFLAGS),;t t
+s,@CXXFLAGS@,$(CXXFLAGS),;t t
+s,@FFLAGS@,$(FFLAGS),;t t
+s,@LDFLAGS@,$(LDFLAGS),;t t
+s,@LIBS@,$(LIBS),;t t
+s,@exec_prefix@,$${prefix},;t t
+s,@prefix@,$(prefix),;t t
+s,@program_transform_name@,s,.*,$(PROGRAM_PREFIX)&$(PROGRAM_SUFFIX),,;t t
+s,@bindir@,$${exec_prefix}/bin,;t t
+s,@sbindir@,$${exec_prefix}/sbin,;t t
+s,@libexecdir@,$${exec_prefix}/libexec,;t t
+s,@datadir@,$${prefix}/share,;t t
+s,@sysconfdir@,$${prefix}/etc,;t t
+s,@sharedstatedir@,/etc,;t t
+s,@localstatedir@,/var,;t t
+s,@libdir@,$${exec_prefix}/lib,;t t
+s,@includedir@,$${prefix}/include,;t t
+s,@oldincludedir@,/usr/include,;t t
+s,@infodir@,$${datadir}/info,;t t
+s,@mandir@,$${datadir}/man,;t t
+s,@ridir@,$${datadir}/ri,;t t
+s,@docdir@,$${datadir}/doc/$${RUBY_BASE_NAME},;t t
+s,@build@,$(CPU)-pc-$(PLATFORM),;t t
+s,@build_alias@,$(CPU)-$(PLATFORM),;t t
+s,@build_cpu@,$(CPU),;t t
+s,@build_vendor@,pc,;t t
+s,@build_os@,$(PLATFORM),;t t
+s,@host@,$(CPU)-pc-$(PLATFORM),;t t
+s,@host_alias@,$(CPU)-$(PLATFORM),;t t
+s,@host_cpu@,$(CPU),;t t
+s,@host_vendor@,pc,;t t
+s,@host_os@,$(PLATFORM),;t t
+s,@target@,$(ARCH)-pc-$(PLATFORM),;t t
+s,@target_alias@,$(ARCH)-$(PLATFORM),;t t
+s,@target_cpu@,$(ARCH),;t t
+s,@target_vendor@,pc,;t t
+s,@target_os@,$(PLATFORM),;t t
+s,@NULLCMD@,:,;t t
+s,@CC@,$(CC),;t t
+s,@CPP@,$(CPP),;t t
+s,@CXX@,$$(CC),;t t
+s,@LD@,$$(CC),;t t
+s,@YACC@,$(YACC),;t t
+s,@RANLIB@,,;t t
+s,@AR@,$(AR),;t t
+s,@ARFLAGS@,$(ARFLAGS),;t t
+s,@LN_S@,$(LN_S),;t t
+s,@SET_MAKE@,MFLAGS = -$$(MAKEFLAGS),;t t
+s,@RM@,$$(COMSPEC) /C $$(top_srcdir:/=\)\win32\rm.bat,;t t
+s,@RMDIR@,$$(COMSPEC) /C $$(top_srcdir:/=\)\win32\rmdirs.bat,:t t
+s,@RMDIRS@,$$(COMSPEC) /C $$(top_srcdir:/=\)\win32\rmdirs.bat,;t t
+s,@RMALL@,$$(COMSPEC) /C $$(top_srcdir:/=\)\win32\rm.bat -f -r,:t t
+s,@MAKEDIRS@,$$(COMSPEC) /E:ON /C $$(top_srcdir:/=\)\win32\makedirs.bat,;t t
+s,@LIBOBJS@,$(LIBOBJS),;t t
+s,@ALLOCA@,$(ALLOCA),;t t
+s,@DEFAULT_KCODE@,$(DEFAULT_KCODE),;t t
+s,@EXEEXT@,.exe,;t t
+s,@EXECUTABLE_EXTS@,$(EXECUTABLE_EXTS),;t t
+s,@OBJEXT@,$(OBJEXT),;t t
+s,@ASMEXT@,$(ASMEXT),;t t
+s,@XCFLAGS@,$(XCFLAGS),;t t
+s,@XLDFLAGS@,$(XLDFLAGS),;t t
+s,@DLDFLAGS@,$(DLDFLAGS) $$(LIBPATH),;t t
+s,@EXTDLDFLAGS@,$(EXTDLDFLAGS),;t t
+s,@ARCH_FLAG@,$(ARCH_FLAG),;t t
+s,@STATIC@,$(STATIC),;t t
+s,@CCDLFLAGS@,,;t t
+s,@LDSHARED@,$(LDSHARED),;t t
+s,@DLEXT@,so,;t t
+s,@LIBEXT@,lib,;t t
+s,@STRIP@,$(STRIP),;t t
+s,@EXTSTATIC@,$(EXTSTATIC),;t t
+s,@setup@,Setup,;t t
+s,@MINIRUBY@,$(MINIRUBY),;t t
+s,@PREP@,miniruby$(EXEEXT),;t t
+s,@RUNRUBY@,$(RUNRUBY),;t t
+s,@EXTOUT@,$(EXTOUT),;t t
+s,@ARCHFILE@,,;t t
+s,@RDOCTARGET@,,;t t
+s,@LIBRUBY_LDSHARED@,$(LIBRUBY_LDSHARED),;t t
+s,@LIBRUBY_DLDFLAGS@,$(LIBRUBY_DLDFLAGS),;t t
+s,@RUBY_BASE_NAME@,$(RUBY_BASE_NAME),;t t
+s,@RUBY_INSTALL_NAME@,$(RUBY_INSTALL_NAME),;t t
+s,@rubyw_install_name@,$(RUBYW_INSTALL_NAME),;t t
+s,@RUBYW_INSTALL_NAME@,$(RUBYW_INSTALL_NAME),;t t
+s,@RUBY_SO_NAME@,$(RUBY_SO_NAME),;t t
+s,@LIBRUBY_A@,$$(RUBY_SO_NAME)-static.lib,;t t
+s,@LIBRUBY_SO@,$$(RUBY_SO_NAME).dll,;t t
+s,@LIBRUBY_ALIASES@,$(LIBRUBY_ALIASES),;t t
+s,@LIBRUBY@,$$(RUBY_SO_NAME).lib,;t t
+s,@LIBRUBYARG@,$$(LIBRUBYARG_SHARED),;t t
+s,@LIBRUBYARG_STATIC@,$$(LIBRUBY_A),;t t
+s,@LIBRUBYARG_SHARED@,$$(LIBRUBY),;t t
+s,@SOLIBS@,$(SOLIBS),;t t
+s,@DLDLIBS@,$(DLDLIBS),;t t
+s,@ENABLE_SHARED@,yes,;t t
+s,@BASERUBY@,$(BASERUBY),;t t
+s,@OUTFLAG@,$(OUTFLAG),;t t
+s,@COUTFLAG@,$(COUTFLAG),;t t
+s,@CPPOUTFILE@,-P,;t t
+s,@LIBPATHFLAG@, -libpath:%s,;t t
+s,@RPATHFLAG@,,;t t
+s,@LIBARG@,%s.lib,;t t
+s,@LINK_SO@,$$(LDSHARED) -Fe$$(@) $$(OBJS) $$(LIBS) $$(LOCAL_LIBS) -link $$(DLDFLAGS) -implib:$$(*F:.so=)-$$(arch).lib -pdb:$$(*F:.so=)-$$(arch).pdb -def:$$(DEFFILE),;t t
+!if $(MSC_VER) >= 1400
+s,@LINK_SO@,@if exist $$(@).manifest $$(RUBY) -run -e wait_writable -- -n 10 $$(@),;t t
+s,@LINK_SO@,@if exist $$(@).manifest $(MANIFESTTOOL) -manifest $$(@).manifest -outputresource:$$(@);2,;t t
+s,@LINK_SO@,@if exist $$(@).manifest $$(RM) $$(@:/=\).manifest,;t t
+!endif
+s,@COMPILE_C@,$$(CC) $$(INCFLAGS) $$(CFLAGS) $$(CPPFLAGS) $$(COUTFLAG)$$(@) -c -Tc$$(<:\=/),;t t
+s,@COMPILE_CXX@,$$(CXX) $$(INCFLAGS) $$(CXXFLAGS) $$(CPPFLAGS) $$(COUTFLAG)$$(@) -c -Tp$$(<:\=/),;t t
+s,@ASSEMBLE_C@,$$(CC) $$(CFLAGS) $$(CPPFLAGS) -Fa$$(@) -c -Tc$$(<:\=/),;t t
+s,@ASSEMBLE_CXX@,$$(CXX) $$(CXXFLAGS) $$(CPPFLAGS) -Fa$$(@) -c -Tp$$(<:\=/),;t t
+s,@COMPILE_RULES@,{$$(*VPATH*)}.%s.%s: .%s.%s:,;t t
+s,@RULE_SUBST@,{.;$$(VPATH)}%s,;t t
+s,@TRY_LINK@,$$(CC) -Feconftest $$(INCFLAGS) -I$$(hdrdir) $$(CPPFLAGS) $$(CFLAGS) $$(src) $$(LOCAL_LIBS) $$(LIBS) -link $$(LDFLAGS) $$(LIBPATH) $$(XLDFLAGS),;t t
+s,@COMMON_LIBS@,$(COMMON_LIBS),;t t
+s,@COMMON_MACROS@,$(COMMON_MACROS),;t t
+s,@COMMON_HEADERS@,$(COMMON_HEADERS),;t t
+s,@cleanobjs@,$$*.exp $$*.lib $$*.pdb,;t t
+s,@DISTCLEANFILES@,vc*.pdb,;t t
+s,@EXPORT_PREFIX@, ,;t t
+s,@archlibdir@,$${libdir}/$${arch},;t t
+s,@sitearchlibdir@,$${libdir}/$${sitearch},;t t
+s,@archincludedir@,$${includedir}/$${arch},;t t
+s,@sitearchincludedir@,$${includedir}/$${sitearch},;t t
+s,@arch@,$(ARCH)-$(PLATFORM),;t t
+s,@sitearch@,$(ARCH)-$(RT),;t t
+s,@ruby_version@,$(ruby_version),;t t
+s,@rubylibprefix@,$${prefix}/lib/$${RUBY_BASE_NAME},;t t
+s,@rubyarchdir@,$${rubylibdir}/$${arch},;t t
+s,@rubylibdir@,$${rubylibprefix}/$${ruby_version},;t t
+s,@sitedir@,$${rubylibprefix}/site_ruby,;t t
+s,@sitearchdir@,$${sitelibdir}/$${sitearch},;t t
+s,@sitelibdir@,$${sitedir}/$${ruby_version},;t t
+s,@vendordir@,$${rubylibprefix}/vendor_ruby,;t t
+s,@vendorarchdir@,$${vendorlibdir}/$${sitearch},;t t
+s,@vendorlibdir@,$${vendordir}/$${ruby_version},;t t
+s,@rubyhdrdir@,$$(includedir)/$${RUBY_BASE_NAME}-$$(ruby_version),;t t
+s,@sitehdrdir@,$$(rubyhdrdir)/site_ruby,;t t
+s,@vendorhdrdir@,$$(rubyhdrdir)/vendor_ruby,;t t
+s,@rubyarchhdrdir@,$$(rubyhdrdir)/$${arch},;t t
+s,@sitearchhdrdir@,$$(sitehdrdir)/$${sitearch},;t t
+s,@vendorarchhdrdir@,$$(vendorhdrdir)/$${sitearch},;t t
+s,@PLATFORM_DIR@,$(PLATFORM_DIR),;t t
+s,@THREAD_MODEL@,$(THREAD_MODEL),;t t
+s,@configure_args@,--with-make-prog=nmake --enable-shared $(configure_args),;t t
+s,@configure_input@,$$configure_input,;t t
+s,@srcdir@,$(srcdir),;t t
+s,@top_srcdir@,$(srcdir),;t t
+s,@try_header@,try_compile,;t t
+s,@ruby_pc@,$(ruby_pc),;t t
+<<KEEP
+
+miniruby: miniruby$(EXEEXT)
+
+miniruby$(EXEEXT):
+		@echo $(LIBS)
+		$(ECHO) linking $(@:\=/)
+		$(Q) $(PURIFY) $(CC) $(MAINOBJ) $(MINIOBJS) $(COMMONOBJS) $(INITOBJS) $(LIBS) -Fe$@ -link $(LDFLAGS)
+		@$(RM) miniruby.lib miniruby.exp
+		$(Q) miniruby.exe -v
+		$(Q) $(LDSHARED_1)
+		$(Q) $(LDSHARED_2)
+
+miniruby.rc:
+		@exit > $@
+
+!if "$(PROGRAM)" != ""
+$(PROGRAM):	$(MAINOBJ) $(LIBRUBY_SO) $(RUBY_INSTALL_NAME).res
+		$(ECHO) linking $(@:\=/)
+		$(Q) $(PURIFY) $(CC) $(MAINOBJ) $(RUBY_INSTALL_NAME).res \
+			$(OUTFLAG)$@ $(LIBRUBYARG) -link $(LDFLAGS) $(XLDFLAGS)
+		$(Q) $(LDSHARED_0)
+		$(Q) $(LDSHARED_1)
+		$(Q) $(LDSHARED_2)
+!endif
+
+!if "$(WPROGRAM)" != ""
+$(WPROGRAM):	$(MAINOBJ) $(WINMAINOBJ) $(LIBRUBY_SO) $(RUBYW_INSTALL_NAME).res
+		$(ECHO) linking $(@:\=/)
+		$(Q) $(PURIFY) $(CC) $(MAINOBJ) $(WINMAINOBJ) \
+			$(RUBYW_INSTALL_NAME).res $(OUTFLAG)$@ $(LIBRUBYARG) \
+			-link $(LDFLAGS) $(XLDFLAGS) -subsystem:Windows
+		$(Q) $(LDSHARED_0)
+		$(Q) $(LDSHARED_1)
+		$(Q) $(LDSHARED_2)
+!endif
+
+!if "$(STUBPROGRAM)" != ""
+$(STUBPROGRAM):	stub.$(OBJEXT) $(LIBRUBY) $(LIBRUBY_SO) $(RUBY_INSTALL_NAME).res
+		$(ECHO) linking $(@:\=/)
+		$(Q) $(PURIFY) $(CC) stub.$(OBJEXT) $(RUBY_INSTALL_NAME).res \
+			$(OUTFLAG)$@ $(LIBRUBYARG) -link $(LDFLAGS) $(XLDFLAGS)
+		$(Q) $(LDSHARED_0)
+		$(Q) $(LDSHARED_1)
+		$(Q) $(LDSHARED_2)
+!endif
+
+$(LIBRUBY_A):	$(OBJS) $(INITOBJS)
+		$(ECHO) linking static-library $(@:\=/)
+		$(Q) $(AR) $(ARFLAGS)$@ $(OBJS) $(INITOBJS)
+
+$(LIBRUBY):	$(RUBYDEF)
+		$(ECHO) linking import-library $(@:\=/)
+		$(Q) $(AR) $(ARFLAGS)$@ -def:$(RUBYDEF)
+
+$(LIBRUBY_SO):	$(LIBRUBY_A) $(DLDOBJS) $(RUBYDEF) $(RUBY_SO_NAME).res
+		@echo $(DLDOBJS)
+		@-$(PRE_LIBRUBY_UPDATE)
+		$(ECHO) linking shared-library $(@:\=/)
+		$(Q) $(LDSHARED) $(MAINOBJ) $(DLDOBJS) $(LIBRUBY_A) \
+			$(RUBY_SO_NAME).res $(LIBS) -Fe$@ -link $(LDFLAGS) \
+			$(LIBRUBY_DLDFLAGS)
+		@$(RM) dummy.lib dummy.exp
+		$(Q) $(LDSHARED_0)
+		$(Q) $(LDSHARED_1)
+		$(Q) $(LDSHARED_2)
+# | findstr -v -c:LNK4049 -c:LNK4217
+
+$(RUBYDEF):	$(LIBRUBY_A) $(PREP)
+		$(ECHO) generating $(@:\=/)
+		$(Q) $(MINIRUBY) $(srcdir)/win32/mkexports.rb \
+		  -output=$@ -arch=$(ARCH) $(LIBRUBY_A)
+
+{$(win_srcdir)}.def.lib:
+		$(Q) $(AR) $(ARFLAGS)$@ -def:$<
+
+clean-local::
+		$(Q)$(RM) $(WINMAINOBJ) ext\extinit.c ext\extinit.$(OBJEXT) ext\vc*.pdb miniruby.lib
+		$(Q)$(RM) $(RUBY_INSTALL_NAME).res $(RUBYW_INSTALL_NAME).res $(RUBY_SO_NAME).res
+		$(Q)$(RM) miniruby.rc $(RUBY_INSTALL_NAME).rc $(RUBYW_INSTALL_NAME).rc $(RUBY_SO_NAME).rc
+		$(Q)$(RM) *.map *.pdb *.ilk *.exp $(RUBYDEF) ext\ripper\y.output
+
+distclean-local::
+		$(Q)$(RM) ext\config.cache $(RBCONFIG:/=\) $(CONFIG_H:/=\)
+		-$(Q)$(RM) $(INSTALLED_LIST:/=\) $(arch_hdrdir:/=\)\ruby\config.h verconf.h
+		-$(Q)$(RMDIRS) $(arch_hdrdir:/=\)\ruby
+
+clean-ext distclean-ext realclean-ext::
+!if "$(EXTS)" != ""
+		@for %I in ($(EXTS)) \
+!else
+		@for /R ext %I in (.) \
+!endif
+		do @if exist %I\Makefile ( \
+		    cd %I && ( \
+		    echo $(@:-ext=)ing %~nI & \
+		    $(MAKE) $(MFLAGS) $(@:-ext=) & \
+		    cd %CD% & \
+		    $(RMDIRS) %I \
+		) )
+
+distclean-ext realclean-ext::
+		-$(Q)rmdir ext
+
+clean-extout:
+
+clean-enc distclean-enc realclean-enc:
+!if exist($(ENC_MK))
+	@echo $(@:-enc=ing) encodings
+	@-$(MAKE) -f $(ENC_MK) $(MFLAGS) V=$(V) $(@:-enc=)
+!endif
+
+$(RCFILES): $(RBCONFIG) $(srcdir)/revision.h $(srcdir)/win32/resource.rb
+		@$(MINIRUBY) $(srcdir)/win32/resource.rb \
+			-ruby_name=$(RUBY_INSTALL_NAME) \
+			-rubyw_name=$(RUBYW_INSTALL_NAME) \
+			-so_name=$(RUBY_SO_NAME) \
+			. $(icondirs) $(win_srcdir)
+
+$(arch)-fake.rb: $(MKFILES) $(srcdir)/version.h
+	@echo Creating <<$@
+class Object
+  remove_const :CROSS_COMPILING if defined?(CROSS_COMPILING)
+  CROSS_COMPILING = RUBY_PLATFORM
+  remove_const :RUBY_PLATFORM
+  remove_const :RUBY_VERSION
+  remove_const :RUBY_DESCRIPTION if defined?(RUBY_DESCRIPTION)
+  RUBY_PLATFORM = "$(arch)"
+  RUBY_VERSION = $(RUBY_PROGRAM_VERSION)
+  RUBY_DESCRIPTION = "ruby #{RUBY_VERSION} (" $(RUBY_RELEASE_DATE) ") [#{RUBY_PLATFORM}]"
+end
+class File
+  remove_const :ALT_SEPARATOR
+  ALT_SEPARATOR = "\\"
+end
+<<KEEP
+
+$(ruby_pc): $(RBCONFIG)
+	@$(MINIRUBY) -r./rbconfig $(srcdir)/tool/expand-config.rb \
+	$(srcdir)/template/ruby.pc.in > $@
+
+{$(srcdir)/enc}.c.obj:
+	$(ECHO) compiling $(<:\=/)
+	$(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(COUTFLAG)$@ -c -Tc$(<:\=/)
+{$(srcdir)/missing}.c.obj:
+	$(ECHO) compiling $(<:\=/)
+	$(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(COUTFLAG)$@ -c -Tc$(<:\=/)
+{$(win_srcdir)}.c.obj:
+	$(ECHO) compiling $(<:\=/)
+	$(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(COUTFLAG)$@ -c -Tc$(<:\=/)
+{$(srcdir)}.c{}.obj:
+	$(ECHO) compiling $(<:\=/)
+	$(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(COUTFLAG)$@ -c -Tc$(<:\=/)
+.c.obj:
+	$(ECHO) compiling $(<:\=/)
+	$(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(COUTFLAG)$@ -c -Tc$(<:\=/)
+
+{$(srcdir)/missing}.c.asm:
+	$(ECHO) translating $(<:\=/)
+	$(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -Fa$@ -c -Tc$(<:\=/)
+{$(win_srcdir)}.c.asm:
+	$(ECHO) translating $(<:\=/)
+	$(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -Fa$@ -c -Tc$(<:\=/)
+{$(srcdir)}.c{}.asm:
+	$(ECHO) translating $(<:\=/)
+	$(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -Fa$@ -c -Tc$(<:\=/)
+.c.asm:
+	$(ECHO) translating $(<:\=/)
+	$(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -Fa$@ -c -Tc$(<:\=/)
+
+{$(srcdir)/missing}.c.i:
+	$(ECHO) preprocessing $(<:\=/)
+	$(Q) $(CC) $(XCFLAGS) $(CPPFLAGS) -P -Tc$(<:\=/) > $@
+{$(win_srcdir)}.c.i:
+	$(ECHO) preprocessing $(<:\=/)
+	$(Q) $(CC) $(XCFLAGS) $(CPPFLAGS) -P -Tc$(<:\=/)
+{$(srcdir)}.c{}.i:
+	$(ECHO) preprocessing $(<:\=/)
+	$(Q) $(CC) $(XCFLAGS) $(CPPFLAGS) -P -Tc$(<:\=/)
+.c.i:
+	$(ECHO) preprocessing $(<:\=/)
+	$(Q) $(CC) $(XCFLAGS) $(CPPFLAGS) -P -Tc$(<:\=/)
+
+.rc.res:
+	$(ECHO) compiling $(<:\=/)
+	$(Q) $(RC) $(RCFLAGS) -I. -I$(<D) $(iconinc) -I$(srcdir)/win32 $(RFLAGS) -fo$@ $(<:\=/)
+
+lex.c: {$(srcdir)}lex.c.blt
+	copy $(?:/=\) $@
+
+enc/unicode/name2ctype.h: {$(srcdir)}enc/unicode/name2ctype.h.blt
+	@if not exist $(@D:/=\) md $(@D:/=\)
+	$(ECHO) copying $@
+	$(Q) copy $(?:/=\) $(@:/=\) > nul
+
+enc/jis/props.h: {$(srcdir)}enc/jis/props.h.blt
+	@if not exist $(@D:/=\) md $(@D:/=\)
+	$(ECHO) copying $@
+	$(Q) copy $(?:/=\) $(@:/=\) > nul
+
+$(OBJS): {$(hdrdir)/ruby}win32.h
+
+dir.$(OBJEXT) win32/win32.$(OBJEXT): {$(srcdir)}win32/dir.h
+
+ext/extinit.obj: ext/extinit.c $(SETUP)
+	$(ECHO) compiling ext/extinit.c
+	$(Q) $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) $(COUTFLAG)$@ -c ext/extinit.c
+
+probes.h: {$(VPATH)}probes.dmyh
+	@$(ECHO) copying dummy $(DEST_FILE)
+	@if exist probes.dmyh (\
+	  $(Q) $(CP) probes.dmyh $(OS_DEST_FILE)\
+	) else (\
+	  $(Q) $(CP) $(srcdir:/=\)\probes.dmyh $(OS_DEST_FILE)\
+	)
+
+INSNS	= opt_sc.inc optinsn.inc optunifs.inc insns.inc insns_info.inc \
+	  vmtc.inc vm.inc
+
+!if [exit > insns_rules.mk]
+!else if [for %I in ($(INSNS)) do \
+	@for %J in (\
+"%I: $$(srcdir)/insns.def {$$(VPATH)}vm_opts.h \" \
+"	  $$(srcdir)/defs/opt_operand.def $$(srcdir)/defs/opt_insn_unif.def \" \
+"	  $$(srcdir)/tool/instruction.rb $$(srcdir)/tool/insns2vm.rb" \
+"	@$$(RM) $$(PROGRAM)" \
+"	$$(BASERUBY) -Ku $$(srcdir)/tool/insns2vm.rb $$(INSNS2VMOPT) %I" \
+"" \
+) do @echo.%~J>>insns_rules.mk]
+!else
+! include insns_rules.mk
+! if [del insns_rules.mk > nul]
+! endif
+!endif
+
+verconf.h: verconf.mk
+
+loadpath: verconf.h
+	@$(CPP) $(XCFLAGS) $(CPPFLAGS) $(srcdir)/loadpath.c | \
+	sed -e '1,/^const char ruby_initial_load_paths/d;/;/,$$d' \
+	    -e '/^^ /!d;s/ *"\\\\0"$$//;s/" *"//g'
diff --git a/jni/ruby/win32/README.win32 b/jni/ruby/win32/README.win32
new file mode 100644
index 0000000..314feb3
--- /dev/null
+++ b/jni/ruby/win32/README.win32
@@ -0,0 +1,141 @@
+=begin
+
+= How to build ruby using Visual C++
+
+== Requirement
+
+(1) Windows XP or later.
+
+(2) Visual C++ 6.0 or later. (strongly recommended VC++ 10 or later)
+
+    Note: if you want to build x64 or ia64 version, use native compiler for
+          x64/ia64.
+
+(3) Please set environment variable (({INCLUDE})), (({LIB})), (({PATH}))
+    to run required commands properly from the command line.
+
+    Note: building ruby requires following commands.
+     * nmake
+     * cl
+     * lib
+     * dumpbin
+
+(4) If you want to build from SVN source, following commands are required.
+     * bison
+     * sed
+     * ruby 1.8 or later
+
+(5) Enable Command Extension of your command line.  It's the default behavior
+    of cmd.exe.  If you want to enable it explicitly, run cmd.exe with /E:ON
+    option.
+
+== How to compile and install
+
+(1) Execute win32\configure.bat on your build directory.
+    You can specify the target platform as an argument.
+    For example, run `((%configure --target=i686-mswin32%))'
+    You can also specify the install directory.
+    For example, run `((%configure --prefix=<install_directory>%))'
+    Default of the install directory is /usr .
+    The default ((|<PLATFORM>|)) is `(({i386-mswin32}))'.
+
+(2) Change ((|RUBY_INSTALL_NAME|)) and ((|RUBY_SO_NAME|)) in (({Makefile}))
+    if you want to change the name of the executable files.
+    And add ((|RUBYW_INSTALL_NAME|)) to change the name of the
+    executable without console window if also you want.
+
+(3) Run `((%nmake%))'
+
+(4) Run `((%nmake test%))'
+
+(5) Run `((%nmake install%))'
+
+== Icons
+
+Any icon files(*.ico) in the build directory, directories specified with
+((|icondirs|)) make variable and (({win32})) directory under the ruby
+source directory will be included in DLL or executable files, according
+to their base names.
+    $(RUBY_INSTALL_NAME).ico or ruby.ico   --> $(RUBY_INSTALL_NAME).exe
+    $(RUBYW_INSTALL_NAME).ico or rubyw.ico --> $(RUBYW_INSTALL_NAME).exe
+    the others                             --> $(RUBY_SO_NAME).dll
+
+Although no icons are distributed with the ruby source or in the official
+site, you can use anything you like. For example, followings are written
+in Japanese, but you can download at least.
+
+* ((<URL:http://homepage1.nifty.com/a_nakata/ruby/>)) or
+  ((<icon itself|URL:http://homepage1.nifty.com/a_nakata/ruby/RubyIcon.ico>))
+
+== Build examples
+
+* Build on the ruby source directory.
+
+  ex.)
+    ruby source directory:  C:\ruby
+    build directory:        C:\ruby
+    install directory:      C:\usr\local
+
+    C:
+    cd \ruby
+    win32\configure --prefix=/usr/local
+    nmake
+    nmake test
+    nmake install
+
+* Build on the relative directory from the ruby source directory.
+
+  ex.)
+    ruby source directory:  C:\ruby
+    build directory:        C:\ruby\mswin32
+    install directory:      C:\usr\local
+
+    C:
+    cd \ruby
+    mkdir mswin32
+    cd mswin32
+    ..\win32\configure --prefix=/usr/local
+    nmake
+    nmake test
+    nmake install
+
+* Build on the different drive.
+
+  ex.)
+    ruby source directory:  C:\src\ruby
+    build directory:        D:\build\ruby
+    install directory:      C:\usr\local
+
+    D:
+    cd D:\build\ruby
+    C:\src\ruby\win32\configure --prefix=/usr/local
+    nmake
+    nmake test
+    nmake install DESTDIR=C:
+
+* Build x64 version (requires native x64 VC++ compiler)
+
+  ex.)
+    ruby source directory:  C:\ruby
+    build directory:        C:\ruby
+    install directory:      C:\usr\local
+
+    C:
+    cd \ruby
+    win32\configure --prefix=/usr/local --target=x64-mswin64
+    nmake
+    nmake test
+    nmake install
+
+== Bugs
+
+You can ((*NOT*)) use a path name that contains any white space characters as
+the ruby source directory, this restriction comes from the behavior of
+(({!INCLUDE})) directives of (({NMAKE})).
+((- you may call it a bug. -))
+
+You can build ruby in any directory including the source directory,
+except (({win32})) directory in the source directory.
+This is restriction originating in the path search method of (({NMAKE})).
+
+=end
diff --git a/jni/ruby/win32/configure.bat b/jni/ruby/win32/configure.bat
new file mode 100755
index 0000000..edf18b7
--- /dev/null
+++ b/jni/ruby/win32/configure.bat
@@ -0,0 +1,216 @@
+@echo off

+@setlocal disabledelayedexpansion

+set witharg=

+

+for %%I in (%0) do if /%%~dpI/ == /%CD%\/ (

+    echo don't run in win32 directory.

+    exit /b 999

+)

+

+echo> ~tmp~.mak ####

+echo>> ~tmp~.mak conf = %0

+echo>> ~tmp~.mak $(conf): nul

+echo>> ~tmp~.mak 	@del ~setup~.mak

+echo>> ~tmp~.mak 	@-$(MAKE) -l$(MAKEFLAGS) -f $(@D)/setup.mak \

+if exist pathlist.tmp del pathlist.tmp

+echo>confargs.tmp #define CONFIGURE_ARGS \

+:loop

+set opt=%1

+if "%1" == "" goto :end

+if "%1" == "--prefix" goto :prefix

+if "%1" == "--srcdir" goto :srcdir

+if "%1" == "srcdir" goto :srcdir

+if "%1" == "--target" goto :target

+if "%1" == "target" goto :target

+if "%1" == "--with-static-linked-ext" goto :extstatic

+if "%1" == "--program-prefix" goto :pprefix

+if "%1" == "--program-suffix" goto :suffix

+if "%1" == "--program-name" goto :installname

+if "%1" == "--install-name" goto :installname

+if "%1" == "--so-name" goto :soname

+if "%1" == "--enable-install-doc" goto :enable-rdoc

+if "%1" == "--disable-install-doc" goto :disable-rdoc

+if "%1" == "--enable-debug-env" goto :enable-debug-env

+if "%1" == "--disable-debug-env" goto :disable-debug-env

+if "%1" == "--enable-rubygems" goto :enable-rubygems

+if "%1" == "--disable-rubygems" goto :disable-rubygems

+if "%1" == "--extout" goto :extout

+if "%1" == "--path" goto :path

+if "%1" == "--with-baseruby" goto :baseruby

+if "%1" == "--with-ntver" goto :ntver

+if "%1" == "--without-ext" goto :witharg

+if "%1" == "--without-extensions" goto :witharg

+if "%opt:~0,10%" == "--without-" goto :withoutarg

+if "%opt:~0,7%" == "--with-" goto :witharg

+if "%1" == "-h" goto :help

+if "%1" == "--help" goto :help

+  if "%opt:~0,1%" == "-" (

+    echo>>confargs.tmp  %1 \

+    set witharg=

+  ) else if "%witharg" == "" (

+    echo>>confargs.tmp  %1 \

+  ) else (

+    echo>>confargs.tmp ,%1\

+  )

+  shift

+goto :loop

+:srcdir

+  echo>> ~tmp~.mak 	"srcdir=%~2" \

+  echo>>confargs.tmp --srcdir=%2 \

+  shift

+  shift

+goto :loop

+:prefix

+  echo>> ~tmp~.mak 	"prefix=%~2" \

+  echo>>confargs.tmp  %1=%2 \

+  shift

+  shift

+goto :loop

+:pprefix

+  echo>> ~tmp~.mak 	"PROGRAM_PREFIX=%~2" \

+  echo>>confargs.tmp  %1=%2 \

+  shift

+  shift

+goto :loop

+:suffix

+  echo>> ~tmp~.mak 	"PROGRAM_SUFFIX=%~2" \

+  echo>>confargs.tmp  %1=%2 \

+  shift

+  shift

+goto :loop

+:installname

+  echo>> ~tmp~.mak 	"RUBY_INSTALL_NAME=%~2" \

+  echo>>confargs.tmp  %1=%2 \

+  shift

+  shift

+goto :loop

+:soname

+  echo>> ~tmp~.mak 	"RUBY_SO_NAME=%~2" \

+  echo>>confargs.tmp  %1=%2 \

+  shift

+  shift

+goto :loop

+:target

+  echo>> ~tmp~.mak 	"%~2" \

+  echo>>confargs.tmp --target=%2 \

+  if "%~2" == "x64-mswin64" goto target2

+  if NOT "%~2" == "ia64-mswin64" goto target3

+:target2

+  echo>> ~tmp~.mak 	"TARGET_OS=mswin64" \

+:target3

+  shift

+  shift

+goto :loop

+:extstatic

+  echo>> ~tmp~.mak 	"EXTSTATIC=static" \

+  echo>>confargs.tmp %1 \

+  shift

+goto :loop

+:enable-rdoc

+  echo>> ~tmp~.mak 	"RDOCTARGET=rdoc" \

+  echo>>confargs.tmp %1 \

+  shift

+goto :loop

+:disable-rdoc

+  echo>> ~tmp~.mak 	"RDOCTARGET=nodoc" \

+  echo>>confargs.tmp %1 \

+  shift

+goto :loop

+:enable-debug-env

+  echo>> ~tmp~.mak 	"ENABLE_DEBUG_ENV=yes" \

+  echo>>confargs.tmp %1 \

+  shift

+goto :loop

+:disable-debug-env

+  echo>> ~tmp~.mak 	"ENABLE_DEBUG_ENV=no" \

+  echo>>confargs.tmp %1 \

+  shift

+goto :loop

+:enable-rubygems

+  echo>> ~tmp~.mak 	"USE_RUBYGEMS=YES" \

+  echo>>confargs.tmp %1 \

+  shift

+goto :loop

+:disable-rubygems

+  echo>> ~tmp~.mak 	"USE_RUBYGEMS=NO" \

+  echo>>confargs.tmp %1 \

+  shift

+goto :loop

+:ntver

+  echo>> ~tmp~.mak 	"NTVER=%~2" \

+  echo>>confargs.tmp  %1=%2 \

+  shift

+  shift

+goto :loop

+:extout

+  echo>> ~tmp~.mak 	"EXTOUT=%~2" \

+  echo>>confargs.tmp  %1=%2 \

+  shift

+  shift

+goto :loop

+:path

+  echo>>pathlist.tmp %~2;\

+  echo>>confargs.tmp  %1=%2 \

+  shift

+  shift

+goto :loop

+:baseruby

+  echo>> ~tmp~.mak 	"BASERUBY=%~2" \

+  echo>>confargs.tmp  %1=%2 \

+  shift

+  shift

+goto :loop

+:witharg

+  echo>>confargs.tmp  %1=%2\

+  set witharg=1

+  shift

+  shift

+goto :loop

+:withoutarg

+  echo>>confargs.tmp  %1 \

+  shift

+goto :loop

+:help

+  echo Configuration:

+  echo   --help                  display this help

+  echo   --srcdir=DIR            find the sources in DIR [configure dir or `..']

+  echo Installation directories:

+  echo   --prefix=PREFIX         install files in PREFIX [/usr]

+  echo System types:

+  echo   --target=TARGET         configure for TARGET [i386-mswin32]

+  echo Optional Package:

+  echo   --with-baseruby=RUBY    use RUBY as baseruby [ruby]

+  echo   --with-static-linked-ext link external modules statically

+  echo   --with-ext="a,b,..."    use extensions a, b, ...

+  echo   --without-ext="a,b,..." ignore extensions a, b, ...

+  echo   --disable-install-doc   do not install rdoc indexes during install

+  echo   --with-ntver=0xXXXX     target NT version (shouldn't use with old SDK)

+  del *.tmp

+  del ~tmp~.mak

+goto :exit

+:end

+echo>> ~tmp~.mak 	WIN32DIR=$(@D:\=/)

+echo.>>confargs.tmp

+echo>confargs.c #define $ $$ 

+echo>>confargs.c !ifndef CONFIGURE_ARGS

+type>>confargs.c confargs.tmp

+echo>>confargs.c configure_args = CONFIGURE_ARGS

+echo>>confargs.c !endif

+echo>>confargs.c #undef $

+if exist pathlist.tmp echo>>confargs.c #define PATH_LIST \

+if exist pathlist.tmp type>>confargs.c pathlist.tmp

+if exist pathlist.tmp echo.>>confargs.c

+if exist pathlist.tmp echo>>confargs.c pathlist = PATH_LIST

+cl -EP confargs.c > ~setup~.mak 2>nul

+if exist pathlist.tmp echo>>~setup~.mak PATH = $(pathlist:;=/bin;)$(PATH)

+if exist pathlist.tmp echo>>~setup~.mak INCLUDE = $(pathlist:;=/include;)

+if exist pathlist.tmp echo>>~setup~.mak LIB = $(pathlist:;=/lib;)

+type>>~setup~.mak ~tmp~.mak

+del *.tmp > nul

+del ~tmp~.mak > nul

+echo>>~setup~.mak 	@if exist Makefile.old del Makefile.old

+echo>>~setup~.mak 	@if exist Makefile ren Makefile Makefile.old

+echo>>~setup~.mak 	@ren Makefile.new Makefile

+nmake -alf ~setup~.mak MAKEFILE=Makefile.new

+:exit

+@endlocal

diff --git a/jni/ruby/win32/dir.h b/jni/ruby/win32/dir.h
new file mode 100644
index 0000000..0e1bff0
--- /dev/null
+++ b/jni/ruby/win32/dir.h
@@ -0,0 +1,45 @@
+#ifndef RUBY_WIN32_DIR_H
+#define RUBY_WIN32_DIR_H
+
+#ifdef __BORLANDC__
+#  ifndef WIN32_DIR_H_
+#    define WIN32_DIR_H_
+#    include <sys/types.h>
+#  endif
+#endif
+
+struct direct
+{
+    long d_namlen;
+    ino_t d_ino;
+    char *d_name;
+    char d_isdir; /* directory */
+    char d_isrep; /* reparse point */
+};
+typedef struct {
+    WCHAR *start;
+    WCHAR *curr;
+    long size;
+    long nfiles;
+    long loc;  /* [0, nfiles) */
+    struct direct dirstr;
+    char *bits;  /* used for d_isdir and d_isrep */
+} DIR;
+
+
+DIR*           rb_w32_opendir(const char*);
+DIR*           rb_w32_uopendir(const char*);
+struct direct* rb_w32_readdir(DIR *, rb_encoding *);
+long           rb_w32_telldir(DIR *);
+void           rb_w32_seekdir(DIR *, long);
+void           rb_w32_rewinddir(DIR *);
+void           rb_w32_closedir(DIR *);
+
+#define opendir(s)   rb_w32_opendir((s))
+#define readdir(d)   rb_w32_readdir((d), 0)
+#define telldir(d)   rb_w32_telldir((d))
+#define seekdir(d, l)   rb_w32_seekdir((d), (l))
+#define rewinddir(d) rb_w32_rewinddir((d))
+#define closedir(d)  rb_w32_closedir((d))
+
+#endif /* RUBY_WIN32_DIR_H */
diff --git a/jni/ruby/win32/enc-setup.mak b/jni/ruby/win32/enc-setup.mak
new file mode 100644
index 0000000..44345a2
--- /dev/null
+++ b/jni/ruby/win32/enc-setup.mak
@@ -0,0 +1,10 @@
+encs: BUILTIN_ENCOBJS BUILTIN_TRANSOBJS
+BUILTIN_ENCOBJS BUILTIN_TRANSOBJS: $(srcdir)/enc/Makefile.in
+
+!include $(srcdir)/enc/Makefile.in
+
+BUILTIN_ENCOBJS:
+	@echo BUILTIN_ENCOBJS = $(BUILTIN_ENCS:.c=.obj) >> $(MAKEFILE)
+
+BUILTIN_TRANSOBJS:
+	@echo BUILTIN_TRANSOBJS = $(BUILTIN_TRANSES:.trans=.obj) >> $(MAKEFILE)
diff --git a/jni/ruby/win32/file.c b/jni/ruby/win32/file.c
new file mode 100644
index 0000000..38b3d12
--- /dev/null
+++ b/jni/ruby/win32/file.c
@@ -0,0 +1,682 @@
+#include "ruby/ruby.h"
+#include "ruby/encoding.h"
+#include "ruby/thread.h"
+#include "internal.h"
+#include <winbase.h>
+#include <wchar.h>
+#include <shlwapi.h>
+
+#ifndef INVALID_FILE_ATTRIBUTES
+# define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
+#endif
+
+/* cache 'encoding name' => 'code page' into a hash */
+static struct code_page_table {
+    USHORT *table;
+    unsigned int count;
+} rb_code_page;
+
+#define IS_DIR_SEPARATOR_P(c) (c == L'\\' || c == L'/')
+#define IS_DIR_UNC_P(c) (IS_DIR_SEPARATOR_P(c[0]) && IS_DIR_SEPARATOR_P(c[1]))
+
+/* MultiByteToWideChar() doesn't work with code page 51932 */
+#define INVALID_CODE_PAGE 51932
+#define PATH_BUFFER_SIZE MAX_PATH * 2
+
+#define insecure_obj_p(obj, level) ((level) >= 4 || ((level) > 0 && OBJ_TAINTED(obj)))
+
+/* defined in win32/win32.c */
+#define system_code_page rb_w32_filecp
+#define mbstr_to_wstr rb_w32_mbstr_to_wstr
+#define wstr_to_mbstr rb_w32_wstr_to_mbstr
+UINT rb_w32_filecp(void);
+WCHAR *rb_w32_mbstr_to_wstr(UINT, const char *, int, long *);
+char *rb_w32_wstr_to_mbstr(UINT, const WCHAR *, int, long *);
+
+static inline void
+replace_wchar(wchar_t *s, int find, int replace)
+{
+    while (*s != 0) {
+	if (*s == find)
+	    *s = replace;
+	s++;
+    }
+}
+
+/*
+  Return user's home directory using environment variables combinations.
+  Memory allocated by this function should be manually freed afterwards.
+
+  Try:
+  HOME, HOMEDRIVE + HOMEPATH and USERPROFILE environment variables
+  TODO: Special Folders - Profile and Personal
+*/
+static wchar_t *
+home_dir(void)
+{
+    wchar_t *buffer = NULL;
+    size_t buffer_len = 0, len = 0;
+    size_t home_env = 0;
+
+    /*
+      GetEnvironmentVariableW when used with NULL will return the required
+      buffer size and its terminating character.
+      http://msdn.microsoft.com/en-us/library/windows/desktop/ms683188(v=vs.85).aspx
+    */
+
+    if ((len = GetEnvironmentVariableW(L"HOME", NULL, 0)) != 0) {
+	buffer_len = len;
+	home_env = 1;
+    }
+    else if ((len = GetEnvironmentVariableW(L"HOMEDRIVE", NULL, 0)) != 0) {
+	buffer_len = len;
+	if ((len = GetEnvironmentVariableW(L"HOMEPATH", NULL, 0)) != 0) {
+	    buffer_len += len;
+	    home_env = 2;
+	}
+	else {
+	    buffer_len = 0;
+	}
+    }
+    else if ((len = GetEnvironmentVariableW(L"USERPROFILE", NULL, 0)) != 0) {
+	buffer_len = len;
+	home_env = 3;
+    }
+
+    /* allocate buffer */
+    if (home_env)
+	buffer = (wchar_t *)xmalloc(buffer_len * sizeof(wchar_t));
+
+    switch (home_env) {
+      case 1:
+	/* HOME */
+	GetEnvironmentVariableW(L"HOME", buffer, buffer_len);
+	break;
+      case 2:
+	/* HOMEDRIVE + HOMEPATH */
+	len = GetEnvironmentVariableW(L"HOMEDRIVE", buffer, buffer_len);
+	GetEnvironmentVariableW(L"HOMEPATH", buffer + len, buffer_len - len);
+	break;
+      case 3:
+	/* USERPROFILE */
+	GetEnvironmentVariableW(L"USERPROFILE", buffer, buffer_len);
+	break;
+      default:
+	break;
+    }
+
+    if (home_env) {
+	/* sanitize backslashes with forwardslashes */
+	replace_wchar(buffer, L'\\', L'/');
+
+	return buffer;
+    }
+
+    return NULL;
+}
+
+/* Remove trailing invalid ':$DATA' of the path. */
+static inline size_t
+remove_invalid_alternative_data(wchar_t *wfullpath, size_t size)
+{
+    static const wchar_t prime[] = L":$DATA";
+    enum { prime_len = (sizeof(prime) / sizeof(wchar_t)) -1 };
+
+    if (size <= prime_len || _wcsnicmp(wfullpath + size - prime_len, prime, prime_len) != 0)
+	return size;
+
+    /* alias of stream */
+    /* get rid of a bug of x64 VC++ */
+    if (wfullpath[size - (prime_len + 1)] == ':') {
+	/* remove trailing '::$DATA' */
+	size -= prime_len + 1; /* prime */
+	wfullpath[size] = L'\0';
+    }
+    else {
+	/* remove trailing ':$DATA' of paths like '/aa:a:$DATA' */
+	wchar_t *pos = wfullpath + size - (prime_len + 1);
+	while (!IS_DIR_SEPARATOR_P(*pos) && pos != wfullpath) {
+	    if (*pos == L':') {
+		size -= prime_len; /* alternative */
+		wfullpath[size] = L'\0';
+		break;
+	    }
+	    pos--;
+	}
+    }
+    return size;
+}
+
+void rb_enc_foreach_name(int (*func)(st_data_t name, st_data_t idx, st_data_t arg), st_data_t arg);
+
+static int
+code_page_i(st_data_t name, st_data_t idx, st_data_t arg)
+{
+    const char *n = (const char *)name;
+    if (strncmp("CP", n, 2) == 0) {
+	int code_page = atoi(n + 2);
+	if (code_page != 0) {
+	    struct code_page_table *cp = (struct code_page_table *)arg;
+	    unsigned int count = cp->count;
+	    USHORT *table = cp->table;
+	    if (count <= idx) {
+		unsigned int i = count;
+		cp->count = count = (((idx + 4) & ~31) | 28);
+		cp->table = table = realloc(table, count * sizeof(*table));
+		while (i < count) table[i++] = INVALID_CODE_PAGE;
+	    }
+	    table[idx] = (USHORT)code_page;
+	}
+    }
+    return ST_CONTINUE;
+}
+
+/*
+  Return code page number of the encoding.
+  Cache code page into a hash for performance since finding the code page in
+  Encoding#names is slow.
+*/
+static UINT
+code_page(rb_encoding *enc)
+{
+    int enc_idx;
+
+    if (!enc)
+	return system_code_page();
+
+    enc_idx = rb_enc_to_index(enc);
+
+    /* map US-ASCII and ASCII-8bit as code page 1252 (us-ascii) */
+    if (enc_idx == rb_usascii_encindex() || enc_idx == rb_ascii8bit_encindex()) {
+	return 1252;
+    }
+    if (enc_idx == rb_utf8_encindex()) {
+	return CP_UTF8;
+    }
+
+    if (0 <= enc_idx && (unsigned int)enc_idx < rb_code_page.count)
+	return rb_code_page.table[enc_idx];
+
+    return INVALID_CODE_PAGE;
+}
+
+#define fix_string_encoding(str, encoding) rb_str_conv_enc((str), (encoding), rb_utf8_encoding())
+
+/*
+  Replace the last part of the path to long name.
+  We try to avoid to call FindFirstFileW() since it takes long time.
+*/
+static inline size_t
+replace_to_long_name(wchar_t **wfullpath, size_t size, int heap)
+{
+    WIN32_FIND_DATAW find_data;
+    HANDLE find_handle;
+
+    /*
+      Skip long name conversion if the path is already long name.
+      Short name is 8.3 format.
+      http://en.wikipedia.org/wiki/8.3_filename
+      This check can be skipped for directory components that have file
+      extensions longer than 3 characters, or total lengths longer than
+      12 characters.
+      http://msdn.microsoft.com/en-us/library/windows/desktop/aa364980(v=vs.85).aspx
+    */
+    size_t const max_short_name_size = 8 + 1 + 3;
+    size_t const max_extension_size = 3;
+    size_t path_len = 1, extension_len = 0;
+    wchar_t *pos = *wfullpath;
+
+    if (size == 3 && pos[1] == L':' && pos[2] == L'\\' && pos[3] == L'\0') {
+	/* root path doesn't need short name expansion */
+	return size;
+    }
+
+    /* skip long name conversion if path contains wildcard characters */
+    if (wcspbrk(pos, L"*?")) {
+	return size;
+    }
+
+    pos = *wfullpath + size - 1;
+    while (!IS_DIR_SEPARATOR_P(*pos) && pos != *wfullpath) {
+	if (!extension_len && *pos == L'.') {
+	    extension_len = path_len - 1;
+	}
+	if (path_len > max_short_name_size || extension_len > max_extension_size) {
+	    return size;
+	}
+	path_len++;
+	pos--;
+    }
+
+    find_handle = FindFirstFileW(*wfullpath, &find_data);
+    if (find_handle != INVALID_HANDLE_VALUE) {
+	size_t trail_pos = wcslen(*wfullpath);
+	size_t file_len = wcslen(find_data.cFileName);
+
+	FindClose(find_handle);
+	while (trail_pos > 0) {
+	    if (IS_DIR_SEPARATOR_P((*wfullpath)[trail_pos]))
+		break;
+	    trail_pos--;
+	}
+	size = trail_pos + 1 + file_len;
+	if ((size + 1) > sizeof(*wfullpath) / sizeof((*wfullpath)[0])) {
+	    wchar_t *buf = (wchar_t *)xmalloc((size + 1) * sizeof(wchar_t));
+	    wcsncpy(buf, *wfullpath, trail_pos + 1);
+	    if (heap)
+		xfree(*wfullpath);
+	    *wfullpath = buf;
+	}
+	wcsncpy(*wfullpath + trail_pos + 1, find_data.cFileName, file_len + 1);
+    }
+    return size;
+}
+
+static inline size_t
+user_length_in_path(const wchar_t *wuser, size_t len)
+{
+    size_t i;
+
+    for (i = 0; i < len && !IS_DIR_SEPARATOR_P(wuser[i]); i++)
+	;
+
+    return i;
+}
+
+static VALUE
+append_wstr(VALUE dst, const wchar_t *ws, size_t len, UINT cp, UINT path_cp, rb_encoding *path_encoding)
+{
+    long olen, nlen = (long)len;
+
+    if (cp == path_cp) {
+	nlen = WideCharToMultiByte(cp, 0, ws, len, NULL, 0, NULL, NULL);
+	olen = RSTRING_LEN(dst);
+	rb_str_modify_expand(dst, nlen);
+	WideCharToMultiByte(cp, 0, ws, len, RSTRING_PTR(dst) + olen, nlen, NULL, NULL);
+	rb_enc_associate(dst, path_encoding);
+	rb_str_set_len(dst, olen + nlen);
+    }
+    else {
+	const int replaceflags = ECONV_UNDEF_REPLACE|ECONV_INVALID_REPLACE;
+	char *utf8str = wstr_to_mbstr(CP_UTF8, ws, (int)len, &nlen);
+	rb_econv_t *ec = rb_econv_open("UTF-8", rb_enc_name(path_encoding), replaceflags);
+	dst = rb_econv_append(ec, utf8str, nlen, dst, replaceflags);
+	rb_econv_close(ec);
+	free(utf8str);
+    }
+    return dst;
+}
+
+VALUE
+rb_file_expand_path_internal(VALUE fname, VALUE dname, int abs_mode, int long_name, VALUE result)
+{
+    size_t size = 0, whome_len = 0;
+    size_t buffer_len = 0;
+    long wpath_len = 0, wdir_len = 0;
+    char *fullpath = NULL;
+    wchar_t *wfullpath = NULL, *wpath = NULL, *wpath_pos = NULL;
+    wchar_t *wdir = NULL, *wdir_pos = NULL;
+    wchar_t *whome = NULL, *buffer = NULL, *buffer_pos = NULL;
+    UINT path_cp, cp;
+    VALUE path = fname, dir = dname;
+    wchar_t wfullpath_buffer[PATH_BUFFER_SIZE];
+    wchar_t path_drive = L'\0', dir_drive = L'\0';
+    int ignore_dir = 0;
+    rb_encoding *path_encoding;
+    int tainted = 0;
+
+    /* tainted if path is tainted */
+    tainted = OBJ_TAINTED(path);
+
+    /* get path encoding */
+    if (NIL_P(dir)) {
+	path_encoding = rb_enc_get(path);
+    }
+    else {
+	path_encoding = rb_enc_check(path, dir);
+    }
+
+    cp = path_cp = code_page(path_encoding);
+
+    /* workaround invalid codepage */
+    if (path_cp == INVALID_CODE_PAGE) {
+	cp = CP_UTF8;
+	if (!NIL_P(path)) {
+	    path = fix_string_encoding(path, path_encoding);
+	}
+    }
+
+    /* convert char * to wchar_t */
+    if (!NIL_P(path)) {
+	wpath = mbstr_to_wstr(cp, RSTRING_PTR(path), (int)RSTRING_LEN(path), &wpath_len);
+	wpath_pos = wpath;
+    }
+
+    /* determine if we need the user's home directory */
+    /* expand '~' only if NOT rb_file_absolute_path() where `abs_mode` is 1 */
+    if (abs_mode == 0 && wpath_len > 0 && wpath_pos[0] == L'~' &&
+	(wpath_len == 1 || IS_DIR_SEPARATOR_P(wpath_pos[1]))) {
+	/* tainted if expanding '~' */
+	tainted = 1;
+
+	whome = home_dir();
+	if (whome == NULL) {
+	    xfree(wpath);
+	    rb_raise(rb_eArgError, "couldn't find HOME environment -- expanding `~'");
+	}
+	whome_len = wcslen(whome);
+
+	if (PathIsRelativeW(whome) && !(whome_len >= 2 && IS_DIR_UNC_P(whome))) {
+	    xfree(wpath);
+	    xfree(whome);
+	    rb_raise(rb_eArgError, "non-absolute home");
+	}
+
+	if (path_cp == INVALID_CODE_PAGE || rb_enc_str_asciionly_p(path)) {
+	    /* use filesystem encoding if expanding home dir */
+	    path_encoding = rb_filesystem_encoding();
+	    cp = path_cp = system_code_page();
+	}
+
+	/* ignores dir since we are expanding home */
+	ignore_dir = 1;
+
+	/* exclude ~ from the result */
+	wpath_pos++;
+	wpath_len--;
+
+	/* exclude separator if present */
+	if (wpath_len && IS_DIR_SEPARATOR_P(wpath_pos[0])) {
+	    wpath_pos++;
+	    wpath_len--;
+	}
+    }
+    else if (wpath_len >= 2 && wpath_pos[1] == L':') {
+	if (wpath_len >= 3 && IS_DIR_SEPARATOR_P(wpath_pos[2])) {
+	    /* ignore dir since path contains a drive letter and a root slash */
+	    ignore_dir = 1;
+	}
+	else {
+	    /* determine if we ignore dir or not later */
+	    path_drive = wpath_pos[0];
+	    wpath_pos += 2;
+	    wpath_len -= 2;
+	}
+    }
+    else if (abs_mode == 0 && wpath_len >= 2 && wpath_pos[0] == L'~') {
+	result = rb_str_new_cstr("can't find user ");
+	result = append_wstr(result, wpath_pos + 1, user_length_in_path(wpath_pos + 1, wpath_len - 1),
+			     cp, path_cp, path_encoding);
+
+	if (wpath)
+	    xfree(wpath);
+
+	rb_exc_raise(rb_exc_new_str(rb_eArgError, result));
+    }
+
+    /* convert dir */
+    if (!ignore_dir && !NIL_P(dir)) {
+	/* fix string encoding */
+	if (path_cp == INVALID_CODE_PAGE) {
+	    dir = fix_string_encoding(dir, path_encoding);
+	}
+
+	/* convert char * to wchar_t */
+	if (!NIL_P(dir)) {
+	    wdir = mbstr_to_wstr(cp, RSTRING_PTR(dir), (int)RSTRING_LEN(dir), &wdir_len);
+	    wdir_pos = wdir;
+	}
+
+	if (abs_mode == 0 && wdir_len > 0 && wdir_pos[0] == L'~' &&
+	    (wdir_len == 1 || IS_DIR_SEPARATOR_P(wdir_pos[1]))) {
+	    /* tainted if expanding '~' */
+	    tainted = 1;
+
+	    whome = home_dir();
+	    if (whome == NULL) {
+		free(wpath);
+		free(wdir);
+		rb_raise(rb_eArgError, "couldn't find HOME environment -- expanding `~'");
+	    }
+	    whome_len = wcslen(whome);
+
+	    if (PathIsRelativeW(whome) && !(whome_len >= 2 && IS_DIR_UNC_P(whome))) {
+		free(wpath);
+		free(wdir);
+		xfree(whome);
+		rb_raise(rb_eArgError, "non-absolute home");
+	    }
+
+	    /* exclude ~ from the result */
+	    wdir_pos++;
+	    wdir_len--;
+
+	    /* exclude separator if present */
+	    if (wdir_len && IS_DIR_SEPARATOR_P(wdir_pos[0])) {
+		wdir_pos++;
+		wdir_len--;
+	    }
+	}
+	else if (wdir_len >= 2 && wdir[1] == L':') {
+	    dir_drive = wdir[0];
+	    if (wpath_len && IS_DIR_SEPARATOR_P(wpath_pos[0])) {
+		wdir_len = 2;
+	    }
+	}
+	else if (wdir_len >= 2 && IS_DIR_UNC_P(wdir)) {
+	    /* UNC path */
+	    if (wpath_len && IS_DIR_SEPARATOR_P(wpath_pos[0])) {
+		/* cut the UNC path tail to '//host/share' */
+		long separators = 0;
+		long pos = 2;
+		while (pos < wdir_len && separators < 2) {
+		    if (IS_DIR_SEPARATOR_P(wdir[pos])) {
+			separators++;
+		    }
+		    pos++;
+		}
+		if (separators == 2)
+		    wdir_len = pos - 1;
+	    }
+	}
+	else if (abs_mode == 0 && wdir_len >= 2 && wdir_pos[0] == L'~') {
+	    result = rb_str_new_cstr("can't find user ");
+	    result = append_wstr(result, wdir_pos + 1, user_length_in_path(wdir_pos + 1, wdir_len - 1),
+				 cp, path_cp, path_encoding);
+	    if (wpath)
+		free(wpath);
+
+	    if (wdir)
+		free(wdir);
+
+	    rb_exc_raise(rb_exc_new_str(rb_eArgError, result));
+	}
+    }
+
+    /* determine if we ignore dir or not */
+    if (!ignore_dir && path_drive && dir_drive) {
+	if (towupper(path_drive) != towupper(dir_drive)) {
+	    /* ignore dir since path drive is different from dir drive */
+	    ignore_dir = 1;
+	    wdir_len = 0;
+	    dir_drive = 0;
+	}
+    }
+
+    if (!ignore_dir && wpath_len >= 2 && IS_DIR_UNC_P(wpath)) {
+	/* ignore dir since path has UNC root */
+	ignore_dir = 1;
+	wdir_len = 0;
+    }
+    else if (!ignore_dir && wpath_len >= 1 && IS_DIR_SEPARATOR_P(wpath[0]) &&
+	     !dir_drive && !(wdir_len >= 2 && IS_DIR_UNC_P(wdir))) {
+	/* ignore dir since path has root slash and dir doesn't have drive or UNC root */
+	ignore_dir = 1;
+	wdir_len = 0;
+    }
+
+    buffer_len = wpath_len + 1 + wdir_len + 1 + whome_len + 1;
+
+    buffer = buffer_pos = (wchar_t *)xmalloc((buffer_len + 1) * sizeof(wchar_t));
+
+    /* add home */
+    if (whome_len) {
+	wcsncpy(buffer_pos, whome, whome_len);
+	buffer_pos += whome_len;
+    }
+
+    /* Add separator if required */
+    if (whome_len && wcsrchr(L"\\/:", buffer_pos[-1]) == NULL) {
+	buffer_pos[0] = L'\\';
+	buffer_pos++;
+    }
+    else if (!dir_drive && path_drive) {
+	*buffer_pos++ = path_drive;
+	*buffer_pos++ = L':';
+    }
+
+    if (wdir_len) {
+	/* tainted if dir is used and dir is tainted */
+	if (!tainted && OBJ_TAINTED(dir))
+	    tainted = 1;
+
+	wcsncpy(buffer_pos, wdir_pos, wdir_len);
+	buffer_pos += wdir_len;
+    }
+
+    /* add separator if required */
+    if (wdir_len && wcsrchr(L"\\/:", buffer_pos[-1]) == NULL) {
+	buffer_pos[0] = L'\\';
+	buffer_pos++;
+    }
+
+    /* now deal with path */
+    if (wpath_len) {
+	wcsncpy(buffer_pos, wpath_pos, wpath_len);
+	buffer_pos += wpath_len;
+    }
+
+    /* GetFullPathNameW requires at least "." to determine current directory */
+    if (wpath_len == 0) {
+	buffer_pos[0] = L'.';
+	buffer_pos++;
+    }
+
+    /* Ensure buffer is NULL terminated */
+    buffer_pos[0] = L'\0';
+
+    /* tainted if path is relative */
+    if (!tainted && PathIsRelativeW(buffer) && !(buffer_len >= 2 && IS_DIR_UNC_P(buffer)))
+	tainted = 1;
+
+    /* FIXME: Make this more robust */
+    /* Determine require buffer size */
+    size = GetFullPathNameW(buffer, PATH_BUFFER_SIZE, wfullpath_buffer, NULL);
+    if (size > PATH_BUFFER_SIZE) {
+	/* allocate more memory than alloted originally by PATH_BUFFER_SIZE */
+	wfullpath = (wchar_t *)xmalloc(size * sizeof(wchar_t));
+	size = GetFullPathNameW(buffer, size, wfullpath, NULL);
+    }
+    else {
+	wfullpath = wfullpath_buffer;
+    }
+
+    /* Remove any trailing slashes */
+    if (IS_DIR_SEPARATOR_P(wfullpath[size - 1]) &&
+	wfullpath[size - 2] != L':' &&
+	!(size == 2 && IS_DIR_UNC_P(wfullpath))) {
+	size -= 1;
+	wfullpath[size] = L'\0';
+    }
+
+    /* Remove any trailing dot */
+    if (wfullpath[size - 1] == L'.') {
+	size -= 1;
+	wfullpath[size] = L'\0';
+    }
+
+    /* removes trailing invalid ':$DATA' */
+    size = remove_invalid_alternative_data(wfullpath, size);
+
+    /* Replace the trailing path to long name */
+    if (long_name)
+	size = replace_to_long_name(&wfullpath, size, (wfullpath != wfullpath_buffer));
+
+    /* sanitize backslashes with forwardslashes */
+    replace_wchar(wfullpath, L'\\', L'/');
+
+    /* convert to VALUE and set the path encoding */
+    rb_str_set_len(result, 0);
+    result = append_wstr(result, wfullpath, size, cp, path_cp, path_encoding);
+
+    /* makes the result object tainted if expanding tainted strings or returning modified path */
+    if (tainted)
+	OBJ_TAINT(result);
+
+    /* TODO: better cleanup */
+    if (buffer)
+	xfree(buffer);
+
+    if (wpath)
+	free(wpath);
+
+    if (wdir)
+	free(wdir);
+
+    if (whome)
+	xfree(whome);
+
+    if (wfullpath && wfullpath != wfullpath_buffer)
+	xfree(wfullpath);
+
+    if (fullpath)
+	xfree(fullpath);
+
+    rb_enc_associate(result, path_encoding);
+    return result;
+}
+
+static void *
+loadopen_func(void *wpath)
+{
+    return (void *)CreateFileW(wpath, GENERIC_READ,
+			       FILE_SHARE_READ | FILE_SHARE_WRITE,
+			       NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+}
+
+int
+rb_file_load_ok(const char *path)
+{
+    DWORD attr;
+    int ret = 1;
+    long len;
+    wchar_t* wpath;
+
+    wpath = mbstr_to_wstr(CP_UTF8, path, -1, &len);
+    if (!wpath) return 0;
+
+    attr = GetFileAttributesW(wpath);
+    if (attr == INVALID_FILE_ATTRIBUTES ||
+	(attr & FILE_ATTRIBUTE_DIRECTORY)) {
+	ret = 0;
+    }
+    else {
+	HANDLE h = (HANDLE)rb_thread_call_without_gvl(loadopen_func, (void *)wpath,
+						      RUBY_UBF_IO, 0);
+	if (h != INVALID_HANDLE_VALUE) {
+	    CloseHandle(h);
+	}
+	else {
+	    ret = 0;
+	}
+    }
+    free(wpath);
+    return ret;
+}
+
+void
+Init_w32_codepage(void)
+{
+    if (rb_code_page.count) return;
+    rb_enc_foreach_name(code_page_i, (st_data_t)&rb_code_page);
+}
diff --git a/jni/ruby/win32/ifchange.bat b/jni/ruby/win32/ifchange.bat
new file mode 100755
index 0000000..ed10914
--- /dev/null
+++ b/jni/ruby/win32/ifchange.bat
@@ -0,0 +1,95 @@
+@echo off

+:: usage: ifchange target temporary

+

+set timestamp=

+set keepsuffix=

+set empty=

+:optloop

+for %%I in (%1) do set opt=%%~I

+if "%opt%" == "--timestamp" (

+    set timestamp=.

+    shift

+    goto :optloop

+) else if "%opt:~0,12%" == "--timestamp=" (

+    set timestamp=%opt:~12%

+    shift

+    goto :optloop

+) else if "%opt%" == "--keep" (

+    set keepsuffix=.old

+    shift

+    goto :optloop

+) else if "%opt:~0,7%" == "--keep=" (

+    set keepsuffix=%opt:~7%

+    shift

+    goto :optloop

+) else if "%opt%" == "--empty" (

+    set empty=yes

+    shift

+    goto :optloop

+)

+if "%opt%" == "" goto :end

+

+set dest=%1

+set src=%2

+set dest=%dest:/=\%

+set src=%src:/=\%

+if not "%dest%" == "" if not "%dest%" == "%%dest:/=\%%" goto :nt

+

+if not exist %2 goto :end

+

+:: check if fc.exe works.

+echo foo > conftst1.tmp

+echo bar > conftst2.tmp

+fc.exe conftst1.tmp conftst2.tmp > nul

+if not errorlevel 1 goto :brokenfc

+del conftst1.tmp > nul

+del conftst2.tmp > nul

+

+:: target does not exist or new file differs from it.

+if not exist %1 goto :update

+fc.exe %1 %2 > nul

+if errorlevel 1 goto :update

+

+:unchange

+echo %1 unchanged.

+del %2

+goto :end

+

+:brokenfc

+del conftest1.tmp > nul

+del conftest2.tmp > nul

+echo FC.EXE does not work properly.

+echo assuming %1 should be changed.

+

+:update

+echo %1 updated.

+:: if exist %1 del %1

+dir /b %2

+if "%keepsuffix%" != "" %1 %1%keepsuffix%

+copy %2 %1

+del %2

+goto :end

+

+:nt

+if exist %dest% (

+    if not exist %src% goto :nt_unchanged1

+    if "%empty%" == "" for %%I in (%src%) do if %%~zI == 0 goto :nt_unchanged

+    fc.exe %dest% %src% > nul && (

+      :nt_unchanged

+	del %src%

+      :nt_unchanged1

+	for %%I in (%1) do echo %%~I unchanged

+	goto :nt_end

+    )

+)

+for %%I in (%1) do echo %%~I updated

+copy %src% %dest% > nul

+del %src%

+

+:nt_end

+if "%timestamp%" == "" goto :end

+    if "%timestamp%" == "." (

+        for %%I in ("%dest%") do set timestamp=%%~dpI.time.%%~nxI

+    )

+    goto :end > "%timestamp%"

+:end

diff --git a/jni/ruby/win32/makedirs.bat b/jni/ruby/win32/makedirs.bat
new file mode 100755
index 0000000..13740d8
--- /dev/null
+++ b/jni/ruby/win32/makedirs.bat
@@ -0,0 +1,3 @@
+@echo off

+setlocal EnableExtensions

+for %%I in (%*) do if not exist "%%~I/." mkdir "%%~I"

diff --git a/jni/ruby/win32/mkexports.rb b/jni/ruby/win32/mkexports.rb
new file mode 100755
index 0000000..ab29fc1
--- /dev/null
+++ b/jni/ruby/win32/mkexports.rb
@@ -0,0 +1,172 @@
+#!./miniruby -sI.
+
+$name = $library = $description = nil
+
+module RbConfig
+  autoload :CONFIG, "./rbconfig"
+end
+
+class Exports
+  @@subclass = []
+  def self.inherited(klass)
+    @@subclass << [/#{klass.name.sub(/.*::/, '').downcase}/i, klass]
+  end
+
+  def self.create(*args, &block)
+    platform = RUBY_PLATFORM
+    pat, klass = @@subclass.find {|p, k| p =~ platform}
+    unless klass
+      raise ArgumentError, "unsupported platform: #{platform}"
+    end
+    klass.new(*args, &block)
+  end
+
+  def self.extract(objs, *rest)
+    create(objs).exports(*rest)
+  end
+
+  def self.output(output = $output, &block)
+    if output
+      open(output, 'wb', &block)
+    else
+      yield STDOUT
+    end
+  end
+
+  def initialize(objs)
+    syms = {}
+    winapis = {}
+    syms["ruby_sysinit_real"] = "ruby_sysinit"
+    each_export(objs) do |internal, export|
+      syms[internal] = export
+      winapis[$1] = internal if /^_?(rb_w32_\w+)(?:@\d+)?$/ =~ internal
+    end
+    incdir = File.join(File.dirname(File.dirname(__FILE__)), "include/ruby")
+    read_substitution(incdir+"/win32.h", syms, winapis)
+    read_substitution(incdir+"/subst.h", syms, winapis)
+    syms["rb_w32_vsnprintf"] ||= "ruby_vsnprintf"
+    syms["rb_w32_snprintf"] ||= "ruby_snprintf"
+    @syms = syms
+  end
+
+  def read_substitution(header, syms, winapis)
+    IO.foreach(header) do |line|
+      if /^#define (\w+)\((.*?)\)\s+(?:\(void\))?(rb_w32_\w+)\((.*?)\)\s*$/ =~ line and
+          $2.delete(" ") == $4.delete(" ")
+        export, internal = $1, $3
+        if syms[internal] or internal = winapis[internal]
+          syms[forwarding(internal, export)] = internal
+        end
+      end
+    end
+  end
+
+  def exports(name = $name, library = $library, description = $description)
+    exports = []
+    if name
+      exports << "Name " + name
+    elsif library
+      exports << "Library " + library
+    end
+    exports << "Description " + description.dump if description
+    exports << "VERSION #{RbConfig::CONFIG['MAJOR']}.#{RbConfig::CONFIG['MINOR']}"
+    exports << "EXPORTS" << symbols()
+    exports
+  end
+
+  private
+  def forwarding(internal, export)
+    internal.sub(/^[^@]+/, "\\1#{export}")
+  end
+
+  def each_export(objs)
+  end
+
+  def objdump(objs, &block)
+    if objs.empty?
+      $stdin.each_line(&block)
+    else
+      each_line(objs, &block)
+    end
+  end
+
+  def symbols()
+    @syms.sort.collect {|k, v| v ? v == true ? "#{k} DATA" : "#{k}=#{v}" : k}
+  end
+end
+
+class Exports::Mswin < Exports
+  def each_line(objs, &block)
+    IO.popen(%w"dumpbin -symbols -exports" + objs) do |f|
+      f.each(&block)
+    end
+  end
+
+  def each_export(objs)
+    noprefix = ($arch ||= nil and /^(sh|i\d86)/ !~ $arch)
+    objs = objs.collect {|s| s.tr('/', '\\')}
+    filetype = nil
+    objdump(objs) do |l|
+      if (filetype = l[/^File Type: (.+)/, 1])..(/^\f/ =~ l)
+        case filetype
+        when /OBJECT/, /LIBRARY/
+          next if /^[[:xdigit:]]+ 0+ UNDEF / =~ l
+          next unless /External/ =~ l
+          next unless l.sub!(/.*?\s(\(\)\s+)?External\s+\|\s+/, '')
+          is_data = !$1
+          if noprefix or /^[@_]/ =~ l
+            next if /(?!^)@.*@/ =~ l || /@[[:xdigit:]]{8,32}$/ =~ l ||
+              /^_?(?:Init_|.*_threadptr_|DllMain\b)/ =~ l
+            l.sub!(/^[@_]/, '') if /@\d+$/ !~ l
+          elsif !l.sub!(/^(\S+) \([^@?\`\']*\)$/, '\1')
+            next
+          end
+        when /DLL/
+          next unless l.sub!(/^\s*\d+\s+[[:xdigit:]]+\s+[[:xdigit:]]+\s+/, '')
+        else
+          next
+        end
+        yield l.strip, is_data
+      end
+    end
+    yield "strcasecmp", "msvcrt.stricmp"
+    yield "strncasecmp", "msvcrt.strnicmp"
+  end
+end
+
+class Exports::Cygwin < Exports
+  def self.nm
+    @@nm ||= RbConfig::CONFIG["NM"]
+  end
+
+  def exports(*)
+    super()
+  end
+
+  def each_line(objs, &block)
+    IO.foreach("|#{self.class.nm} --extern --defined #{objs.join(' ')}", &block)
+  end
+
+  def each_export(objs)
+    symprefix = RbConfig::CONFIG["SYMBOL_PREFIX"]
+    symprefix.strip! if symprefix
+    re = /\s(?:(T)|[[:upper:]])\s#{symprefix}((?!Init_|.*_threadptr_|DllMain\b).*)$/
+    objdump(objs) do |l|
+      next if /@.*@/ =~ l
+      yield $2, !$1 if re =~ l
+    end
+  end
+end
+
+class Exports::Mingw < Exports::Cygwin
+  def each_export(objs)
+    super
+    yield "strcasecmp", "_stricmp"
+    yield "strncasecmp", "_strnicmp"
+  end
+end
+
+END {
+  exports = Exports.extract(ARGV)
+  Exports.output {|f| f.puts(*exports)}
+}
diff --git a/jni/ruby/win32/resource.rb b/jni/ruby/win32/resource.rb
new file mode 100755
index 0000000..786edb0
--- /dev/null
+++ b/jni/ruby/win32/resource.rb
@@ -0,0 +1,97 @@
+#!./miniruby -sI.
+
+require './rbconfig'
+
+CONFIG = RbConfig::MAKEFILE_CONFIG
+
+version = RUBY_VERSION.split(/\./)
+patch = CONFIG['PATCHLEVEL']
+nversion = (version + [patch.to_i < 0 ? '0' : patch]).join(',')
+sversion = version.join('.') + (patch.to_i < 0 ? 'dev' : "p#{patch}")
+
+$ruby_name ||= CONFIG["RUBY_INSTALL_NAME"]
+$rubyw_name ||= CONFIG["RUBYW_INSTALL_NAME"] || $ruby_name.sub(/ruby/, '\&w')
+$so_name ||= CONFIG["RUBY_SO_NAME"]
+
+icons = {}
+def icons.find(path)
+  if File.directory?(path)
+    Dir.open(File.expand_path(path)) do |d|
+      d.grep(/\.ico$/i) {|i| self[$`] = i}
+    end
+  else
+    self[File.basename(path, '.ico')] = path
+  end
+  self
+end
+
+if ARGV.empty?
+  icons.find('.')
+else
+  ARGV.each {|i| icons.find(i)}
+end
+
+ruby_icon = rubyw_icon = nil
+[$ruby_name, 'ruby'].find do |i|
+  if i = icons[i]
+    ruby_icon = "1 ICON DISCARDABLE "+i.dump+"\n"
+  end
+end
+[$rubyw_name, 'rubyw'].find do |i|
+  if i = icons[i]
+    rubyw_icon = "1 ICON DISCARDABLE "+i.dump+"\n"
+  end
+end
+dll_icons = []
+icons.keys.sort.each do |i|
+  dll_icons << "#{dll_icons.size + 1} ICON DISCARDABLE "+icons[i].dump+"\n"
+end
+
+[ # base name    extension         file type  desc, icons
+  [$ruby_name,   CONFIG["EXEEXT"], 'VFT_APP', 'CUI', ruby_icon],
+  [$rubyw_name,  CONFIG["EXEEXT"], 'VFT_APP', 'GUI', rubyw_icon || ruby_icon],
+  [$so_name,     '.dll',           'VFT_DLL', 'DLL', dll_icons.join],
+].each do |base, ext, type, desc, icon|
+  open(base + '.rc', "w") { |f|
+    f.binmode if /mingw/ =~ RUBY_PLATFORM
+
+    f.print <<EOF
+#ifndef __BORLANDC__
+#include <windows.h>
+#include <winver.h>
+#endif
+
+#{icon || ''}
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION    #{nversion}
+ PRODUCTVERSION #{nversion}
+ FILEFLAGSMASK  0x3fL
+ FILEFLAGS      0x0L
+ FILEOS         VOS__WINDOWS32
+ FILETYPE       #{type}
+ FILESUBTYPE    VFT2_UNKNOWN
+BEGIN
+ BLOCK "StringFileInfo"
+ BEGIN
+  BLOCK "000004b0"
+  BEGIN
+   VALUE "Comments",         "#{RUBY_RELEASE_DATE}\\0"
+   VALUE "CompanyName",      "http://www.ruby-lang.org/\\0"
+   VALUE "FileDescription",  "Ruby interpreter (#{desc}) #{sversion} [#{RUBY_PLATFORM}]\\0"
+   VALUE "FileVersion",      "#{sversion}\\0"
+   VALUE "InternalName",     "#{base + ext}\\0"
+   VALUE "LegalCopyright",   "Copyright (C) 1993-#{RUBY_RELEASE_DATE[/\d+/]} Yukihiro Matsumoto\\0"
+   VALUE "OriginalFilename", "#{base + ext}\\0"
+   VALUE "ProductName",      "Ruby interpreter #{sversion} [#{RUBY_PLATFORM}]\\0"
+   VALUE "ProductVersion",   "#{sversion}\\0"
+  END
+ END
+ BLOCK "VarFileInfo"
+ BEGIN
+  VALUE "Translation", 0x0, 0x4b0
+ END
+END
+EOF
+  }
+end
+
diff --git a/jni/ruby/win32/rm.bat b/jni/ruby/win32/rm.bat
new file mode 100755
index 0000000..9496441
--- /dev/null
+++ b/jni/ruby/win32/rm.bat
@@ -0,0 +1,18 @@
+@echo off

+:optloop

+if "%1" == "-f" shift

+if "%1" == "-r" (shift & set recursive=1 & goto :optloop)

+if "%recursive%" == "1" goto :recursive

+:begin

+if "%1" == "" goto :end

+set p=%1

+if exist "%p:/=\%" for %%I in ("%p:/=\%") do @del "%%I"

+shift

+goto :begin

+:recursive

+if "%1" == "" goto :end

+set p=%1

+if exist "%p:/=\%" rd /s /q "%p:/=\%"

+shift

+goto :recursive

+:end

diff --git a/jni/ruby/win32/rmdirs.bat b/jni/ruby/win32/rmdirs.bat
new file mode 100755
index 0000000..829e93d
--- /dev/null
+++ b/jni/ruby/win32/rmdirs.bat
@@ -0,0 +1,29 @@
+::-*- batch -*-

+@echo off

+if "%1" == "-p" shift

+:begin

+if "%1" == "" goto :end

+    set dir=%1

+    shift

+    set dir=%dir:/=\%

+    :rmdirs

+        if not exist "%dir%\." goto :begin

+        if "%dir%" == "." goto :begin

+        if "%dir%" == ".." goto :begin

+        rd "%dir%" 2> nul || goto :begin

+        :trim_sep

+            if not /%dir:~-1%/ == /\/ goto :trim_base

+            set dir=%dir:~0,-1%

+        if not "%dir%" == "" goto :trim_sep

+        :trim_base

+            if /%dir:~-1%/ == /\/ goto :parent

+            set dir=%dir:~0,-1%

+        if not "%dir%" == "" goto :trim_base

+        :parent

+        set dir=%dir:~0,-1%

+        if "%dir%" == "" goto :begin

+        if "%dir:~-1%" == ":" goto :begin

+    goto :rmdirs

+shift

+goto :begin

+:end

diff --git a/jni/ruby/win32/rtname.cmd b/jni/ruby/win32/rtname.cmd
new file mode 100644
index 0000000..1f410a0
--- /dev/null
+++ b/jni/ruby/win32/rtname.cmd
@@ -0,0 +1,18 @@
+@echo off
+set rt=
+set rtver=
+set osver=
+for /f "usebackq" %%I in (`dumpbin -dependents %1 ^| findstr -r -i "\<msvcr.*\.dll$"`) do set rt=%%~nI
+if "%rt%" == "" (
+    (echo %0: %1 is not linked to msvcrt) 1>&2
+    exit 1
+)
+for %%i in (a b c d e f g h i j k l m n o p q r s t u v w x y z) do @call set rt=%%rt:%%i=%%i%%
+if "%rt%" == "msvcrt" (
+    call set rtver=60
+) else (
+    call set rtver=%%rt:msvcr=%%
+    call set rt=msvcr%%rtver%%
+    call set osver=_%%rtver%%
+)
+for %%I in ("PLATFORM = $(TARGET_OS)%osver%" "RT = %rt%" "RT_VER = %rtver%") do @echo %%~I
diff --git a/jni/ruby/win32/setup.mak b/jni/ruby/win32/setup.mak
new file mode 100644
index 0000000..f00418e
--- /dev/null
+++ b/jni/ruby/win32/setup.mak
@@ -0,0 +1,213 @@
+# -*- makefile -*-
+
+!if "$(srcdir)" != ""
+WIN32DIR = $(srcdir)/win32
+!elseif "$(WIN32DIR)" == "win32"
+srcdir = .
+!elseif "$(WIN32DIR)" == "$(WIN32DIR:/win32=)/win32"
+srcdir = $(WIN32DIR:/win32=)
+!else
+srcdir = $(WIN32DIR)/..
+!endif
+!ifndef prefix
+prefix = /usr
+!endif
+BANG = !
+APPEND = echo.>>$(MAKEFILE)
+!ifdef MAKEFILE
+MAKE = $(MAKE) -f $(MAKEFILE)
+!else
+MAKEFILE = Makefile
+!endif
+CPU = PROCESSOR_LEVEL
+CC = cl -nologo
+CPP = $(CC) -EP
+
+all: -prologue- -generic- -epilogue-
+i386-mswin32: -prologue32- -i386- -epilogue-
+i486-mswin32: -prologue32- -i486- -epilogue-
+i586-mswin32: -prologue32- -i586- -epilogue-
+i686-mswin32: -prologue32- -i686- -epilogue-
+alpha-mswin32: -prologue32- -alpha- -epilogue-
+x64-mswin64: -prologue64- -x64- -epilogue-
+ia64-mswin64: -prologue64- -ia64- -epilogue-
+
+-prologue-: -basic-vars- -system-vars- -version- -program-name-
+
+-prologue32-: -basic-vars- -system-vars32- -version- -program-name-
+
+-prologue64-: -basic-vars- -system-vars64- -version- -program-name-
+
+-basic-vars-: nul
+	@type << > $(MAKEFILE)
+### Makefile for ruby $(TARGET_OS) ###
+MAKE = nmake
+srcdir = $(srcdir:\=/)
+prefix = $(prefix:\=/)
+EXTSTATIC = $(EXTSTATIC)
+!if defined(RDOCTARGET)
+RDOCTARGET = $(RDOCTARGET)
+!endif
+!if defined(EXTOUT)
+EXTOUT = $(EXTOUT)
+!endif
+!if defined(BASERUBY)
+BASERUBY = $(BASERUBY:/=\)
+!endif
+!if defined(NTVER)
+NTVER = $(NTVER)
+!endif
+!if defined(USE_RUBYGEMS)
+USE_RUBYGEMS = $(USE_RUBYGEMS)
+!endif
+
+<<
+!if !defined(BASERUBY)
+	@for %I in (ruby.exe) do @echo BASERUBY = %~s$$PATH:I>> $(MAKEFILE)
+	@echo !if "$$(BASERUBY)" == "">> $(MAKEFILE)
+	@echo BASERUBY = echo executable host ruby is required.  use --with-baseruby option.^& exit 1 >> $(MAKEFILE)
+	@echo HAVE_BASERUBY = no>> $(MAKEFILE)
+	@echo !else>> $(MAKEFILE)
+	@echo HAVE_BASERUBY = yes>> $(MAKEFILE)
+	@echo !endif>> $(MAKEFILE)
+!elseif [$(BASERUBY) -eexit 2> nul] == 0
+	@echo HAVE_BASERUBY = yes>> $(MAKEFILE)
+!else
+	@echo HAVE_BASERUBY = no>> $(MAKEFILE)
+!endif
+
+-system-vars-: -osname- -runtime- -headers-
+
+-system-vars32-: -osname32- -runtime- -headers-
+
+-system-vars64-: -osname64- -runtime- -headers-
+
+-osname32-: nul
+	@echo TARGET_OS = mswin32>>$(MAKEFILE)
+
+-osname64-: nul
+	@echo TARGET_OS = mswin64>>$(MAKEFILE)
+
+-osname-: nul
+	@echo !ifndef TARGET_OS>>$(MAKEFILE)
+	@($(CC) -c <<conftest.c > nul && (echo TARGET_OS = mswin32) || (echo TARGET_OS = mswin64)) >>$(MAKEFILE)
+#ifdef _WIN64
+#error
+#endif
+<<
+	@echo !endif>>$(MAKEFILE)
+	@$(WIN32DIR:/=\)\rm.bat conftest.*
+
+-runtime-: nul
+	@$(CC) -MD <<conftest.c user32.lib -link > nul
+#include <stdio.h>
+int main(void) {FILE *volatile f = stdin; return 0;}
+<<
+	@$(WIN32DIR:/=\)\rtname conftest.exe >>$(MAKEFILE)
+	@$(WIN32DIR:/=\)\rm.bat conftest.*
+
+-headers-: nul
+
+check-psapi.h: nul
+	($(CC) -MD <<conftest.c psapi.lib -link && echo>>$(MAKEFILE) HAVE_PSAPI_H=1) & $(WIN32DIR:/=\)\rm.bat conftest.*
+#include <windows.h>
+#include <psapi.h>
+int main(void) {return (EnumProcesses(NULL,0,NULL) ? 0 : 1);}
+<<
+
+-version-: nul verconf.mk
+	@$(APPEND)
+	@$(CPP) -I$(srcdir) -I$(srcdir)/include <<"Creating $(MAKEFILE)" | findstr "=" >>$(MAKEFILE)
+#define RUBY_REVISION 0
+#include "version.h"
+MAJOR = RUBY_API_VERSION_MAJOR
+MINOR = RUBY_API_VERSION_MINOR
+TEENY = RUBY_API_VERSION_TEENY
+RUBY_PROGRAM_VERSION = RUBY_VERSION
+MSC_VER = _MSC_VER
+<<
+
+verconf.mk: nul
+	@echo RUBY_RELEASE_DATE \>$(@)
+	@$(CPP) -I$(srcdir) -I$(srcdir)/include <<"Creating $(@)" | findstr "=" >>$(@)
+#define RUBY_REVISION 0
+#include "version.h"
+ = RUBY_RELEASE_DATE
+<<
+
+-program-name-:
+	@type << >>$(MAKEFILE)
+!ifdef PROGRAM_PREFIX
+PROGRAM_PREFIX = $(PROGRAM_PREFIX)
+!endif
+!ifdef PROGRAM_SUFFIX
+PROGRAM_SUFFIX = $(PROGRAM_SUFFIX)
+!endif
+!ifdef RUBY_INSTALL_NAME
+RUBY_INSTALL_NAME = $(RUBY_INSTALL_NAME)
+!endif
+!ifdef RUBY_SO_NAME
+RUBY_SO_NAME = $(RUBY_SO_NAME)
+!endif
+<<
+
+-generic-: nul
+	@$(CPP) <<conftest.c 2>nul | findstr = >>$(MAKEFILE)
+#if defined _M_X64
+MACHINE = x64
+#elif defined _M_IA64
+MACHINE = ia64
+#else
+MACHINE = x86
+#endif
+<<
+!if defined($(CPU))
+	@echo>>$(MAKEFILE) $(CPU) = $(PROCESSOR_LEVEL)
+!endif
+	@$(APPEND)
+
+-alpha-: nul
+	@echo MACHINE = alpha>>$(MAKEFILE)
+-x64-: nul
+	@echo MACHINE = x64>>$(MAKEFILE)
+-ia64-: nul
+	@echo MACHINE = ia64>>$(MAKEFILE)
+-ix86-: nul
+	@echo MACHINE = x86>>$(MAKEFILE)
+
+-i386-: -ix86-
+	@echo $(CPU) = 3>>$(MAKEFILE)
+-i486-: -ix86-
+	@echo $(CPU) = 4>>$(MAKEFILE)
+-i586-: -ix86-
+	@echo $(CPU) = 5>>$(MAKEFILE)
+-i686-: -ix86-
+	@echo $(CPU) = 6>>$(MAKEFILE)
+
+-epilogue-: -encs-
+
+-encs-: nul
+	@$(MAKE) -l -f $(srcdir)/win32/enc-setup.mak srcdir="$(srcdir)" MAKEFILE=$(MAKEFILE)
+
+-epilogue-: nul
+!if exist(confargs.c)
+	@$(APPEND)
+	@$(CPP) confargs.c 2>&1 | findstr "! =" >> $(MAKEFILE)
+	@del confargs.c
+!endif
+	@type << >>$(MAKEFILE)
+
+# RUBY_INSTALL_NAME = ruby
+# RUBY_SO_NAME = $$(RT)-$$(RUBY_INSTALL_NAME)$$(MAJOR)$$(MINOR)
+# CFLAGS = -nologo -MD $$(DEBUGFLAGS) $$(OPTFLAGS) $$(PROCESSOR_FLAG)
+# CPPFLAGS = -I. -I$$(srcdir) -I$$(srcdir)/missing -DLIBRUBY_SO=\"$$(LIBRUBY_SO)\"
+# STACK = 0x2000000
+# LDFLAGS = $$(CFLAGS) -Fm
+# XLDFLAGS =
+# RFLAGS = -r
+# EXTLIBS =
+
+$(BANG)include $$(srcdir)/win32/Makefile.sub
+<<
+	@$(COMSPEC) /C $(srcdir:/=\)\win32\rm.bat config.h config.status
+	@echo "type `nmake' to make ruby."
diff --git a/jni/ruby/win32/stub.c b/jni/ruby/win32/stub.c
new file mode 100644
index 0000000..fc82d73
--- /dev/null
+++ b/jni/ruby/win32/stub.c
@@ -0,0 +1,42 @@
+#include <ruby.h>
+static void stub_sysinit(int *argc, char ***argv);
+#define ruby_sysinit stub_sysinit
+#include <main.c>
+#undef ruby_sysinit
+
+void
+stub_sysinit(int *argc, char ***argv)
+{
+    char exename[4096];
+    size_t lenexe, len0, lenall;
+    int i, ac;
+    char **av, *p;
+
+    lenexe = (size_t)GetModuleFileName(NULL, exename, sizeof exename);
+    ruby_sysinit(argc, argv);
+    ac = *argc;
+    av = *argv;
+    len0 = strlen(av[0]) + 1;
+    lenall = 0;
+    for (i = 1; i < ac; ++i) {
+	lenall += strlen(av[i]) + 1;
+    }
+    *argv = av = realloc(av, lenall + (lenexe + 1) * 2 + sizeof(char *) * (i + 2));
+    *argc = ++ac;
+    p = (char *)(av + i + 2);
+    memmove(p + (lenexe + 1) * 2, (char *)(av + ac) + len0, lenall);
+    memcpy(p, exename, lenexe);
+    p[lenexe] = '\0';
+    *av++ = p;
+    p += lenexe + 1;
+    memcpy(p, exename, lenexe);
+    p[lenexe] = '\0';
+    *av++ = p;
+    p += lenexe + 1;
+    while (--i) {
+	*av++ = p;
+	p += strlen(p) + 1;
+    }
+    *av = NULL;
+}
+
diff --git a/jni/ruby/win32/win32.c b/jni/ruby/win32/win32.c
new file mode 100644
index 0000000..eb1818a
--- /dev/null
+++ b/jni/ruby/win32/win32.c
@@ -0,0 +1,7274 @@
+/*
+ *  Copyright (c) 1993, Intergraph Corporation
+ *
+ *  You may distribute under the terms of either the GNU General Public
+ *  License or the Artistic License, as specified in the perl README file.
+ *
+ *  Various Unix compatibility functions and NT specific functions.
+ *
+ *  Some of this code was derived from the MSDOS port(s) and the OS/2 port.
+ *
+ */
+/*
+  The parts licensed under above copyright notice are marked as "Artistic or
+  GPL".
+  Another parts are licensed under Ruby's License.
+
+  Copyright (C) 1993-2011 Yukihiro Matsumoto
+  Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
+  Copyright (C) 2000  Information-technology Promotion Agency, Japan
+ */
+
+#undef __STRICT_ANSI__
+
+#include "ruby/ruby.h"
+#include "ruby/encoding.h"
+#include <fcntl.h>
+#include <process.h>
+#include <sys/stat.h>
+/* #include <sys/wait.h> */
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include <windows.h>
+#include <winbase.h>
+#include <wincon.h>
+#include <share.h>
+#include <shlobj.h>
+#include <mbstring.h>
+#include <shlwapi.h>
+#if _MSC_VER >= 1400
+#include <crtdbg.h>
+#include <rtcapi.h>
+#endif
+#ifdef __MINGW32__
+#include <mswsock.h>
+#endif
+#include "ruby/win32.h"
+#include "win32/dir.h"
+#include "internal.h"
+#define isdirsep(x) ((x) == '/' || (x) == '\\')
+
+#if defined _MSC_VER && _MSC_VER <= 1200
+# define CharNextExA(cp, p, flags) CharNextExA((WORD)(cp), (p), (flags))
+#endif
+
+static int w32_stati64(const char *path, struct stati64 *st, UINT cp);
+static char *w32_getenv(const char *name, UINT cp);
+
+#undef getenv
+#define DLN_FIND_EXTRA_ARG_DECL ,UINT cp
+#define DLN_FIND_EXTRA_ARG ,cp
+#define rb_w32_stati64(path, st) w32_stati64(path, st, cp)
+#define getenv(name) w32_getenv(name, cp)
+#undef CharNext
+#define CharNext(p) CharNextExA(cp, (p), 0)
+#define dln_find_exe_r rb_w32_udln_find_exe_r
+#define dln_find_file_r rb_w32_udln_find_file_r
+#include "dln.h"
+#include "dln_find.c"
+#undef MAXPATHLEN
+#undef rb_w32_stati64
+#undef dln_find_exe_r
+#undef dln_find_file_r
+#define dln_find_exe_r(fname, path, buf, size) rb_w32_udln_find_exe_r(fname, path, buf, size, cp)
+#define dln_find_file_r(fname, path, buf, size) rb_w32_udln_find_file_r(fname, path, buf, size, cp)
+#undef CharNext			/* no default cp version */
+
+#undef stat
+#undef fclose
+#undef close
+#undef setsockopt
+#undef dup2
+
+#if defined __BORLANDC__
+#  define _filbuf _fgetc
+#  define _flsbuf _fputc
+#  define enough_to_get(n) (--(n) >= 0)
+#  define enough_to_put(n) (++(n) < 0)
+#else
+#  define enough_to_get(n) (--(n) >= 0)
+#  define enough_to_put(n) (--(n) >= 0)
+#endif
+
+#ifdef WIN32_DEBUG
+#define Debug(something) something
+#else
+#define Debug(something) /* nothing */
+#endif
+
+#define TO_SOCKET(x)	_get_osfhandle(x)
+
+static struct ChildRecord *CreateChild(const WCHAR *, const WCHAR *, SECURITY_ATTRIBUTES *, HANDLE, HANDLE, HANDLE, DWORD);
+static int has_redirection(const char *, UINT);
+int rb_w32_wait_events(HANDLE *events, int num, DWORD timeout);
+static int rb_w32_open_osfhandle(intptr_t osfhandle, int flags);
+static int wstati64(const WCHAR *path, struct stati64 *st);
+VALUE rb_w32_conv_from_wchar(const WCHAR *wstr, rb_encoding *enc);
+int ruby_brace_glob_with_enc(const char *str, int flags, ruby_glob_func *func, VALUE arg, rb_encoding *enc);
+
+#define RUBY_CRITICAL(expr) do { expr; } while (0)
+
+/* errno mapping */
+static struct {
+    DWORD winerr;
+    int err;
+} errmap[] = {
+    {	ERROR_INVALID_FUNCTION,		EINVAL		},
+    {	ERROR_FILE_NOT_FOUND,		ENOENT		},
+    {	ERROR_PATH_NOT_FOUND,		ENOENT		},
+    {	ERROR_TOO_MANY_OPEN_FILES,	EMFILE		},
+    {	ERROR_ACCESS_DENIED,		EACCES		},
+    {	ERROR_INVALID_HANDLE,		EBADF		},
+    {	ERROR_ARENA_TRASHED,		ENOMEM		},
+    {	ERROR_NOT_ENOUGH_MEMORY,	ENOMEM		},
+    {	ERROR_INVALID_BLOCK,		ENOMEM		},
+    {	ERROR_BAD_ENVIRONMENT,		E2BIG		},
+    {	ERROR_BAD_FORMAT,		ENOEXEC		},
+    {	ERROR_INVALID_ACCESS,		EINVAL		},
+    {	ERROR_INVALID_DATA,		EINVAL		},
+    {	ERROR_INVALID_DRIVE,		ENOENT		},
+    {	ERROR_CURRENT_DIRECTORY,	EACCES		},
+    {	ERROR_NOT_SAME_DEVICE,		EXDEV		},
+    {	ERROR_NO_MORE_FILES,		ENOENT		},
+    {	ERROR_WRITE_PROTECT,		EROFS		},
+    {	ERROR_BAD_UNIT,			ENODEV		},
+    {	ERROR_NOT_READY,		ENXIO		},
+    {	ERROR_BAD_COMMAND,		EACCES		},
+    {	ERROR_CRC,			EACCES		},
+    {	ERROR_BAD_LENGTH,		EACCES		},
+    {	ERROR_SEEK,			EIO		},
+    {	ERROR_NOT_DOS_DISK,		EACCES		},
+    {	ERROR_SECTOR_NOT_FOUND,		EACCES		},
+    {	ERROR_OUT_OF_PAPER,		EACCES		},
+    {	ERROR_WRITE_FAULT,		EIO		},
+    {	ERROR_READ_FAULT,		EIO		},
+    {	ERROR_GEN_FAILURE,		EACCES		},
+    {	ERROR_LOCK_VIOLATION,		EACCES		},
+    {	ERROR_SHARING_VIOLATION,	EACCES		},
+    {	ERROR_WRONG_DISK,		EACCES		},
+    {	ERROR_SHARING_BUFFER_EXCEEDED,	EACCES		},
+    {	ERROR_BAD_NETPATH,		ENOENT		},
+    {	ERROR_NETWORK_ACCESS_DENIED,	EACCES		},
+    {	ERROR_BAD_NET_NAME,		ENOENT		},
+    {	ERROR_FILE_EXISTS,		EEXIST		},
+    {	ERROR_CANNOT_MAKE,		EACCES		},
+    {	ERROR_FAIL_I24,			EACCES		},
+    {	ERROR_INVALID_PARAMETER,	EINVAL		},
+    {	ERROR_NO_PROC_SLOTS,		EAGAIN		},
+    {	ERROR_DRIVE_LOCKED,		EACCES		},
+    {	ERROR_BROKEN_PIPE,		EPIPE		},
+    {	ERROR_DISK_FULL,		ENOSPC		},
+    {	ERROR_INVALID_TARGET_HANDLE,	EBADF		},
+    {	ERROR_INVALID_HANDLE,		EINVAL		},
+    {	ERROR_WAIT_NO_CHILDREN,		ECHILD		},
+    {	ERROR_CHILD_NOT_COMPLETE,	ECHILD		},
+    {	ERROR_DIRECT_ACCESS_HANDLE,	EBADF		},
+    {	ERROR_NEGATIVE_SEEK,		EINVAL		},
+    {	ERROR_SEEK_ON_DEVICE,		EACCES		},
+    {	ERROR_DIR_NOT_EMPTY,		ENOTEMPTY	},
+    {	ERROR_DIRECTORY,		ENOTDIR		},
+    {	ERROR_NOT_LOCKED,		EACCES		},
+    {	ERROR_BAD_PATHNAME,		ENOENT		},
+    {	ERROR_MAX_THRDS_REACHED,	EAGAIN		},
+    {	ERROR_LOCK_FAILED,		EACCES		},
+    {	ERROR_ALREADY_EXISTS,		EEXIST		},
+    {	ERROR_INVALID_STARTING_CODESEG,	ENOEXEC		},
+    {	ERROR_INVALID_STACKSEG,		ENOEXEC		},
+    {	ERROR_INVALID_MODULETYPE,	ENOEXEC		},
+    {	ERROR_INVALID_EXE_SIGNATURE,	ENOEXEC		},
+    {	ERROR_EXE_MARKED_INVALID,	ENOEXEC		},
+    {	ERROR_BAD_EXE_FORMAT,		ENOEXEC		},
+    {	ERROR_ITERATED_DATA_EXCEEDS_64k,ENOEXEC		},
+    {	ERROR_INVALID_MINALLOCSIZE,	ENOEXEC		},
+    {	ERROR_DYNLINK_FROM_INVALID_RING,ENOEXEC		},
+    {	ERROR_IOPL_NOT_ENABLED,		ENOEXEC		},
+    {	ERROR_INVALID_SEGDPL,		ENOEXEC		},
+    {	ERROR_AUTODATASEG_EXCEEDS_64k,	ENOEXEC		},
+    {	ERROR_RING2SEG_MUST_BE_MOVABLE,	ENOEXEC		},
+    {	ERROR_RELOC_CHAIN_XEEDS_SEGLIM,	ENOEXEC		},
+    {	ERROR_INFLOOP_IN_RELOC_CHAIN,	ENOEXEC		},
+    {	ERROR_FILENAME_EXCED_RANGE,	ENOENT		},
+    {	ERROR_NESTING_NOT_ALLOWED,	EAGAIN		},
+#ifndef ERROR_PIPE_LOCAL
+#define ERROR_PIPE_LOCAL	229L
+#endif
+    {	ERROR_PIPE_LOCAL,		EPIPE		},
+    {	ERROR_BAD_PIPE,			EPIPE		},
+    {	ERROR_PIPE_BUSY,		EAGAIN		},
+    {	ERROR_NO_DATA,			EPIPE		},
+    {	ERROR_PIPE_NOT_CONNECTED,	EPIPE		},
+    {	ERROR_OPERATION_ABORTED,	EINTR		},
+    {	ERROR_NOT_ENOUGH_QUOTA,		ENOMEM		},
+    {	ERROR_MOD_NOT_FOUND,		ENOENT		},
+    {	WSAEINTR,			EINTR		},
+    {	WSAEBADF,			EBADF		},
+    {	WSAEACCES,			EACCES		},
+    {	WSAEFAULT,			EFAULT		},
+    {	WSAEINVAL,			EINVAL		},
+    {	WSAEMFILE,			EMFILE		},
+    {	WSAEWOULDBLOCK,			EWOULDBLOCK	},
+    {	WSAEINPROGRESS,			EINPROGRESS	},
+    {	WSAEALREADY,			EALREADY	},
+    {	WSAENOTSOCK,			ENOTSOCK	},
+    {	WSAEDESTADDRREQ,		EDESTADDRREQ	},
+    {	WSAEMSGSIZE,			EMSGSIZE	},
+    {	WSAEPROTOTYPE,			EPROTOTYPE	},
+    {	WSAENOPROTOOPT,			ENOPROTOOPT	},
+    {	WSAEPROTONOSUPPORT,		EPROTONOSUPPORT	},
+    {	WSAESOCKTNOSUPPORT,		ESOCKTNOSUPPORT	},
+    {	WSAEOPNOTSUPP,			EOPNOTSUPP	},
+    {	WSAEPFNOSUPPORT,		EPFNOSUPPORT	},
+    {	WSAEAFNOSUPPORT,		EAFNOSUPPORT	},
+    {	WSAEADDRINUSE,			EADDRINUSE	},
+    {	WSAEADDRNOTAVAIL,		EADDRNOTAVAIL	},
+    {	WSAENETDOWN,			ENETDOWN	},
+    {	WSAENETUNREACH,			ENETUNREACH	},
+    {	WSAENETRESET,			ENETRESET	},
+    {	WSAECONNABORTED,		ECONNABORTED	},
+    {	WSAECONNRESET,			ECONNRESET	},
+    {	WSAENOBUFS,			ENOBUFS		},
+    {	WSAEISCONN,			EISCONN		},
+    {	WSAENOTCONN,			ENOTCONN	},
+    {	WSAESHUTDOWN,			ESHUTDOWN	},
+    {	WSAETOOMANYREFS,		ETOOMANYREFS	},
+    {	WSAETIMEDOUT,			ETIMEDOUT	},
+    {	WSAECONNREFUSED,		ECONNREFUSED	},
+    {	WSAELOOP,			ELOOP		},
+    {	WSAENAMETOOLONG,		ENAMETOOLONG	},
+    {	WSAEHOSTDOWN,			EHOSTDOWN	},
+    {	WSAEHOSTUNREACH,		EHOSTUNREACH	},
+    {	WSAEPROCLIM,			EPROCLIM	},
+    {	WSAENOTEMPTY,			ENOTEMPTY	},
+    {	WSAEUSERS,			EUSERS		},
+    {	WSAEDQUOT,			EDQUOT		},
+    {	WSAESTALE,			ESTALE		},
+    {	WSAEREMOTE,			EREMOTE		},
+};
+
+/* License: Ruby's */
+int
+rb_w32_map_errno(DWORD winerr)
+{
+    int i;
+
+    if (winerr == 0) {
+	return 0;
+    }
+
+    for (i = 0; i < (int)(sizeof(errmap) / sizeof(*errmap)); i++) {
+	if (errmap[i].winerr == winerr) {
+	    return errmap[i].err;
+	}
+    }
+
+    if (winerr >= WSABASEERR) {
+	return winerr;
+    }
+    return EINVAL;
+}
+
+#define map_errno rb_w32_map_errno
+
+static const char *NTLoginName;
+
+static OSVERSIONINFO osver;
+
+/* License: Artistic or GPL */
+static void
+get_version(void)
+{
+    memset(&osver, 0, sizeof(OSVERSIONINFO));
+    osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+    GetVersionEx(&osver);
+}
+
+#ifdef _M_IX86
+/* License: Artistic or GPL */
+DWORD
+rb_w32_osid(void)
+{
+    return osver.dwPlatformId;
+}
+#endif
+
+/* License: Artistic or GPL */
+DWORD
+rb_w32_osver(void)
+{
+    return osver.dwMajorVersion;
+}
+
+/* simulate flock by locking a range on the file */
+
+/* License: Artistic or GPL */
+#define LK_ERR(f,i) \
+    do {								\
+	if (f)								\
+	    i = 0;							\
+	else {								\
+	    DWORD err = GetLastError();					\
+	    if (err == ERROR_LOCK_VIOLATION || err == ERROR_IO_PENDING)	\
+		errno = EWOULDBLOCK;					\
+	    else if (err == ERROR_NOT_LOCKED)				\
+		i = 0;							\
+	    else							\
+		errno = map_errno(err);					\
+	}								\
+    } while (0)
+#define LK_LEN      ULONG_MAX
+
+/* License: Artistic or GPL */
+static uintptr_t
+flock_winnt(uintptr_t self, int argc, uintptr_t* argv)
+{
+    OVERLAPPED o;
+    int i = -1;
+    const HANDLE fh = (HANDLE)self;
+    const int oper = argc;
+
+    memset(&o, 0, sizeof(o));
+
+    switch(oper) {
+      case LOCK_SH:		/* shared lock */
+	LK_ERR(LockFileEx(fh, 0, 0, LK_LEN, LK_LEN, &o), i);
+	break;
+      case LOCK_EX:		/* exclusive lock */
+	LK_ERR(LockFileEx(fh, LOCKFILE_EXCLUSIVE_LOCK, 0, LK_LEN, LK_LEN, &o), i);
+	break;
+      case LOCK_SH|LOCK_NB:	/* non-blocking shared lock */
+	LK_ERR(LockFileEx(fh, LOCKFILE_FAIL_IMMEDIATELY, 0, LK_LEN, LK_LEN, &o), i);
+	break;
+      case LOCK_EX|LOCK_NB:	/* non-blocking exclusive lock */
+	LK_ERR(LockFileEx(fh,
+			  LOCKFILE_EXCLUSIVE_LOCK|LOCKFILE_FAIL_IMMEDIATELY,
+			  0, LK_LEN, LK_LEN, &o), i);
+	break;
+      case LOCK_UN:		/* unlock lock */
+      case LOCK_UN|LOCK_NB:	/* unlock is always non-blocking, I hope */
+	LK_ERR(UnlockFileEx(fh, 0, LK_LEN, LK_LEN, &o), i);
+	break;
+      default:            /* unknown */
+	errno = EINVAL;
+	break;
+    }
+    return i;
+}
+
+#undef LK_ERR
+
+/* License: Artistic or GPL */
+int
+flock(int fd, int oper)
+{
+    const asynchronous_func_t locker = flock_winnt;
+
+    return rb_w32_asynchronize(locker,
+			      (VALUE)_get_osfhandle(fd), oper, NULL,
+			      (DWORD)-1);
+}
+
+/* License: Ruby's */
+static inline WCHAR *
+translate_wchar(WCHAR *p, int from, int to)
+{
+    for (; *p; p++) {
+	if (*p == from)
+	    *p = to;
+    }
+    return p;
+}
+
+/* License: Ruby's */
+static inline char *
+translate_char(char *p, int from, int to, UINT cp)
+{
+    while (*p) {
+	if ((unsigned char)*p == from)
+	    *p = to;
+	p = CharNextExA(cp, p, 0);
+    }
+    return p;
+}
+
+#ifndef CSIDL_LOCAL_APPDATA
+#define CSIDL_LOCAL_APPDATA 28
+#endif
+#ifndef CSIDL_COMMON_APPDATA
+#define CSIDL_COMMON_APPDATA 35
+#endif
+#ifndef CSIDL_WINDOWS
+#define CSIDL_WINDOWS	36
+#endif
+#ifndef CSIDL_SYSTEM
+#define CSIDL_SYSTEM	37
+#endif
+#ifndef CSIDL_PROFILE
+#define CSIDL_PROFILE 40
+#endif
+
+/* License: Ruby's */
+static BOOL
+get_special_folder(int n, WCHAR *env)
+{
+    LPITEMIDLIST pidl;
+    LPMALLOC alloc;
+    BOOL f = FALSE;
+    if (SHGetSpecialFolderLocation(NULL, n, &pidl) == 0) {
+	f = SHGetPathFromIDListW(pidl, env);
+	SHGetMalloc(&alloc);
+	alloc->lpVtbl->Free(alloc, pidl);
+	alloc->lpVtbl->Release(alloc);
+    }
+    return f;
+}
+
+/* License: Ruby's */
+static void
+regulate_path(WCHAR *path)
+{
+    WCHAR *p = translate_wchar(path, L'\\', L'/');
+    if (p - path == 2 && path[1] == L':') {
+	*p++ = L'/';
+	*p = L'\0';
+    }
+}
+
+/* License: Ruby's */
+static FARPROC
+get_proc_address(const char *module, const char *func, HANDLE *mh)
+{
+    HANDLE h;
+    FARPROC ptr;
+
+    if (mh)
+	h = LoadLibrary(module);
+    else
+	h = GetModuleHandle(module);
+    if (!h)
+	return NULL;
+
+    ptr = GetProcAddress(h, func);
+    if (mh) {
+	if (ptr)
+	    *mh = h;
+	else
+	    FreeLibrary(h);
+    }
+    return ptr;
+}
+
+/* License: Ruby's */
+static UINT
+get_system_directory(WCHAR *path, UINT len)
+{
+    typedef UINT WINAPI wgetdir_func(WCHAR*, UINT);
+    FARPROC ptr =
+	get_proc_address("kernel32", "GetSystemWindowsDirectoryW", NULL);
+    if (ptr)
+	return (*(wgetdir_func *)ptr)(path, len);
+    return GetWindowsDirectoryW(path, len);
+}
+
+/* License: Ruby's */
+VALUE
+rb_w32_special_folder(int type)
+{
+    WCHAR path[_MAX_PATH];
+
+    if (!get_special_folder(type, path)) return Qnil;
+    regulate_path(path);
+    return rb_w32_conv_from_wchar(path, rb_filesystem_encoding());
+}
+
+/* License: Ruby's */
+UINT
+rb_w32_system_tmpdir(WCHAR *path, UINT len)
+{
+    static const WCHAR temp[] = L"temp";
+    WCHAR *p;
+
+    if (!get_special_folder(CSIDL_LOCAL_APPDATA, path)) {
+	if (get_system_directory(path, len)) return 0;
+    }
+    p = translate_wchar(path, L'\\', L'/');
+    if (*(p - 1) != L'/') *p++ = L'/';
+    if ((UINT)(p - path + numberof(temp)) >= len) return 0;
+    memcpy(p, temp, sizeof(temp));
+    return (UINT)(p - path + numberof(temp) - 1);
+}
+
+/* License: Ruby's */
+static void
+init_env(void)
+{
+    static const WCHAR TMPDIR[] = L"TMPDIR";
+    struct {WCHAR name[6], eq, val[_MAX_PATH];} wk;
+    DWORD len;
+    BOOL f;
+#define env wk.val
+#define set_env_val(vname) do { \
+	typedef char wk_name_offset[(numberof(wk.name) - (numberof(vname) - 1)) * 2 + 1]; \
+	WCHAR *const buf = wk.name + sizeof(wk_name_offset) / 2; \
+	MEMCPY(buf, vname, WCHAR, numberof(vname) - 1); \
+	_wputenv(buf); \
+    } while (0)
+
+    wk.eq = L'=';
+
+    if (!GetEnvironmentVariableW(L"HOME", env, numberof(env))) {
+	f = FALSE;
+	if (GetEnvironmentVariableW(L"HOMEDRIVE", env, numberof(env)))
+	    len = lstrlenW(env);
+	else
+	    len = 0;
+	if (GetEnvironmentVariableW(L"HOMEPATH", env + len, numberof(env) - len) || len) {
+	    f = TRUE;
+	}
+	else if (GetEnvironmentVariableW(L"USERPROFILE", env, numberof(env))) {
+	    f = TRUE;
+	}
+	else if (get_special_folder(CSIDL_PROFILE, env)) {
+	    f = TRUE;
+	}
+	else if (get_special_folder(CSIDL_PERSONAL, env)) {
+	    f = TRUE;
+	}
+	if (f) {
+	    regulate_path(env);
+	    set_env_val(L"HOME");
+	}
+    }
+
+    if (!GetEnvironmentVariableW(L"USER", env, numberof(env))) {
+	if (!GetEnvironmentVariableW(L"USERNAME", env, numberof(env)) &&
+	    !GetUserNameW(env, (len = numberof(env), &len))) {
+	    NTLoginName = "<Unknown>";
+	}
+	else {
+	    set_env_val(L"USER");
+	    NTLoginName = rb_w32_wstr_to_mbstr(CP_UTF8, env, -1, NULL);
+	}
+    }
+    else {
+	NTLoginName = rb_w32_wstr_to_mbstr(CP_UTF8, env, -1, NULL);
+    }
+
+    if (!GetEnvironmentVariableW(TMPDIR, env, numberof(env)) &&
+	!GetEnvironmentVariableW(L"TMP", env, numberof(env)) &&
+	!GetEnvironmentVariableW(L"TEMP", env, numberof(env)) &&
+	rb_w32_system_tmpdir(env, numberof(env))) {
+	set_env_val(TMPDIR);
+    }
+
+#undef env
+#undef set_env_val
+}
+
+
+typedef BOOL (WINAPI *cancel_io_t)(HANDLE);
+static cancel_io_t cancel_io = NULL;
+
+/* License: Ruby's */
+static void
+init_func(void)
+{
+    if (!cancel_io)
+	cancel_io = (cancel_io_t)get_proc_address("kernel32", "CancelIo", NULL);
+}
+
+static void init_stdhandle(void);
+
+#if RUBY_MSVCRT_VERSION >= 80
+/* License: Ruby's */
+static void
+invalid_parameter(const wchar_t *expr, const wchar_t *func, const wchar_t *file, unsigned int line, uintptr_t dummy)
+{
+    // nothing to do
+}
+
+int ruby_w32_rtc_error;
+
+/* License: Ruby's */
+static int __cdecl
+rtc_error_handler(int e, const char *src, int line, const char *exe, const char *fmt, ...)
+{
+    va_list ap;
+    VALUE str;
+
+    if (!ruby_w32_rtc_error) return 0;
+    str = rb_sprintf("%s:%d: ", src, line);
+    va_start(ap, fmt);
+    rb_str_vcatf(str, fmt, ap);
+    va_end(ap);
+    rb_str_cat(str, "\n", 1);
+    rb_write_error2(RSTRING_PTR(str), RSTRING_LEN(str));
+    return 0;
+}
+#endif
+
+static CRITICAL_SECTION select_mutex;
+static int NtSocketsInitialized = 0;
+static st_table *socklist = NULL;
+static st_table *conlist = NULL;
+#define conlist_disabled ((st_table *)-1)
+static char *uenvarea;
+
+/* License: Ruby's */
+struct constat {
+    struct {
+	int state, seq[16], reverse;
+	WORD attr;
+	COORD saved;
+    } vt100;
+};
+enum {constat_init = -2, constat_esc = -1, constat_seq = 0};
+
+/* License: Ruby's */
+static int
+free_conlist(st_data_t key, st_data_t val, st_data_t arg)
+{
+    xfree((struct constat *)val);
+    return ST_DELETE;
+}
+
+/* License: Ruby's */
+static void
+constat_delete(HANDLE h)
+{
+    if (conlist && conlist != conlist_disabled) {
+	st_data_t key = (st_data_t)h, val;
+	st_delete(conlist, &key, &val);
+	xfree((struct constat *)val);
+    }
+}
+
+/* License: Ruby's */
+static void
+exit_handler(void)
+{
+    if (NtSocketsInitialized) {
+	WSACleanup();
+	if (socklist) {
+	    st_free_table(socklist);
+	    socklist = NULL;
+	}
+	DeleteCriticalSection(&select_mutex);
+	NtSocketsInitialized = 0;
+    }
+    if (conlist && conlist != conlist_disabled) {
+	st_foreach(conlist, free_conlist, 0);
+	st_free_table(conlist);
+	conlist = NULL;
+    }
+    if (uenvarea) {
+	free(uenvarea);
+	uenvarea = NULL;
+    }
+}
+
+/* License: Artistic or GPL */
+static void
+StartSockets(void)
+{
+    WORD version;
+    WSADATA retdata;
+
+    //
+    // initialize the winsock interface and insure that it's
+    // cleaned up at exit.
+    //
+    version = MAKEWORD(2, 0);
+    if (WSAStartup(version, &retdata))
+	rb_fatal ("Unable to locate winsock library!\n");
+    if (LOBYTE(retdata.wVersion) != 2)
+	rb_fatal("could not find version 2 of winsock dll\n");
+
+    InitializeCriticalSection(&select_mutex);
+
+    NtSocketsInitialized = 1;
+}
+
+#define MAKE_SOCKDATA(af, fl)	((int)((((int)af)<<4)|((fl)&0xFFFF)))
+#define GET_FAMILY(v)		((int)(((v)>>4)&0xFFFF))
+#define GET_FLAGS(v)		((int)((v)&0xFFFF))
+
+/* License: Ruby's */
+static inline int
+socklist_insert(SOCKET sock, int flag)
+{
+    if (!socklist)
+	socklist = st_init_numtable();
+    return st_insert(socklist, (st_data_t)sock, (st_data_t)flag);
+}
+
+/* License: Ruby's */
+static inline int
+socklist_lookup(SOCKET sock, int *flagp)
+{
+    st_data_t data;
+    int ret;
+
+    if (!socklist)
+	return 0;
+    ret = st_lookup(socklist, (st_data_t)sock, (st_data_t *)&data);
+    if (ret && flagp)
+	*flagp = (int)data;
+
+    return ret;
+}
+
+/* License: Ruby's */
+static inline int
+socklist_delete(SOCKET *sockp, int *flagp)
+{
+    st_data_t key;
+    st_data_t data;
+    int ret;
+
+    if (!socklist)
+	return 0;
+    key = (st_data_t)*sockp;
+    if (flagp)
+	data = (st_data_t)*flagp;
+    ret = st_delete(socklist, &key, &data);
+    if (ret) {
+	*sockp = (SOCKET)key;
+	if (flagp)
+	    *flagp = (int)data;
+    }
+
+    return ret;
+}
+
+static int w32_cmdvector(const WCHAR *, char ***, UINT, rb_encoding *);
+//
+// Initialization stuff
+//
+/* License: Ruby's */
+void
+rb_w32_sysinit(int *argc, char ***argv)
+{
+#if RUBY_MSVCRT_VERSION >= 80
+    static void set_pioinfo_extra(void);
+
+    _CrtSetReportMode(_CRT_ASSERT, 0);
+    _set_invalid_parameter_handler(invalid_parameter);
+    _RTC_SetErrorFunc(rtc_error_handler);
+    set_pioinfo_extra();
+#else
+    SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOGPFAULTERRORBOX);
+#endif
+
+    get_version();
+
+    //
+    // subvert cmd.exe's feeble attempt at command line parsing
+    //
+    *argc = w32_cmdvector(GetCommandLineW(), argv, CP_UTF8, rb_utf8_encoding());
+
+    //
+    // Now set up the correct time stuff
+    //
+
+    tzset();
+
+    init_env();
+
+    init_func();
+
+    init_stdhandle();
+
+    atexit(exit_handler);
+
+    // Initialize Winsock
+    StartSockets();
+}
+
+char *
+getlogin(void)
+{
+    return (char *)NTLoginName;
+}
+
+#define MAXCHILDNUM 256	/* max num of child processes */
+
+/* License: Ruby's */
+static struct ChildRecord {
+    HANDLE hProcess;	/* process handle */
+    rb_pid_t pid;	/* process id */
+} ChildRecord[MAXCHILDNUM];
+
+/* License: Ruby's */
+#define FOREACH_CHILD(v) do { \
+    struct ChildRecord* v; \
+    for (v = ChildRecord; v < ChildRecord + sizeof(ChildRecord) / sizeof(ChildRecord[0]); ++v)
+#define END_FOREACH_CHILD } while (0)
+
+/* License: Ruby's */
+static struct ChildRecord *
+FindChildSlot(rb_pid_t pid)
+{
+
+    FOREACH_CHILD(child) {
+	if (child->pid == pid) {
+	    return child;
+	}
+    } END_FOREACH_CHILD;
+    return NULL;
+}
+
+/* License: Ruby's */
+static struct ChildRecord *
+FindChildSlotByHandle(HANDLE h)
+{
+
+    FOREACH_CHILD(child) {
+	if (child->hProcess == h) {
+	    return child;
+	}
+    } END_FOREACH_CHILD;
+    return NULL;
+}
+
+/* License: Ruby's */
+static void
+CloseChildHandle(struct ChildRecord *child)
+{
+    HANDLE h = child->hProcess;
+    child->hProcess = NULL;
+    child->pid = 0;
+    CloseHandle(h);
+}
+
+/* License: Ruby's */
+static struct ChildRecord *
+FindFreeChildSlot(void)
+{
+    FOREACH_CHILD(child) {
+	if (!child->pid) {
+	    child->pid = -1;	/* lock the slot */
+	    child->hProcess = NULL;
+	    return child;
+	}
+    } END_FOREACH_CHILD;
+    return NULL;
+}
+
+
+/*
+  ruby -lne 'BEGIN{$cmds = Hash.new(0); $mask = 1}'
+   -e '$cmds[$_.downcase] |= $mask' -e '$mask <<= 1 if ARGF.eof'
+   -e 'END{$cmds.sort.each{|n,f|puts "    \"\\#{f.to_s(8)}\" #{n.dump} + 1,"}}'
+   98cmd ntcmd
+ */
+static const char *const szInternalCmds[] = {
+    "\2" "assoc",
+    "\3" "break",
+    "\3" "call",
+    "\3" "cd",
+    "\1" "chcp",
+    "\3" "chdir",
+    "\3" "cls",
+    "\2" "color",
+    "\3" "copy",
+    "\1" "ctty",
+    "\3" "date",
+    "\3" "del",
+    "\3" "dir",
+    "\3" "echo",
+    "\2" "endlocal",
+    "\3" "erase",
+    "\3" "exit",
+    "\3" "for",
+    "\2" "ftype",
+    "\3" "goto",
+    "\3" "if",
+    "\1" "lfnfor",
+    "\1" "lh",
+    "\1" "lock",
+    "\3" "md",
+    "\3" "mkdir",
+    "\2" "move",
+    "\3" "path",
+    "\3" "pause",
+    "\2" "popd",
+    "\3" "prompt",
+    "\2" "pushd",
+    "\3" "rd",
+    "\3" "rem",
+    "\3" "ren",
+    "\3" "rename",
+    "\3" "rmdir",
+    "\3" "set",
+    "\2" "setlocal",
+    "\3" "shift",
+    "\2" "start",
+    "\3" "time",
+    "\2" "title",
+    "\1" "truename",
+    "\3" "type",
+    "\1" "unlock",
+    "\3" "ver",
+    "\3" "verify",
+    "\3" "vol",
+};
+
+/* License: Ruby's */
+static int
+internal_match(const void *key, const void *elem)
+{
+    return strcmp(key, (*(const char *const *)elem) + 1);
+}
+
+/* License: Ruby's */
+static int
+is_command_com(const char *interp)
+{
+    int i = strlen(interp) - 11;
+
+    if ((i == 0 || (i > 0 && isdirsep(interp[i-1]))) &&
+	strcasecmp(interp+i, "command.com") == 0) {
+	return 1;
+    }
+    return 0;
+}
+
+static int internal_cmd_match(const char *cmdname, int nt);
+
+/* License: Ruby's */
+static int
+is_internal_cmd(const char *cmd, int nt)
+{
+    char cmdname[9], *b = cmdname, c;
+
+    do {
+	if (!(c = *cmd++)) return 0;
+    } while (isspace(c));
+    if (c == '@')
+	return 1;
+    while (isalpha(c)) {
+	*b++ = tolower(c);
+	if (b == cmdname + sizeof(cmdname)) return 0;
+	c = *cmd++;
+    }
+    if (c == '.') c = *cmd;
+    switch (c) {
+      case '<': case '>': case '|':
+	return 1;
+      case '\0': case ' ': case '\t': case '\n':
+	break;
+      default:
+	return 0;
+    }
+    *b = 0;
+    return internal_cmd_match(cmdname, nt);
+}
+
+/* License: Ruby's */
+static int
+internal_cmd_match(const char *cmdname, int nt)
+{
+    char **nm;
+
+    nm = bsearch(cmdname, szInternalCmds,
+		 sizeof(szInternalCmds) / sizeof(*szInternalCmds),
+		 sizeof(*szInternalCmds),
+		 internal_match);
+    if (!nm || !(nm[0][0] & (nt ? 2 : 1)))
+	return 0;
+    return 1;
+}
+
+/* License: Ruby's */
+SOCKET
+rb_w32_get_osfhandle(int fh)
+{
+    return _get_osfhandle(fh);
+}
+
+/* License: Ruby's */
+static int
+join_argv(char *cmd, char *const *argv, BOOL escape, UINT cp, int backslash)
+{
+    const char *p, *s;
+    char *q, *const *t;
+    int len, n, bs, quote;
+
+    for (t = argv, q = cmd, len = 0; (p = *t) != 0; t++) {
+	quote = 0;
+	s = p;
+	if (!*p || strpbrk(p, " \t\"'")) {
+	    quote = 1;
+	    len++;
+	    if (q) *q++ = '"';
+	}
+	for (bs = 0; *p; ++p) {
+	    switch (*p) {
+	      case '\\':
+		++bs;
+		break;
+	      case '"':
+		len += n = p - s;
+		if (q) {
+		    memcpy(q, s, n);
+		    q += n;
+		}
+		s = p;
+		len += ++bs;
+		if (q) {
+		    memset(q, '\\', bs);
+		    q += bs;
+		}
+		bs = 0;
+		break;
+	      case '<': case '>': case '|': case '^':
+		if (escape && !quote) {
+		    len += (n = p - s) + 1;
+		    if (q) {
+			memcpy(q, s, n);
+			q += n;
+			*q++ = '^';
+		    }
+		    s = p;
+		    break;
+		}
+	      default:
+		bs = 0;
+		p = CharNextExA(cp, p, 0) - 1;
+		break;
+	    }
+	}
+	len += (n = p - s) + 1;
+	if (quote) len++;
+	if (q) {
+	    memcpy(q, s, n);
+	    if (backslash > 0) {
+		--backslash;
+		q[n] = 0;
+		translate_char(q, '/', '\\', cp);
+	    }
+	    q += n;
+	    if (quote) *q++ = '"';
+	    *q++ = ' ';
+	}
+    }
+    if (q > cmd) --len;
+    if (q) {
+	if (q > cmd) --q;
+	*q = '\0';
+    }
+    return len;
+}
+
+#ifdef HAVE_SYS_PARAM_H
+# include <sys/param.h>
+#else
+# define MAXPATHLEN 512
+#endif
+
+/* License: Ruby's */
+#define STRNDUPV(ptr, v, src, len)					\
+    (((char *)memcpy(((ptr) = ALLOCV((v), (len) + 1)), (src), (len)))[len] = 0)
+
+/* License: Ruby's */
+static int
+check_spawn_mode(int mode)
+{
+    switch (mode) {
+      case P_NOWAIT:
+      case P_OVERLAY:
+	return 0;
+      default:
+	errno = EINVAL;
+	return -1;
+    }
+}
+
+/* License: Ruby's */
+static rb_pid_t
+child_result(struct ChildRecord *child, int mode)
+{
+    DWORD exitcode;
+
+    if (!child) {
+	return -1;
+    }
+
+    if (mode == P_OVERLAY) {
+	WaitForSingleObject(child->hProcess, INFINITE);
+	GetExitCodeProcess(child->hProcess, &exitcode);
+	CloseChildHandle(child);
+	_exit(exitcode);
+    }
+    return child->pid;
+}
+
+/* License: Ruby's */
+static struct ChildRecord *
+CreateChild(const WCHAR *cmd, const WCHAR *prog, SECURITY_ATTRIBUTES *psa,
+	    HANDLE hInput, HANDLE hOutput, HANDLE hError, DWORD dwCreationFlags)
+{
+    BOOL fRet;
+    STARTUPINFOW aStartupInfo;
+    PROCESS_INFORMATION aProcessInformation;
+    SECURITY_ATTRIBUTES sa;
+    struct ChildRecord *child;
+
+    if (!cmd && !prog) {
+	errno = EFAULT;
+	return NULL;
+    }
+
+    child = FindFreeChildSlot();
+    if (!child) {
+	errno = EAGAIN;
+	return NULL;
+    }
+
+    if (!psa) {
+	sa.nLength              = sizeof (SECURITY_ATTRIBUTES);
+	sa.lpSecurityDescriptor = NULL;
+	sa.bInheritHandle       = TRUE;
+	psa = &sa;
+    }
+
+    memset(&aStartupInfo, 0, sizeof(aStartupInfo));
+    memset(&aProcessInformation, 0, sizeof(aProcessInformation));
+    aStartupInfo.cb = sizeof(aStartupInfo);
+    aStartupInfo.dwFlags = STARTF_USESTDHANDLES;
+    if (hInput) {
+	aStartupInfo.hStdInput  = hInput;
+    }
+    else {
+	aStartupInfo.hStdInput  = GetStdHandle(STD_INPUT_HANDLE);
+    }
+    if (hOutput) {
+	aStartupInfo.hStdOutput = hOutput;
+    }
+    else {
+	aStartupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
+    }
+    if (hError) {
+	aStartupInfo.hStdError = hError;
+    }
+    else {
+	aStartupInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
+    }
+
+    dwCreationFlags |= NORMAL_PRIORITY_CLASS;
+
+    if (lstrlenW(cmd) > 32767) {
+	child->pid = 0;		/* release the slot */
+	errno = E2BIG;
+	return NULL;
+    }
+
+    RUBY_CRITICAL({
+	fRet = CreateProcessW(prog, (WCHAR *)cmd, psa, psa,
+			      psa->bInheritHandle, dwCreationFlags, NULL, NULL,
+			      &aStartupInfo, &aProcessInformation);
+	errno = map_errno(GetLastError());
+    });
+
+    if (!fRet) {
+	child->pid = 0;		/* release the slot */
+	return NULL;
+    }
+
+    CloseHandle(aProcessInformation.hThread);
+
+    child->hProcess = aProcessInformation.hProcess;
+    child->pid = (rb_pid_t)aProcessInformation.dwProcessId;
+
+    return child;
+}
+
+/* License: Ruby's */
+static int
+is_batch(const char *cmd)
+{
+    int len = strlen(cmd);
+    if (len <= 4) return 0;
+    cmd += len - 4;
+    if (*cmd++ != '.') return 0;
+    if (strcasecmp(cmd, "bat") == 0) return 1;
+    if (strcasecmp(cmd, "cmd") == 0) return 1;
+    return 0;
+}
+
+UINT rb_w32_filecp(void);
+#define filecp rb_w32_filecp
+#define mbstr_to_wstr rb_w32_mbstr_to_wstr
+#define wstr_to_mbstr rb_w32_wstr_to_mbstr
+#define acp_to_wstr(str, plen) mbstr_to_wstr(CP_ACP, str, -1, plen)
+#define wstr_to_acp(str, plen) wstr_to_mbstr(CP_ACP, str, -1, plen)
+#define filecp_to_wstr(str, plen) mbstr_to_wstr(filecp(), str, -1, plen)
+#define wstr_to_filecp(str, plen) wstr_to_mbstr(filecp(), str, -1, plen)
+#define utf8_to_wstr(str, plen) mbstr_to_wstr(CP_UTF8, str, -1, plen)
+#define wstr_to_utf8(str, plen) wstr_to_mbstr(CP_UTF8, str, -1, plen)
+
+/* License: Artistic or GPL */
+static rb_pid_t
+w32_spawn(int mode, const char *cmd, const char *prog, UINT cp)
+{
+    char fbuf[MAXPATHLEN];
+    char *p = NULL;
+    const char *shell = NULL;
+    WCHAR *wcmd = NULL, *wshell = NULL;
+    int e = 0;
+    rb_pid_t ret = -1;
+    VALUE v = 0;
+    VALUE v2 = 0;
+    int sep = 0;
+    char *cmd_sep = NULL;
+
+    if (check_spawn_mode(mode)) return -1;
+
+    if (prog) {
+	if (!(p = dln_find_exe_r(prog, NULL, fbuf, sizeof(fbuf)))) {
+	    shell = prog;
+	}
+	else {
+	    shell = p;
+	    translate_char(p, '/', '\\', cp);
+	}
+    }
+    else {
+	int redir = -1;
+	int nt;
+	while (ISSPACE(*cmd)) cmd++;
+	if ((shell = getenv("RUBYSHELL")) && (redir = has_redirection(cmd, cp))) {
+	    size_t shell_len = strlen(shell);
+	    char *tmp = ALLOCV(v, shell_len + strlen(cmd) + sizeof(" -c ") + 2);
+	    memcpy(tmp, shell, shell_len + 1);
+	    translate_char(tmp, '/', '\\', cp);
+	    sprintf(tmp + shell_len, " -c \"%s\"", cmd);
+	    cmd = tmp;
+	}
+	else if ((shell = getenv("COMSPEC")) &&
+		 (nt = !is_command_com(shell),
+		  (redir < 0 ? has_redirection(cmd, cp) : redir) ||
+		  is_internal_cmd(cmd, nt))) {
+	    char *tmp = ALLOCV(v, strlen(shell) + strlen(cmd) + sizeof(" /c ") + (nt ? 2 : 0));
+	    sprintf(tmp, nt ? "%s /c \"%s\"" : "%s /c %s", shell, cmd);
+	    cmd = tmp;
+	}
+	else {
+	    int len = 0, quote = (*cmd == '"') ? '"' : (*cmd == '\'') ? '\'' : 0;
+	    int slash = 0;
+	    for (prog = cmd + !!quote;; prog = CharNextExA(cp, prog, 0)) {
+		if (*prog == '/') slash = 1;
+		if (!*prog) {
+		    len = prog - cmd;
+		    if (slash) {
+			STRNDUPV(p, v2, cmd, len);
+			cmd = p;
+		    }
+		    shell = cmd;
+		    break;
+		}
+		if ((unsigned char)*prog == quote) {
+		    len = prog++ - cmd - 1;
+		    STRNDUPV(p, v2, cmd + 1, len);
+		    shell = p;
+		    break;
+		}
+		if (quote) continue;
+		if (ISSPACE(*prog) || strchr("<>|*?\"", *prog)) {
+		    len = prog - cmd;
+		    STRNDUPV(p, v2, cmd, len + (slash ? strlen(prog) : 0));
+		    if (slash) {
+			cmd = p;
+			sep = *(cmd_sep = &p[len]);
+			*cmd_sep = '\0';
+		    }
+		    shell = p;
+		    break;
+		}
+	    }
+	    shell = dln_find_exe_r(shell, NULL, fbuf, sizeof(fbuf));
+	    if (p && slash) translate_char(p, '/', '\\', cp);
+	    if (!shell) {
+		shell = p ? p : cmd;
+	    }
+	    else {
+		len = strlen(shell);
+		if (strchr(shell, ' ')) quote = -1;
+		if (shell == fbuf) {
+		    p = fbuf;
+		}
+		else if (shell != p && strchr(shell, '/')) {
+		    STRNDUPV(p, v2, shell, len);
+		    shell = p;
+		}
+		if (p) translate_char(p, '/', '\\', cp);
+		if (is_batch(shell)) {
+		    int alen = strlen(prog);
+		    cmd = p = ALLOCV(v, len + alen + (quote ? 2 : 0) + 1);
+		    if (quote) *p++ = '"';
+		    memcpy(p, shell, len);
+		    p += len;
+		    if (quote) *p++ = '"';
+		    memcpy(p, prog, alen + 1);
+		    shell = 0;
+		}
+	    }
+	}
+    }
+
+    if (!e && shell && !(wshell = mbstr_to_wstr(cp, shell, -1, NULL))) e = E2BIG;
+    if (cmd_sep) *cmd_sep = sep;
+    if (!e && cmd && !(wcmd = mbstr_to_wstr(cp, cmd, -1, NULL))) e = E2BIG;
+    if (v2) ALLOCV_END(v2);
+    if (v) ALLOCV_END(v);
+
+    if (!e) {
+	ret = child_result(CreateChild(wcmd, wshell, NULL, NULL, NULL, NULL, 0), mode);
+    }
+    free(wshell);
+    free(wcmd);
+    if (e) errno = e;
+    return ret;
+}
+
+/* License: Ruby's */
+rb_pid_t
+rb_w32_spawn(int mode, const char *cmd, const char *prog)
+{
+    /* assume ACP */
+    return w32_spawn(mode, cmd, prog, filecp());
+}
+
+/* License: Ruby's */
+rb_pid_t
+rb_w32_uspawn(int mode, const char *cmd, const char *prog)
+{
+    return w32_spawn(mode, cmd, prog, CP_UTF8);
+}
+
+/* License: Artistic or GPL */
+static rb_pid_t
+w32_aspawn_flags(int mode, const char *prog, char *const *argv, DWORD flags, UINT cp)
+{
+    int c_switch = 0;
+    size_t len;
+    BOOL ntcmd = FALSE, tmpnt;
+    const char *shell;
+    char *cmd, fbuf[MAXPATHLEN];
+    WCHAR *wcmd = NULL, *wprog = NULL;
+    int e = 0;
+    rb_pid_t ret = -1;
+    VALUE v = 0;
+
+    if (check_spawn_mode(mode)) return -1;
+
+    if (!prog) prog = argv[0];
+    if ((shell = getenv("COMSPEC")) &&
+	internal_cmd_match(prog, tmpnt = !is_command_com(shell))) {
+	ntcmd = tmpnt;
+	prog = shell;
+	c_switch = 1;
+    }
+    else if ((cmd = dln_find_exe_r(prog, NULL, fbuf, sizeof(fbuf)))) {
+	if (cmd == prog) strlcpy(cmd = fbuf, prog, sizeof(fbuf));
+	translate_char(cmd, '/', '\\', cp);
+	prog = cmd;
+    }
+    else if (strchr(prog, '/')) {
+	len = strlen(prog);
+	if (len < sizeof(fbuf))
+	    strlcpy(cmd = fbuf, prog, sizeof(fbuf));
+	else
+	    STRNDUPV(cmd, v, prog, len);
+	translate_char(cmd, '/', '\\', cp);
+	prog = cmd;
+    }
+    if (c_switch || is_batch(prog)) {
+	char *progs[2];
+	progs[0] = (char *)prog;
+	progs[1] = NULL;
+	len = join_argv(NULL, progs, ntcmd, cp, 1);
+	if (c_switch) len += 3;
+	else ++argv;
+	if (argv[0]) len += join_argv(NULL, argv, ntcmd, cp, 0);
+	cmd = ALLOCV(v, len);
+	join_argv(cmd, progs, ntcmd, cp, 1);
+	if (c_switch) strlcat(cmd, " /c", len);
+	if (argv[0]) join_argv(cmd + strlcat(cmd, " ", len), argv, ntcmd, cp, 0);
+	prog = c_switch ? shell : 0;
+    }
+    else {
+	len = join_argv(NULL, argv, FALSE, cp, 1);
+	cmd = ALLOCV(v, len);
+	join_argv(cmd, argv, FALSE, cp, 1);
+    }
+
+    if (!e && cmd && !(wcmd = mbstr_to_wstr(cp, cmd, -1, NULL))) e = E2BIG;
+    if (v) ALLOCV_END(v);
+    if (!e && prog && !(wprog = mbstr_to_wstr(cp, prog, -1, NULL))) e = E2BIG;
+
+    if (!e) {
+	ret = child_result(CreateChild(wcmd, wprog, NULL, NULL, NULL, NULL, flags), mode);
+    }
+    free(wprog);
+    free(wcmd);
+    if (e) errno = e;
+    return ret;
+}
+
+/* License: Ruby's */
+rb_pid_t
+rb_w32_aspawn_flags(int mode, const char *prog, char *const *argv, DWORD flags)
+{
+    /* assume ACP */
+    return w32_aspawn_flags(mode, prog, argv, flags, filecp());
+}
+
+/* License: Ruby's */
+rb_pid_t
+rb_w32_uaspawn_flags(int mode, const char *prog, char *const *argv, DWORD flags)
+{
+    return w32_aspawn_flags(mode, prog, argv, flags, CP_UTF8);
+}
+
+/* License: Ruby's */
+rb_pid_t
+rb_w32_aspawn(int mode, const char *prog, char *const *argv)
+{
+    return rb_w32_aspawn_flags(mode, prog, argv, 0);
+}
+
+/* License: Ruby's */
+rb_pid_t
+rb_w32_uaspawn(int mode, const char *prog, char *const *argv)
+{
+    return rb_w32_uaspawn_flags(mode, prog, argv, 0);
+}
+
+/* License: Artistic or GPL */
+typedef struct _NtCmdLineElement {
+    struct _NtCmdLineElement *next;
+    char *str;
+    long len;
+    int flags;
+} NtCmdLineElement;
+
+//
+// Possible values for flags
+//
+
+#define NTGLOB   0x1	// element contains a wildcard
+#define NTMALLOC 0x2	// string in element was malloc'ed
+#define NTSTRING 0x4	// element contains a quoted string
+
+/* License: Ruby's */
+static int
+insert(const char *path, VALUE vinfo, void *enc)
+{
+    NtCmdLineElement *tmpcurr;
+    NtCmdLineElement ***tail = (NtCmdLineElement ***)vinfo;
+
+    tmpcurr = (NtCmdLineElement *)malloc(sizeof(NtCmdLineElement));
+    if (!tmpcurr) return -1;
+    MEMZERO(tmpcurr, NtCmdLineElement, 1);
+    tmpcurr->len = strlen(path);
+    tmpcurr->str = strdup(path);
+    if (!tmpcurr->str) return -1;
+    tmpcurr->flags |= NTMALLOC;
+    **tail = tmpcurr;
+    *tail = &tmpcurr->next;
+
+    return 0;
+}
+
+/* License: Artistic or GPL */
+static NtCmdLineElement **
+cmdglob(NtCmdLineElement *patt, NtCmdLineElement **tail, UINT cp, rb_encoding *enc)
+{
+    char buffer[MAXPATHLEN], *buf = buffer;
+    NtCmdLineElement **last = tail;
+    int status;
+
+    if (patt->len >= MAXPATHLEN)
+	if (!(buf = malloc(patt->len + 1))) return 0;
+
+    strlcpy(buf, patt->str, patt->len + 1);
+    buf[patt->len] = '\0';
+    translate_char(buf, '\\', '/', cp);
+    status = ruby_brace_glob_with_enc(buf, 0, insert, (VALUE)&tail, enc);
+    if (buf != buffer)
+	free(buf);
+
+    if (status || last == tail) return 0;
+    if (patt->flags & NTMALLOC)
+	free(patt->str);
+    free(patt);
+    return tail;
+}
+
+//
+// Check a command string to determine if it has I/O redirection
+// characters that require it to be executed by a command interpreter
+//
+
+/* License: Artistic or GPL */
+static int
+has_redirection(const char *cmd, UINT cp)
+{
+    char quote = '\0';
+    const char *ptr;
+
+    //
+    // Scan the string, looking for redirection characters (< or >), pipe
+    // character (|) or newline (\n) that are not in a quoted string
+    //
+
+    for (ptr = cmd; *ptr;) {
+	switch (*ptr) {
+	  case '\'':
+	  case '\"':
+	    if (!quote)
+		quote = *ptr;
+	    else if (quote == *ptr)
+		quote = '\0';
+	    ptr++;
+	    break;
+
+	  case '>':
+	  case '<':
+	  case '|':
+	  case '&':
+	  case '\n':
+	    if (!quote)
+		return TRUE;
+	    ptr++;
+	    break;
+
+	  case '%':
+	    if (*++ptr != '_' && !ISALPHA(*ptr)) break;
+	    while (*++ptr == '_' || ISALNUM(*ptr));
+	    if (*ptr++ == '%') return TRUE;
+	    break;
+
+	  case '\\':
+	    ptr++;
+	  default:
+	    ptr = CharNextExA(cp, ptr, 0);
+	    break;
+	}
+    }
+    return FALSE;
+}
+
+/* License: Ruby's */
+static inline WCHAR *
+skipspace(WCHAR *ptr)
+{
+    while (iswspace(*ptr))
+	ptr++;
+    return ptr;
+}
+
+/* License: Artistic or GPL */
+static int
+w32_cmdvector(const WCHAR *cmd, char ***vec, UINT cp, rb_encoding *enc)
+{
+    int globbing, len;
+    int elements, strsz, done;
+    int slashes, escape;
+    WCHAR *ptr, *base, *cmdline;
+    char *cptr, *buffer;
+    char **vptr;
+    WCHAR quote;
+    NtCmdLineElement *curr, **tail;
+    NtCmdLineElement *cmdhead = NULL, **cmdtail = &cmdhead;
+
+    //
+    // just return if we don't have a command line
+    //
+    while (iswspace(*cmd))
+	cmd++;
+    if (!*cmd) {
+	*vec = NULL;
+	return 0;
+    }
+
+    ptr = cmdline = wcsdup(cmd);
+
+    //
+    // Ok, parse the command line, building a list of CmdLineElements.
+    // When we've finished, and it's an input command (meaning that it's
+    // the processes argv), we'll do globing and then build the argument
+    // vector.
+    // The outer loop does one iteration for each element seen.
+    // The inner loop does one iteration for each character in the element.
+    //
+
+    while (*(ptr = skipspace(ptr))) {
+	base = ptr;
+	quote = slashes = globbing = escape = 0;
+	for (done = 0; !done && *ptr; ) {
+	    //
+	    // Switch on the current character. We only care about the
+	    // white-space characters, the  wild-card characters, and the
+	    // quote characters.
+	    //
+
+	    switch (*ptr) {
+	      case L'\\':
+		if (quote != L'\'') slashes++;
+	        break;
+
+	      case L' ':
+	      case L'\t':
+	      case L'\n':
+		//
+		// if we're not in a string, then we're finished with this
+		// element
+		//
+
+		if (!quote) {
+		    *ptr = 0;
+		    done = 1;
+		}
+		break;
+
+	      case L'*':
+	      case L'?':
+	      case L'[':
+	      case L'{':
+		//
+		// record the fact that this element has a wildcard character
+		// N.B. Don't glob if inside a single quoted string
+		//
+
+		if (quote != L'\'')
+		    globbing++;
+		slashes = 0;
+		break;
+
+	      case L'\'':
+	      case L'\"':
+		//
+		// if we're already in a string, see if this is the
+		// terminating close-quote. If it is, we're finished with
+		// the string, but not necessarily with the element.
+		// If we're not already in a string, start one.
+		//
+
+		if (!(slashes & 1)) {
+		    if (!quote)
+			quote = *ptr;
+		    else if (quote == *ptr) {
+			if (quote == L'"' && quote == ptr[1])
+			    ptr++;
+			quote = L'\0';
+		    }
+		}
+		escape++;
+		slashes = 0;
+		break;
+
+	      default:
+		ptr = CharNextW(ptr);
+		slashes = 0;
+		continue;
+	    }
+	    ptr++;
+	}
+
+	//
+	// when we get here, we've got a pair of pointers to the element,
+	// base and ptr. Base points to the start of the element while ptr
+	// points to the character following the element.
+	//
+
+	len = ptr - base;
+	if (done) --len;
+
+	//
+	// if it's an input vector element and it's enclosed by quotes,
+	// we can remove them.
+	//
+
+	if (escape) {
+	    WCHAR *p = base, c;
+	    slashes = quote = 0;
+	    while (p < base + len) {
+		switch (c = *p) {
+		  case L'\\':
+		    p++;
+		    if (quote != L'\'') slashes++;
+		    break;
+
+		  case L'\'':
+		  case L'"':
+		    if (!(slashes & 1) && quote && quote != c) {
+			p++;
+			slashes = 0;
+			break;
+		    }
+		    memcpy(p - ((slashes + 1) >> 1), p + (~slashes & 1),
+			   sizeof(WCHAR) * (base + len - p));
+		    len -= ((slashes + 1) >> 1) + (~slashes & 1);
+		    p -= (slashes + 1) >> 1;
+		    if (!(slashes & 1)) {
+			if (quote) {
+			    if (quote == L'"' && quote == *p)
+				p++;
+			    quote = L'\0';
+			}
+			else
+			    quote = c;
+		    }
+		    else
+			p++;
+		    slashes = 0;
+		    break;
+
+		  default:
+		    p = CharNextW(p);
+		    slashes = 0;
+		    break;
+		}
+	    }
+	}
+
+	curr = (NtCmdLineElement *)calloc(sizeof(NtCmdLineElement), 1);
+	if (!curr) goto do_nothing;
+	curr->str = rb_w32_wstr_to_mbstr(cp, base, len, &curr->len);
+	curr->flags |= NTMALLOC;
+
+	if (globbing && (tail = cmdglob(curr, cmdtail, cp, enc))) {
+	    cmdtail = tail;
+	}
+	else {
+	    *cmdtail = curr;
+	    cmdtail = &curr->next;
+	}
+    }
+
+    //
+    // Almost done!
+    // Count up the elements, then allocate space for a vector of pointers
+    // (argv) and a string table for the elements.
+    //
+
+    for (elements = 0, strsz = 0, curr = cmdhead; curr; curr = curr->next) {
+	elements++;
+	strsz += (curr->len + 1);
+    }
+
+    len = (elements+1)*sizeof(char *) + strsz;
+    buffer = (char *)malloc(len);
+    if (!buffer) {
+      do_nothing:
+	while ((curr = cmdhead) != 0) {
+	    cmdhead = curr->next;
+	    if (curr->flags & NTMALLOC) free(curr->str);
+	    free(curr);
+	}
+	free(cmdline);
+	for (vptr = *vec; *vptr; ++vptr);
+	return vptr - *vec;
+    }
+
+    //
+    // make vptr point to the start of the buffer
+    // and cptr point to the area we'll consider the string table.
+    //
+    //   buffer (*vec)
+    //   |
+    //   V       ^---------------------V
+    //   +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+    //   |   |       | ....  | NULL  |   | ..... |\0 |   | ..... |\0 |...
+    //   +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+    //   |-  elements+1             -| ^ 1st element   ^ 2nd element
+
+    vptr = (char **) buffer;
+
+    cptr = buffer + (elements+1) * sizeof(char *);
+
+    while ((curr = cmdhead) != 0) {
+	strlcpy(cptr, curr->str, curr->len + 1);
+	*vptr++ = cptr;
+	cptr += curr->len + 1;
+	cmdhead = curr->next;
+	if (curr->flags & NTMALLOC) free(curr->str);
+	free(curr);
+    }
+    *vptr = 0;
+
+    *vec = (char **) buffer;
+    free(cmdline);
+    return elements;
+}
+
+//
+// UNIX compatible directory access functions for NT
+//
+
+//
+// The idea here is to read all the directory names into a string table
+// (separated by nulls) and when one of the other dir functions is called
+// return the pointer to the current file name.
+//
+
+/* License: Ruby's */
+#define GetBit(bits, i) ((bits)[(i) / CHAR_BIT] &  (1 << (i) % CHAR_BIT))
+#define SetBit(bits, i) ((bits)[(i) / CHAR_BIT] |= (1 << (i) % CHAR_BIT))
+
+#define BitOfIsDir(n) ((n) * 2)
+#define BitOfIsRep(n) ((n) * 2 + 1)
+#define DIRENT_PER_CHAR (CHAR_BIT / 2)
+
+/* License: Artistic or GPL */
+static HANDLE
+open_dir_handle(const WCHAR *filename, WIN32_FIND_DATAW *fd)
+{
+    HANDLE fh;
+    static const WCHAR wildcard[] = L"\\*";
+    WCHAR *scanname;
+    WCHAR *p;
+    int len;
+    VALUE v;
+
+    //
+    // Create the search pattern
+    //
+    len = lstrlenW(filename);
+    scanname = ALLOCV_N(WCHAR, v, len + sizeof(wildcard) / sizeof(WCHAR));
+    lstrcpyW(scanname, filename);
+    p = CharPrevW(scanname, scanname + len);
+    if (*p == L'/' || *p == L'\\' || *p == L':')
+	lstrcatW(scanname, wildcard + 1);
+    else
+	lstrcatW(scanname, wildcard);
+
+    //
+    // do the FindFirstFile call
+    //
+    fh = FindFirstFileW(scanname, fd);
+    ALLOCV_END(v);
+    if (fh == INVALID_HANDLE_VALUE) {
+	errno = map_errno(GetLastError());
+    }
+    return fh;
+}
+
+/* License: Artistic or GPL */
+static DIR *
+opendir_internal(WCHAR *wpath, const char *filename)
+{
+    struct stati64 sbuf;
+    WIN32_FIND_DATAW fd;
+    HANDLE fh;
+    DIR *p;
+    long len;
+    long idx;
+    WCHAR *tmpW;
+    char *tmp;
+
+    //
+    // check to see if we've got a directory
+    //
+    if (wstati64(wpath, &sbuf) < 0) {
+	return NULL;
+    }
+    if (!(sbuf.st_mode & S_IFDIR) &&
+	(!ISALPHA(filename[0]) || filename[1] != ':' || filename[2] != '\0' ||
+	 ((1 << ((filename[0] & 0x5f) - 'A')) & GetLogicalDrives()) == 0)) {
+	errno = ENOTDIR;
+	return NULL;
+    }
+    fh = open_dir_handle(wpath, &fd);
+    if (fh == INVALID_HANDLE_VALUE) {
+	return NULL;
+    }
+
+    //
+    // Get us a DIR structure
+    //
+    p = calloc(sizeof(DIR), 1);
+    if (p == NULL)
+	return NULL;
+
+    idx = 0;
+
+    //
+    // loop finding all the files that match the wildcard
+    // (which should be all of them in this directory!).
+    // the variable idx should point one past the null terminator
+    // of the previous string found.
+    //
+    do {
+	len = lstrlenW(fd.cFileName) + 1;
+
+	//
+	// bump the string table size by enough for the
+	// new name and it's null terminator
+	//
+	tmpW = realloc(p->start, (idx + len) * sizeof(WCHAR));
+	if (!tmpW) {
+	  error:
+	    rb_w32_closedir(p);
+	    FindClose(fh);
+	    errno = ENOMEM;
+	    return NULL;
+	}
+
+	p->start = tmpW;
+	memcpy(&p->start[idx], fd.cFileName, len * sizeof(WCHAR));
+
+	if (p->nfiles % DIRENT_PER_CHAR == 0) {
+	    tmp = realloc(p->bits, p->nfiles / DIRENT_PER_CHAR + 1);
+	    if (!tmp)
+		goto error;
+	    p->bits = tmp;
+	    p->bits[p->nfiles / DIRENT_PER_CHAR] = 0;
+	}
+	if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+	    SetBit(p->bits, BitOfIsDir(p->nfiles));
+	if (fd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
+	    SetBit(p->bits, BitOfIsRep(p->nfiles));
+
+	p->nfiles++;
+	idx += len;
+    } while (FindNextFileW(fh, &fd));
+    FindClose(fh);
+    p->size = idx;
+    p->curr = p->start;
+    return p;
+}
+
+/* License: Ruby's */
+UINT
+filecp(void)
+{
+    UINT cp = AreFileApisANSI() ? CP_ACP : CP_OEMCP;
+    return cp;
+}
+
+/* License: Ruby's */
+char *
+rb_w32_wstr_to_mbstr(UINT cp, const WCHAR *wstr, int clen, long *plen)
+{
+    char *ptr;
+    int len = WideCharToMultiByte(cp, 0, wstr, clen, NULL, 0, NULL, NULL);
+    if (!(ptr = malloc(len))) return 0;
+    WideCharToMultiByte(cp, 0, wstr, clen, ptr, len, NULL, NULL);
+    if (plen) {
+	/* exclude NUL only if NUL-terminated string */
+	if (clen == -1) --len;
+	*plen = len;
+    }
+    return ptr;
+}
+
+/* License: Ruby's */
+WCHAR *
+rb_w32_mbstr_to_wstr(UINT cp, const char *str, int clen, long *plen)
+{
+    WCHAR *ptr;
+    int len = MultiByteToWideChar(cp, 0, str, clen, NULL, 0);
+    if (!(ptr = malloc(sizeof(WCHAR) * len))) return 0;
+    MultiByteToWideChar(cp, 0, str, clen, ptr, len);
+    if (plen) {
+	/* exclude NUL only if NUL-terminated string */
+	if (clen == -1) --len;
+	*plen = len;
+    }
+    return ptr;
+}
+
+/* License: Ruby's */
+DIR *
+rb_w32_opendir(const char *filename)
+{
+    DIR *ret;
+    WCHAR *wpath = filecp_to_wstr(filename, NULL);
+    if (!wpath)
+	return NULL;
+    ret = opendir_internal(wpath, filename);
+    free(wpath);
+    return ret;
+}
+
+/* License: Ruby's */
+DIR *
+rb_w32_uopendir(const char *filename)
+{
+    DIR *ret;
+    WCHAR *wpath = utf8_to_wstr(filename, NULL);
+    if (!wpath)
+	return NULL;
+    ret = opendir_internal(wpath, filename);
+    free(wpath);
+    return ret;
+}
+
+//
+// Move to next entry
+//
+
+/* License: Artistic or GPL */
+static void
+move_to_next_entry(DIR *dirp)
+{
+    if (dirp->curr) {
+	dirp->loc++;
+	dirp->curr += lstrlenW(dirp->curr) + 1;
+	if (dirp->curr >= (dirp->start + dirp->size)) {
+	    dirp->curr = NULL;
+	}
+    }
+}
+
+//
+// Readdir just returns the current string pointer and bumps the
+// string pointer to the next entry.
+//
+/* License: Ruby's */
+static BOOL
+win32_direct_conv(const WCHAR *file, struct direct *entry, const void *enc)
+{
+    UINT cp = *((UINT *)enc);
+    if (!(entry->d_name = wstr_to_mbstr(cp, file, -1, &entry->d_namlen)))
+	return FALSE;
+    return TRUE;
+}
+
+/* License: Ruby's */
+VALUE
+rb_w32_conv_from_wchar(const WCHAR *wstr, rb_encoding *enc)
+{
+    VALUE src;
+    long len = lstrlenW(wstr);
+    int encindex = rb_enc_to_index(enc);
+
+    if (encindex == ENCINDEX_UTF_16LE) {
+	return rb_enc_str_new((char *)wstr, len * sizeof(WCHAR), enc);
+    }
+    else {
+#if SIZEOF_INT < SIZEOF_LONG
+# error long should equal to int on Windows
+#endif
+	int clen = rb_long2int(len);
+	len = WideCharToMultiByte(CP_UTF8, 0, wstr, clen, NULL, 0, NULL, NULL);
+	src = rb_enc_str_new(0, len, rb_enc_from_index(ENCINDEX_UTF_8));
+	WideCharToMultiByte(CP_UTF8, 0, wstr, clen, RSTRING_PTR(src), len, NULL, NULL);
+    }
+    switch (encindex) {
+      case ENCINDEX_ASCII:
+      case ENCINDEX_US_ASCII:
+	/* assume UTF-8 */
+      case ENCINDEX_UTF_8:
+	/* do nothing */
+	return src;
+    }
+    return rb_str_conv_enc_opts(src, NULL, enc, ECONV_UNDEF_REPLACE, Qnil);
+}
+
+/* License: Ruby's */
+char *
+rb_w32_conv_from_wstr(const WCHAR *wstr, long *lenp, rb_encoding *enc)
+{
+    VALUE str = rb_w32_conv_from_wchar(wstr, enc);
+    long len;
+    char *ptr;
+
+    if (NIL_P(str)) return wstr_to_filecp(wstr, lenp);
+    *lenp = len = RSTRING_LEN(str);
+    memcpy(ptr = malloc(len + 1), RSTRING_PTR(str), len);
+    ptr[len] = '\0';
+    return ptr;
+}
+
+/* License: Ruby's */
+static BOOL
+ruby_direct_conv(const WCHAR *file, struct direct *entry, const void *enc)
+{
+    if (!(entry->d_name = rb_w32_conv_from_wstr(file, &entry->d_namlen, enc)))
+	return FALSE;
+    return TRUE;
+}
+
+/* License: Artistic or GPL */
+static struct direct *
+readdir_internal(DIR *dirp, BOOL (*conv)(const WCHAR *, struct direct *, const void *), const void *enc)
+{
+    static int dummy = 0;
+
+    if (dirp->curr) {
+
+	//
+	// first set up the structure to return
+	//
+	if (dirp->dirstr.d_name)
+	    free(dirp->dirstr.d_name);
+	conv(dirp->curr, &dirp->dirstr, enc);
+
+	//
+	// Fake inode
+	//
+	dirp->dirstr.d_ino = dummy++;
+
+	//
+	// Attributes
+	//
+	dirp->dirstr.d_isdir = GetBit(dirp->bits, BitOfIsDir(dirp->loc));
+	dirp->dirstr.d_isrep = GetBit(dirp->bits, BitOfIsRep(dirp->loc));
+
+	//
+	// Now set up for the next call to readdir
+	//
+
+	move_to_next_entry(dirp);
+
+	return &(dirp->dirstr);
+
+    }
+    else
+	return NULL;
+}
+
+/* License: Ruby's */
+struct direct  *
+rb_w32_readdir(DIR *dirp, rb_encoding *enc)
+{
+    if (!enc || enc == rb_ascii8bit_encoding()) {
+	const UINT cp = filecp();
+	return readdir_internal(dirp, win32_direct_conv, &cp);
+    }
+    else if (enc == rb_utf8_encoding()) {
+	const UINT cp = CP_UTF8;
+	return readdir_internal(dirp, win32_direct_conv, &cp);
+    }
+    else
+	return readdir_internal(dirp, ruby_direct_conv, enc);
+}
+
+//
+// Telldir returns the current string pointer position
+//
+
+/* License: Artistic or GPL */
+long
+rb_w32_telldir(DIR *dirp)
+{
+    return dirp->loc;
+}
+
+//
+// Seekdir moves the string pointer to a previously saved position
+// (Saved by telldir).
+
+/* License: Ruby's */
+void
+rb_w32_seekdir(DIR *dirp, long loc)
+{
+    if (dirp->loc > loc) rb_w32_rewinddir(dirp);
+
+    while (dirp->curr && dirp->loc < loc) {
+	move_to_next_entry(dirp);
+    }
+}
+
+//
+// Rewinddir resets the string pointer to the start
+//
+
+/* License: Artistic or GPL */
+void
+rb_w32_rewinddir(DIR *dirp)
+{
+    dirp->curr = dirp->start;
+    dirp->loc = 0;
+}
+
+//
+// This just free's the memory allocated by opendir
+//
+
+/* License: Artistic or GPL */
+void
+rb_w32_closedir(DIR *dirp)
+{
+    if (dirp) {
+	if (dirp->dirstr.d_name)
+	    free(dirp->dirstr.d_name);
+	if (dirp->start)
+	    free(dirp->start);
+	if (dirp->bits)
+	    free(dirp->bits);
+	free(dirp);
+    }
+}
+
+#if (defined _MT || defined __MSVCRT__) && !defined __BORLANDC__
+#define MSVCRT_THREADS
+#endif
+#ifdef MSVCRT_THREADS
+# define MTHREAD_ONLY(x) x
+# define STHREAD_ONLY(x)
+#elif defined(__BORLANDC__)
+# define MTHREAD_ONLY(x)
+# define STHREAD_ONLY(x)
+#else
+# define MTHREAD_ONLY(x)
+# define STHREAD_ONLY(x) x
+#endif
+
+/* License: Ruby's */
+typedef struct	{
+    intptr_t osfhnd;	/* underlying OS file HANDLE */
+    char osfile;	/* attributes of file (e.g., open in text mode?) */
+    char pipech;	/* one char buffer for handles opened on pipes */
+#ifdef MSVCRT_THREADS
+    int lockinitflag;
+    CRITICAL_SECTION lock;
+#endif
+#if RUBY_MSVCRT_VERSION >= 80
+    char textmode;
+    char pipech2[2];
+#endif
+}	ioinfo;
+
+#if !defined _CRTIMP || defined __MINGW32__
+#undef _CRTIMP
+#define _CRTIMP __declspec(dllimport)
+#endif
+
+#if !defined(__BORLANDC__)
+EXTERN_C _CRTIMP ioinfo * __pioinfo[];
+static inline ioinfo* _pioinfo(int);
+
+#define IOINFO_L2E			5
+#define IOINFO_ARRAY_ELTS	(1 << IOINFO_L2E)
+#define _osfhnd(i)  (_pioinfo(i)->osfhnd)
+#define _osfile(i)  (_pioinfo(i)->osfile)
+#define _pipech(i)  (_pioinfo(i)->pipech)
+
+#if RUBY_MSVCRT_VERSION >= 80
+static size_t pioinfo_extra = 0;	/* workaround for VC++8 SP1 */
+
+/* License: Ruby's */
+static void
+set_pioinfo_extra(void)
+{
+    int fd;
+
+    fd = _open("NUL", O_RDONLY);
+    for (pioinfo_extra = 0; pioinfo_extra <= 64; pioinfo_extra += sizeof(void *)) {
+	if (_osfhnd(fd) == _get_osfhandle(fd)) {
+	    break;
+	}
+    }
+    _close(fd);
+
+    if (pioinfo_extra > 64) {
+	/* not found, maybe something wrong... */
+	pioinfo_extra = 0;
+    }
+}
+#else
+#define pioinfo_extra 0
+#endif
+
+static inline ioinfo*
+_pioinfo(int fd)
+{
+    const size_t sizeof_ioinfo = sizeof(ioinfo) + pioinfo_extra;
+    return (ioinfo*)((char*)__pioinfo[fd >> IOINFO_L2E] +
+		     (fd & (IOINFO_ARRAY_ELTS - 1)) * sizeof_ioinfo);
+}
+
+#define _set_osfhnd(fh, osfh) (void)(_osfhnd(fh) = osfh)
+#define _set_osflags(fh, flags) (_osfile(fh) = (flags))
+
+#define FOPEN			0x01	/* file handle open */
+#define FEOFLAG			0x02	/* end of file has been encountered */
+#define FPIPE			0x08	/* file handle refers to a pipe */
+#define FNOINHERIT		0x10	/* file handle opened O_NOINHERIT */
+#define FAPPEND			0x20	/* file handle opened O_APPEND */
+#define FDEV			0x40	/* file handle refers to device */
+#define FTEXT			0x80	/* file handle is in text mode */
+
+static int is_socket(SOCKET);
+static int is_console(SOCKET);
+
+/* License: Ruby's */
+int
+rb_w32_io_cancelable_p(int fd)
+{
+    return cancel_io != NULL && (is_socket(TO_SOCKET(fd)) || !is_console(TO_SOCKET(fd)));
+}
+
+/* License: Ruby's */
+static int
+rb_w32_open_osfhandle(intptr_t osfhandle, int flags)
+{
+    int fh;
+    char fileflags;		/* _osfile flags */
+    HANDLE hF;
+
+    /* copy relevant flags from second parameter */
+    fileflags = FDEV;
+
+    if (flags & O_APPEND)
+	fileflags |= FAPPEND;
+
+    if (flags & O_TEXT)
+	fileflags |= FTEXT;
+
+    if (flags & O_NOINHERIT)
+	fileflags |= FNOINHERIT;
+
+    /* attempt to allocate a C Runtime file handle */
+    hF = CreateFile("NUL", 0, 0, NULL, OPEN_ALWAYS, 0, NULL);
+    fh = _open_osfhandle((intptr_t)hF, 0);
+    CloseHandle(hF);
+    if (fh == -1) {
+	errno = EMFILE;		/* too many open files */
+	_doserrno = 0L;		/* not an OS error */
+    }
+    else {
+
+	MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fh)->lock)));
+	/* the file is open. now, set the info in _osfhnd array */
+	_set_osfhnd(fh, osfhandle);
+
+	fileflags |= FOPEN;		/* mark as open */
+
+	_set_osflags(fh, fileflags); /* set osfile entry */
+	MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fh)->lock));
+    }
+    return fh;			/* return handle */
+}
+
+/* License: Ruby's */
+static void
+init_stdhandle(void)
+{
+    int nullfd = -1;
+    int keep = 0;
+#define open_null(fd)						\
+    (((nullfd < 0) ?						\
+      (nullfd = open("NUL", O_RDWR)) : 0),		\
+     ((nullfd == (fd)) ? (keep = 1) : dup2(nullfd, fd)),	\
+     (fd))
+
+    if (fileno(stdin) < 0) {
+	stdin->_file = open_null(0);
+    }
+    else {
+	setmode(fileno(stdin), O_BINARY);
+    }
+    if (fileno(stdout) < 0) {
+	stdout->_file = open_null(1);
+    }
+    if (fileno(stderr) < 0) {
+	stderr->_file = open_null(2);
+    }
+    if (nullfd >= 0 && !keep) close(nullfd);
+    setvbuf(stderr, NULL, _IONBF, 0);
+}
+#else
+
+#define _set_osfhnd(fh, osfh) (void)((fh), (osfh))
+#define _set_osflags(fh, flags) (void)((fh), (flags))
+
+/* License: Ruby's */
+static void
+init_stdhandle(void)
+{
+}
+#endif
+
+/* License: Ruby's */
+#ifdef __BORLANDC__
+static int
+rb_w32_open_osfhandle(intptr_t osfhandle, int flags)
+{
+    int fd = _open_osfhandle(osfhandle, flags);
+    if (fd == -1) {
+	errno = EMFILE;		/* too many open files */
+	_doserrno = 0L;		/* not an OS error */
+    }
+    return fd;
+}
+#endif
+
+#undef getsockopt
+
+/* License: Ruby's */
+static int
+is_socket(SOCKET sock)
+{
+    if (socklist_lookup(sock, NULL))
+	return TRUE;
+    else
+	return FALSE;
+}
+
+/* License: Ruby's */
+int
+rb_w32_is_socket(int fd)
+{
+    return is_socket(TO_SOCKET(fd));
+}
+
+//
+// Since the errors returned by the socket error function
+// WSAGetLastError() are not known by the library routine strerror
+// we have to roll our own.
+//
+
+#undef strerror
+
+/* License: Artistic or GPL */
+char *
+rb_w32_strerror(int e)
+{
+    static char buffer[512];
+    DWORD source = 0;
+    char *p;
+
+#if defined __BORLANDC__ && defined ENOTEMPTY // _sys_errlist is broken
+    switch (e) {
+      case ENAMETOOLONG:
+	return "Filename too long";
+      case ENOTEMPTY:
+	return "Directory not empty";
+    }
+#endif
+
+    if (e < 0 || e > sys_nerr) {
+	if (e < 0)
+	    e = GetLastError();
+#if WSAEWOULDBLOCK != EWOULDBLOCK
+	else if (e >= EADDRINUSE && e <= EWOULDBLOCK) {
+	    static int s = -1;
+	    int i;
+	    if (s < 0)
+		for (s = 0; s < (int)(sizeof(errmap)/sizeof(*errmap)); s++)
+		    if (errmap[s].winerr == WSAEWOULDBLOCK)
+			break;
+	    for (i = s; i < (int)(sizeof(errmap)/sizeof(*errmap)); i++)
+		if (errmap[i].err == e) {
+		    e = errmap[i].winerr;
+		    break;
+		}
+	}
+#endif
+	if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
+			  FORMAT_MESSAGE_IGNORE_INSERTS, &source, e,
+			  MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
+			  buffer, sizeof(buffer), NULL) == 0 &&
+	    FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
+			  FORMAT_MESSAGE_IGNORE_INSERTS, &source, e, 0,
+			  buffer, sizeof(buffer), NULL) == 0)
+	    strlcpy(buffer, "Unknown Error", sizeof(buffer));
+    }
+    else
+	strlcpy(buffer, strerror(e), sizeof(buffer));
+
+    p = buffer;
+    while ((p = strpbrk(p, "\r\n")) != NULL) {
+	memmove(p, p + 1, strlen(p));
+    }
+    return buffer;
+}
+
+//
+// various stubs
+//
+
+
+// Ownership
+//
+// Just pretend that everyone is a superuser. NT will let us know if
+// we don't really have permission to do something.
+//
+
+#define ROOT_UID	0
+#define ROOT_GID	0
+
+/* License: Artistic or GPL */
+rb_uid_t
+getuid(void)
+{
+	return ROOT_UID;
+}
+
+/* License: Artistic or GPL */
+rb_uid_t
+geteuid(void)
+{
+	return ROOT_UID;
+}
+
+/* License: Artistic or GPL */
+rb_gid_t
+getgid(void)
+{
+	return ROOT_GID;
+}
+
+/* License: Artistic or GPL */
+rb_gid_t
+getegid(void)
+{
+    return ROOT_GID;
+}
+
+/* License: Artistic or GPL */
+int
+setuid(rb_uid_t uid)
+{
+    return (uid == ROOT_UID ? 0 : -1);
+}
+
+/* License: Artistic or GPL */
+int
+setgid(rb_gid_t gid)
+{
+    return (gid == ROOT_GID ? 0 : -1);
+}
+
+//
+// File system stuff
+//
+
+/* License: Artistic or GPL */
+int
+ioctl(int i, int u, ...)
+{
+    errno = EINVAL;
+    return -1;
+}
+
+void
+rb_w32_fdset(int fd, fd_set *set)
+{
+    FD_SET(fd, set);
+}
+
+#undef FD_CLR
+
+/* License: Ruby's */
+void
+rb_w32_fdclr(int fd, fd_set *set)
+{
+    unsigned int i;
+    SOCKET s = TO_SOCKET(fd);
+
+    for (i = 0; i < set->fd_count; i++) {
+        if (set->fd_array[i] == s) {
+	    memmove(&set->fd_array[i], &set->fd_array[i+1],
+		    sizeof(set->fd_array[0]) * (--set->fd_count - i));
+            break;
+        }
+    }
+}
+
+#undef FD_ISSET
+
+/* License: Ruby's */
+int
+rb_w32_fdisset(int fd, fd_set *set)
+{
+    int ret;
+    SOCKET s = TO_SOCKET(fd);
+    if (s == (SOCKET)INVALID_HANDLE_VALUE)
+        return 0;
+    RUBY_CRITICAL(ret = __WSAFDIsSet(s, set));
+    return ret;
+}
+
+/* License: Ruby's */
+void
+rb_w32_fd_copy(rb_fdset_t *dst, const fd_set *src, int max)
+{
+    max = min(src->fd_count, (UINT)max);
+    if ((UINT)dst->capa < (UINT)max) {
+	dst->capa = (src->fd_count / FD_SETSIZE + 1) * FD_SETSIZE;
+	dst->fdset = xrealloc(dst->fdset, sizeof(unsigned int) + sizeof(SOCKET) * dst->capa);
+    }
+
+    memcpy(dst->fdset->fd_array, src->fd_array,
+	   max * sizeof(src->fd_array[0]));
+    dst->fdset->fd_count = src->fd_count;
+}
+
+/* License: Ruby's */
+void
+rb_w32_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src)
+{
+    if ((UINT)dst->capa < src->fdset->fd_count) {
+	dst->capa = (src->fdset->fd_count / FD_SETSIZE + 1) * FD_SETSIZE;
+	dst->fdset = xrealloc(dst->fdset, sizeof(unsigned int) + sizeof(SOCKET) * dst->capa);
+    }
+
+    memcpy(dst->fdset->fd_array, src->fdset->fd_array,
+	   src->fdset->fd_count * sizeof(src->fdset->fd_array[0]));
+    dst->fdset->fd_count = src->fdset->fd_count;
+}
+
+//
+// Networking trampolines
+// These are used to avoid socket startup/shutdown overhead in case
+// the socket routines aren't used.
+//
+
+#undef select
+
+/* License: Ruby's */
+static int
+extract_fd(rb_fdset_t *dst, fd_set *src, int (*func)(SOCKET))
+{
+    unsigned int s = 0;
+    unsigned int m = 0;
+    if (!src) return 0;
+
+    while (s < src->fd_count) {
+        SOCKET fd = src->fd_array[s];
+
+	if (!func || (*func)(fd)) {
+	    if (dst) { /* move it to dst */
+		unsigned int d;
+
+		for (d = 0; d < dst->fdset->fd_count; d++) {
+		    if (dst->fdset->fd_array[d] == fd)
+			break;
+		}
+		if (d == dst->fdset->fd_count) {
+		    if ((int)dst->fdset->fd_count >= dst->capa) {
+			dst->capa = (dst->fdset->fd_count / FD_SETSIZE + 1) * FD_SETSIZE;
+			dst->fdset = xrealloc(dst->fdset, sizeof(unsigned int) + sizeof(SOCKET) * dst->capa);
+		    }
+		    dst->fdset->fd_array[dst->fdset->fd_count++] = fd;
+		}
+		memmove(
+		    &src->fd_array[s],
+		    &src->fd_array[s+1],
+		    sizeof(src->fd_array[0]) * (--src->fd_count - s));
+	    }
+	    else {
+		m++;
+		s++;
+	    }
+	}
+	else s++;
+    }
+
+    return dst ? dst->fdset->fd_count : m;
+}
+
+/* License: Ruby's */
+static int
+copy_fd(fd_set *dst, fd_set *src)
+{
+    unsigned int s;
+    if (!src || !dst) return 0;
+
+    for (s = 0; s < src->fd_count; ++s) {
+	SOCKET fd = src->fd_array[s];
+	unsigned int d;
+	for (d = 0; d < dst->fd_count; ++d) {
+	    if (dst->fd_array[d] == fd)
+		break;
+	}
+	if (d == dst->fd_count && d < FD_SETSIZE) {
+	    dst->fd_array[dst->fd_count++] = fd;
+	}
+    }
+
+    return dst->fd_count;
+}
+
+/* License: Ruby's */
+static int
+is_not_socket(SOCKET sock)
+{
+    return !is_socket(sock);
+}
+
+/* License: Ruby's */
+static int
+is_pipe(SOCKET sock) /* DONT call this for SOCKET! it claims it is PIPE. */
+{
+    int ret;
+
+    RUBY_CRITICAL({
+	ret = (GetFileType((HANDLE)sock) == FILE_TYPE_PIPE);
+    });
+
+    return ret;
+}
+
+/* License: Ruby's */
+static int
+is_readable_pipe(SOCKET sock) /* call this for pipe only */
+{
+    int ret;
+    DWORD n = 0;
+
+    RUBY_CRITICAL(
+	if (PeekNamedPipe((HANDLE)sock, NULL, 0, NULL, &n, NULL)) {
+	    ret = (n > 0);
+	}
+	else {
+	    ret = (GetLastError() == ERROR_BROKEN_PIPE); /* pipe was closed */
+	}
+    );
+
+    return ret;
+}
+
+/* License: Ruby's */
+static int
+is_console(SOCKET sock) /* DONT call this for SOCKET! */
+{
+    int ret;
+    DWORD n = 0;
+    INPUT_RECORD ir;
+
+    RUBY_CRITICAL(
+	ret = (PeekConsoleInput((HANDLE)sock, &ir, 1, &n))
+    );
+
+    return ret;
+}
+
+/* License: Ruby's */
+static int
+is_readable_console(SOCKET sock) /* call this for console only */
+{
+    int ret = 0;
+    DWORD n = 0;
+    INPUT_RECORD ir;
+
+    RUBY_CRITICAL(
+	if (PeekConsoleInput((HANDLE)sock, &ir, 1, &n) && n > 0) {
+	    if (ir.EventType == KEY_EVENT && ir.Event.KeyEvent.bKeyDown &&
+		ir.Event.KeyEvent.uChar.AsciiChar) {
+		ret = 1;
+	    }
+	    else {
+		ReadConsoleInput((HANDLE)sock, &ir, 1, &n);
+	    }
+	}
+    );
+
+    return ret;
+}
+
+/* License: Ruby's */
+static int
+is_invalid_handle(SOCKET sock)
+{
+    return (HANDLE)sock == INVALID_HANDLE_VALUE;
+}
+
+/* License: Artistic or GPL */
+static int
+do_select(int nfds, fd_set *rd, fd_set *wr, fd_set *ex,
+	  struct timeval *timeout)
+{
+    int r = 0;
+
+    if (nfds == 0) {
+	if (timeout)
+	    rb_w32_sleep(timeout->tv_sec * 1000 + timeout->tv_usec / 1000);
+	else
+	    rb_w32_sleep(INFINITE);
+    }
+    else {
+	if (!NtSocketsInitialized)
+	    StartSockets();
+
+	RUBY_CRITICAL(
+	    EnterCriticalSection(&select_mutex);
+	    r = select(nfds, rd, wr, ex, timeout);
+	    LeaveCriticalSection(&select_mutex);
+	    if (r == SOCKET_ERROR) {
+		errno = map_errno(WSAGetLastError());
+		r = -1;
+	    }
+	);
+    }
+
+    return r;
+}
+
+/*
+ * rest -= wait
+ * return 0 if rest is smaller than wait.
+ */
+/* License: Ruby's */
+int
+rb_w32_time_subtract(struct timeval *rest, const struct timeval *wait)
+{
+    if (rest->tv_sec < wait->tv_sec) {
+	return 0;
+    }
+    while (rest->tv_usec < wait->tv_usec) {
+	if (rest->tv_sec <= wait->tv_sec) {
+	    return 0;
+	}
+	rest->tv_sec -= 1;
+	rest->tv_usec += 1000 * 1000;
+    }
+    rest->tv_sec -= wait->tv_sec;
+    rest->tv_usec -= wait->tv_usec;
+    return rest->tv_sec != 0 || rest->tv_usec != 0;
+}
+
+/* License: Ruby's */
+static inline int
+compare(const struct timeval *t1, const struct timeval *t2)
+{
+    if (t1->tv_sec < t2->tv_sec)
+	return -1;
+    if (t1->tv_sec > t2->tv_sec)
+	return 1;
+    if (t1->tv_usec < t2->tv_usec)
+	return -1;
+    if (t1->tv_usec > t2->tv_usec)
+	return 1;
+    return 0;
+}
+
+#undef Sleep
+
+int rb_w32_check_interrupt(void *);	/* @internal */
+
+/* @internal */
+/* License: Ruby's */
+int
+rb_w32_select_with_thread(int nfds, fd_set *rd, fd_set *wr, fd_set *ex,
+			  struct timeval *timeout, void *th)
+{
+    int r;
+    rb_fdset_t pipe_rd;
+    rb_fdset_t cons_rd;
+    rb_fdset_t else_rd;
+    rb_fdset_t else_wr;
+    rb_fdset_t except;
+    int nonsock = 0;
+    struct timeval limit = {0, 0};
+
+    if (nfds < 0 || (timeout && (timeout->tv_sec < 0 || timeout->tv_usec < 0))) {
+	errno = EINVAL;
+	return -1;
+    }
+
+    if (timeout) {
+	if (timeout->tv_sec < 0 ||
+	    timeout->tv_usec < 0 ||
+	    timeout->tv_usec >= 1000000) {
+	    errno = EINVAL;
+	    return -1;
+	}
+	gettimeofday(&limit, NULL);
+	limit.tv_sec += timeout->tv_sec;
+	limit.tv_usec += timeout->tv_usec;
+	if (limit.tv_usec >= 1000000) {
+	    limit.tv_usec -= 1000000;
+	    limit.tv_sec++;
+	}
+    }
+
+    // assume else_{rd,wr} (other than socket, pipe reader, console reader)
+    // are always readable/writable. but this implementation still has
+    // problem. if pipe's buffer is full, writing to pipe will block
+    // until some data is read from pipe. but ruby is single threaded system,
+    // so whole system will be blocked forever.
+
+    rb_fd_init(&else_rd);
+    nonsock += extract_fd(&else_rd, rd, is_not_socket);
+
+    rb_fd_init(&else_wr);
+    nonsock += extract_fd(&else_wr, wr, is_not_socket);
+
+    // check invalid handles
+    if (extract_fd(NULL, else_rd.fdset, is_invalid_handle) > 0 ||
+	extract_fd(NULL, else_wr.fdset, is_invalid_handle) > 0) {
+	rb_fd_term(&else_wr);
+	rb_fd_term(&else_rd);
+	errno = EBADF;
+	return -1;
+    }
+
+    rb_fd_init(&pipe_rd);
+    extract_fd(&pipe_rd, else_rd.fdset, is_pipe); // should not call is_pipe for socket
+
+    rb_fd_init(&cons_rd);
+    extract_fd(&cons_rd, else_rd.fdset, is_console); // ditto
+
+    rb_fd_init(&except);
+    extract_fd(&except, ex, is_not_socket); // drop only
+
+    r = 0;
+    if (rd && (int)rd->fd_count > r) r = (int)rd->fd_count;
+    if (wr && (int)wr->fd_count > r) r = (int)wr->fd_count;
+    if (ex && (int)ex->fd_count > r) r = (int)ex->fd_count;
+    if (nfds > r) nfds = r;
+
+    {
+	struct timeval rest;
+	const struct timeval wait = {0, 10 * 1000}; // 10ms
+	struct timeval zero = {0, 0};		    // 0ms
+	for (;;) {
+	    if (th && rb_w32_check_interrupt(th) != WAIT_TIMEOUT) {
+		r = -1;
+		break;
+	    }
+	    if (nonsock) {
+		// modifying {else,pipe,cons}_rd is safe because
+		// if they are modified, function returns immediately.
+		extract_fd(&else_rd, pipe_rd.fdset, is_readable_pipe);
+		extract_fd(&else_rd, cons_rd.fdset, is_readable_console);
+	    }
+
+	    if (else_rd.fdset->fd_count || else_wr.fdset->fd_count) {
+		r = do_select(nfds, rd, wr, ex, &zero); // polling
+		if (r < 0) break; // XXX: should I ignore error and return signaled handles?
+		r += copy_fd(rd, else_rd.fdset);
+		r += copy_fd(wr, else_wr.fdset);
+		if (ex)
+		    r += ex->fd_count;
+		break;
+	    }
+	    else {
+		const struct timeval *dowait = &wait;
+
+		fd_set orig_rd;
+		fd_set orig_wr;
+		fd_set orig_ex;
+
+		FD_ZERO(&orig_rd);
+		FD_ZERO(&orig_wr);
+		FD_ZERO(&orig_ex);
+
+		if (rd) copy_fd(&orig_rd, rd);
+		if (wr) copy_fd(&orig_wr, wr);
+		if (ex) copy_fd(&orig_ex, ex);
+		r = do_select(nfds, rd, wr, ex, &zero);	// polling
+		if (r != 0) break; // signaled or error
+		if (rd) copy_fd(rd, &orig_rd);
+		if (wr) copy_fd(wr, &orig_wr);
+		if (ex) copy_fd(ex, &orig_ex);
+
+		if (timeout) {
+		    struct timeval now;
+		    gettimeofday(&now, NULL);
+		    rest = limit;
+		    if (!rb_w32_time_subtract(&rest, &now)) break;
+		    if (compare(&rest, &wait) < 0) dowait = &rest;
+		}
+		Sleep(dowait->tv_sec * 1000 + (dowait->tv_usec + 999) / 1000);
+	    }
+	}
+    }
+
+    rb_fd_term(&except);
+    rb_fd_term(&cons_rd);
+    rb_fd_term(&pipe_rd);
+    rb_fd_term(&else_wr);
+    rb_fd_term(&else_rd);
+
+    return r;
+}
+
+/* License: Ruby's */
+int WSAAPI
+rb_w32_select(int nfds, fd_set *rd, fd_set *wr, fd_set *ex,
+	      struct timeval *timeout)
+{
+    return rb_w32_select_with_thread(nfds, rd, wr, ex, timeout, 0);
+}
+
+/* License: Ruby's */
+static FARPROC
+get_wsa_extension_function(SOCKET s, GUID *guid)
+{
+    DWORD dmy;
+    FARPROC ptr = NULL;
+
+    WSAIoctl(s, SIO_GET_EXTENSION_FUNCTION_POINTER, guid, sizeof(*guid),
+	     &ptr, sizeof(ptr), &dmy, NULL, NULL);
+    if (!ptr)
+	errno = ENOSYS;
+    return ptr;
+}
+
+#undef accept
+
+/* License: Artistic or GPL */
+int WSAAPI
+rb_w32_accept(int s, struct sockaddr *addr, int *addrlen)
+{
+    SOCKET r;
+    int fd;
+
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	HANDLE h = CreateFile("NUL", 0, 0, NULL, OPEN_ALWAYS, 0, NULL);
+	fd = rb_w32_open_osfhandle((intptr_t)h, O_RDWR|O_BINARY|O_NOINHERIT);
+	if (fd != -1) {
+	    r = accept(TO_SOCKET(s), addr, addrlen);
+	    if (r != INVALID_SOCKET) {
+		SetHandleInformation((HANDLE)r, HANDLE_FLAG_INHERIT, 0);
+		MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fd)->lock)));
+		_set_osfhnd(fd, r);
+		MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+		CloseHandle(h);
+		socklist_insert(r, 0);
+	    }
+	    else {
+		errno = map_errno(WSAGetLastError());
+		close(fd);
+		fd = -1;
+	    }
+	}
+	else
+	    CloseHandle(h);
+    });
+    return fd;
+}
+
+#undef bind
+
+/* License: Artistic or GPL */
+int WSAAPI
+rb_w32_bind(int s, const struct sockaddr *addr, int addrlen)
+{
+    int r;
+
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	r = bind(TO_SOCKET(s), addr, addrlen);
+	if (r == SOCKET_ERROR)
+	    errno = map_errno(WSAGetLastError());
+    });
+    return r;
+}
+
+#undef connect
+
+/* License: Artistic or GPL */
+int WSAAPI
+rb_w32_connect(int s, const struct sockaddr *addr, int addrlen)
+{
+    int r;
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	r = connect(TO_SOCKET(s), addr, addrlen);
+	if (r == SOCKET_ERROR) {
+	    int err = WSAGetLastError();
+	    if (err != WSAEWOULDBLOCK)
+		errno = map_errno(err);
+	    else
+		errno = EINPROGRESS;
+	}
+    });
+    return r;
+}
+
+
+#undef getpeername
+
+/* License: Artistic or GPL */
+int WSAAPI
+rb_w32_getpeername(int s, struct sockaddr *addr, int *addrlen)
+{
+    int r;
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	r = getpeername(TO_SOCKET(s), addr, addrlen);
+	if (r == SOCKET_ERROR)
+	    errno = map_errno(WSAGetLastError());
+    });
+    return r;
+}
+
+#undef getsockname
+
+/* License: Artistic or GPL */
+int WSAAPI
+rb_w32_getsockname(int fd, struct sockaddr *addr, int *addrlen)
+{
+    int sock;
+    int r;
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	sock = TO_SOCKET(fd);
+	r = getsockname(sock, addr, addrlen);
+	if (r == SOCKET_ERROR) {
+	    DWORD wsaerror = WSAGetLastError();
+	    if (wsaerror == WSAEINVAL) {
+		int flags;
+		if (socklist_lookup(sock, &flags)) {
+		    int af = GET_FAMILY(flags);
+		    if (af) {
+			memset(addr, 0, *addrlen);
+			addr->sa_family = af;
+			return 0;
+		    }
+		}
+	    }
+	    errno = map_errno(wsaerror);
+	}
+    });
+    return r;
+}
+
+#undef getsockopt
+
+/* License: Artistic or GPL */
+int WSAAPI
+rb_w32_getsockopt(int s, int level, int optname, char *optval, int *optlen)
+{
+    int r;
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	r = getsockopt(TO_SOCKET(s), level, optname, optval, optlen);
+	if (r == SOCKET_ERROR)
+	    errno = map_errno(WSAGetLastError());
+    });
+    return r;
+}
+
+#undef ioctlsocket
+
+/* License: Artistic or GPL */
+int WSAAPI
+rb_w32_ioctlsocket(int s, long cmd, u_long *argp)
+{
+    int r;
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	r = ioctlsocket(TO_SOCKET(s), cmd, argp);
+	if (r == SOCKET_ERROR)
+	    errno = map_errno(WSAGetLastError());
+    });
+    return r;
+}
+
+#undef listen
+
+/* License: Artistic or GPL */
+int WSAAPI
+rb_w32_listen(int s, int backlog)
+{
+    int r;
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	r = listen(TO_SOCKET(s), backlog);
+	if (r == SOCKET_ERROR)
+	    errno = map_errno(WSAGetLastError());
+    });
+    return r;
+}
+
+#undef recv
+#undef recvfrom
+#undef send
+#undef sendto
+
+/* License: Ruby's */
+static int
+finish_overlapped_socket(BOOL input, SOCKET s, WSAOVERLAPPED *wol, int result, DWORD *len, DWORD size)
+{
+    DWORD flg;
+    int err;
+
+    if (result != SOCKET_ERROR)
+	*len = size;
+    else if ((err = WSAGetLastError()) == WSA_IO_PENDING) {
+	switch (rb_w32_wait_events_blocking(&wol->hEvent, 1, INFINITE)) {
+	  case WAIT_OBJECT_0:
+	    RUBY_CRITICAL(
+		result = WSAGetOverlappedResult(s, wol, &size, TRUE, &flg)
+		);
+	    if (result) {
+		*len = size;
+		break;
+	    }
+	    /* thru */
+	  default:
+	    if ((err = WSAGetLastError()) == WSAECONNABORTED && !input)
+		errno = EPIPE;
+	    else
+		errno = map_errno(WSAGetLastError());
+	    /* thru */
+	  case WAIT_OBJECT_0 + 1:
+	    /* interrupted */
+	    *len = -1;
+	    cancel_io((HANDLE)s);
+	    break;
+	}
+    }
+    else {
+	if (err == WSAECONNABORTED && !input)
+	    errno = EPIPE;
+	else
+	    errno = map_errno(err);
+	*len = -1;
+    }
+    CloseHandle(wol->hEvent);
+
+    return result;
+}
+
+/* License: Artistic or GPL */
+static int
+overlapped_socket_io(BOOL input, int fd, char *buf, int len, int flags,
+		     struct sockaddr *addr, int *addrlen)
+{
+    int r;
+    int ret;
+    int mode = 0;
+    DWORD flg;
+    WSAOVERLAPPED wol;
+    WSABUF wbuf;
+    SOCKET s;
+
+    if (!NtSocketsInitialized)
+	StartSockets();
+
+    s = TO_SOCKET(fd);
+    socklist_lookup(s, &mode);
+    if (!cancel_io || (GET_FLAGS(mode) & O_NONBLOCK)) {
+	RUBY_CRITICAL({
+	    if (input) {
+		if (addr && addrlen)
+		    r = recvfrom(s, buf, len, flags, addr, addrlen);
+		else
+		    r = recv(s, buf, len, flags);
+		if (r == SOCKET_ERROR)
+		    errno = map_errno(WSAGetLastError());
+	    }
+	    else {
+		if (addr && addrlen)
+		    r = sendto(s, buf, len, flags, addr, *addrlen);
+		else
+		    r = send(s, buf, len, flags);
+		if (r == SOCKET_ERROR) {
+		    DWORD err = WSAGetLastError();
+		    if (err == WSAECONNABORTED)
+			errno = EPIPE;
+		    else
+			errno = map_errno(err);
+		}
+	    }
+	});
+    }
+    else {
+	DWORD size;
+	DWORD rlen;
+	wbuf.len = len;
+	wbuf.buf = buf;
+	memset(&wol, 0, sizeof(wol));
+	RUBY_CRITICAL({
+	    wol.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	    if (input) {
+		flg = flags;
+		if (addr && addrlen)
+		    ret = WSARecvFrom(s, &wbuf, 1, &size, &flg, addr, addrlen,
+				      &wol, NULL);
+		else
+		    ret = WSARecv(s, &wbuf, 1, &size, &flg, &wol, NULL);
+	    }
+	    else {
+		if (addr && addrlen)
+		    ret = WSASendTo(s, &wbuf, 1, &size, flags, addr, *addrlen,
+				    &wol, NULL);
+		else
+		    ret = WSASend(s, &wbuf, 1, &size, flags, &wol, NULL);
+	    }
+	});
+
+	finish_overlapped_socket(input, s, &wol, ret, &rlen, size);
+	r = (int)rlen;
+    }
+
+    return r;
+}
+
+/* License: Ruby's */
+int WSAAPI
+rb_w32_recv(int fd, char *buf, int len, int flags)
+{
+    return overlapped_socket_io(TRUE, fd, buf, len, flags, NULL, NULL);
+}
+
+/* License: Ruby's */
+int WSAAPI
+rb_w32_recvfrom(int fd, char *buf, int len, int flags,
+		struct sockaddr *from, int *fromlen)
+{
+    return overlapped_socket_io(TRUE, fd, buf, len, flags, from, fromlen);
+}
+
+/* License: Ruby's */
+int WSAAPI
+rb_w32_send(int fd, const char *buf, int len, int flags)
+{
+    return overlapped_socket_io(FALSE, fd, (char *)buf, len, flags, NULL, NULL);
+}
+
+/* License: Ruby's */
+int WSAAPI
+rb_w32_sendto(int fd, const char *buf, int len, int flags,
+	      const struct sockaddr *to, int tolen)
+{
+    return overlapped_socket_io(FALSE, fd, (char *)buf, len, flags,
+				(struct sockaddr *)to, &tolen);
+}
+
+#if !defined(MSG_TRUNC) && !defined(__MINGW32__)
+/* License: Ruby's */
+typedef struct {
+    SOCKADDR *name;
+    int namelen;
+    WSABUF *lpBuffers;
+    DWORD dwBufferCount;
+    WSABUF Control;
+    DWORD dwFlags;
+} WSAMSG;
+#endif
+#ifndef WSAID_WSARECVMSG
+#define WSAID_WSARECVMSG {0xf689d7c8,0x6f1f,0x436b,{0x8a,0x53,0xe5,0x4f,0xe3,0x51,0xc3,0x22}}
+#endif
+#ifndef WSAID_WSASENDMSG
+#define WSAID_WSASENDMSG {0xa441e712,0x754f,0x43ca,{0x84,0xa7,0x0d,0xee,0x44,0xcf,0x60,0x6d}}
+#endif
+
+/* License: Ruby's */
+#define msghdr_to_wsamsg(msg, wsamsg) \
+    do { \
+	int i; \
+	(wsamsg)->name = (msg)->msg_name; \
+	(wsamsg)->namelen = (msg)->msg_namelen; \
+	(wsamsg)->lpBuffers = ALLOCA_N(WSABUF, (msg)->msg_iovlen); \
+	(wsamsg)->dwBufferCount = (msg)->msg_iovlen; \
+	for (i = 0; i < (msg)->msg_iovlen; ++i) { \
+	    (wsamsg)->lpBuffers[i].buf = (msg)->msg_iov[i].iov_base; \
+	    (wsamsg)->lpBuffers[i].len = (msg)->msg_iov[i].iov_len; \
+	} \
+	(wsamsg)->Control.buf = (msg)->msg_control; \
+	(wsamsg)->Control.len = (msg)->msg_controllen; \
+	(wsamsg)->dwFlags = (msg)->msg_flags; \
+    } while (0)
+
+/* License: Ruby's */
+int
+recvmsg(int fd, struct msghdr *msg, int flags)
+{
+    typedef int (WSAAPI *WSARecvMsg_t)(SOCKET, WSAMSG *, DWORD *, WSAOVERLAPPED *, LPWSAOVERLAPPED_COMPLETION_ROUTINE);
+    static WSARecvMsg_t pWSARecvMsg = NULL;
+    WSAMSG wsamsg;
+    SOCKET s;
+    int mode = 0;
+    DWORD len;
+    int ret;
+
+    if (!NtSocketsInitialized)
+	StartSockets();
+
+    s = TO_SOCKET(fd);
+
+    if (!pWSARecvMsg) {
+	static GUID guid = WSAID_WSARECVMSG;
+	pWSARecvMsg = (WSARecvMsg_t)get_wsa_extension_function(s, &guid);
+	if (!pWSARecvMsg)
+	    return -1;
+    }
+
+    msghdr_to_wsamsg(msg, &wsamsg);
+    wsamsg.dwFlags |= flags;
+
+    socklist_lookup(s, &mode);
+    if (!cancel_io || (GET_FLAGS(mode) & O_NONBLOCK)) {
+	RUBY_CRITICAL({
+	    if ((ret = pWSARecvMsg(s, &wsamsg, &len, NULL, NULL)) == SOCKET_ERROR) {
+		errno = map_errno(WSAGetLastError());
+		len = -1;
+	    }
+	});
+    }
+    else {
+	DWORD size;
+	WSAOVERLAPPED wol;
+	memset(&wol, 0, sizeof(wol));
+	RUBY_CRITICAL({
+	    wol.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	    ret = pWSARecvMsg(s, &wsamsg, &size, &wol, NULL);
+	});
+
+	ret = finish_overlapped_socket(TRUE, s, &wol, ret, &len, size);
+    }
+    if (ret == SOCKET_ERROR)
+	return -1;
+
+    /* WSAMSG to msghdr */
+    msg->msg_name = wsamsg.name;
+    msg->msg_namelen = wsamsg.namelen;
+    msg->msg_flags = wsamsg.dwFlags;
+
+    return len;
+}
+
+/* License: Ruby's */
+int
+sendmsg(int fd, const struct msghdr *msg, int flags)
+{
+    typedef int (WSAAPI *WSASendMsg_t)(SOCKET, const WSAMSG *, DWORD, DWORD *, WSAOVERLAPPED *, LPWSAOVERLAPPED_COMPLETION_ROUTINE);
+    static WSASendMsg_t pWSASendMsg = NULL;
+    WSAMSG wsamsg;
+    SOCKET s;
+    int mode = 0;
+    DWORD len;
+    int ret;
+
+    if (!NtSocketsInitialized)
+	StartSockets();
+
+    s = TO_SOCKET(fd);
+
+    if (!pWSASendMsg) {
+	static GUID guid = WSAID_WSASENDMSG;
+	pWSASendMsg = (WSASendMsg_t)get_wsa_extension_function(s, &guid);
+	if (!pWSASendMsg)
+	    return -1;
+    }
+
+    msghdr_to_wsamsg(msg, &wsamsg);
+
+    socklist_lookup(s, &mode);
+    if (!cancel_io || (GET_FLAGS(mode) & O_NONBLOCK)) {
+	RUBY_CRITICAL({
+	    if ((ret = pWSASendMsg(s, &wsamsg, flags, &len, NULL, NULL)) == SOCKET_ERROR) {
+		errno = map_errno(WSAGetLastError());
+		len = -1;
+	    }
+	});
+    }
+    else {
+	DWORD size;
+	WSAOVERLAPPED wol;
+	memset(&wol, 0, sizeof(wol));
+	RUBY_CRITICAL({
+	    wol.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+	    ret = pWSASendMsg(s, &wsamsg, flags, &size, &wol, NULL);
+	});
+
+	finish_overlapped_socket(FALSE, s, &wol, ret, &len, size);
+    }
+
+    return len;
+}
+
+#undef setsockopt
+
+/* License: Artistic or GPL */
+int WSAAPI
+rb_w32_setsockopt(int s, int level, int optname, const char *optval, int optlen)
+{
+    int r;
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	r = setsockopt(TO_SOCKET(s), level, optname, optval, optlen);
+	if (r == SOCKET_ERROR)
+	    errno = map_errno(WSAGetLastError());
+    });
+    return r;
+}
+
+#undef shutdown
+
+/* License: Artistic or GPL */
+int WSAAPI
+rb_w32_shutdown(int s, int how)
+{
+    int r;
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	r = shutdown(TO_SOCKET(s), how);
+	if (r == SOCKET_ERROR)
+	    errno = map_errno(WSAGetLastError());
+    });
+    return r;
+}
+
+/* License: Ruby's */
+static SOCKET
+open_ifs_socket(int af, int type, int protocol)
+{
+    unsigned long proto_buffers_len = 0;
+    int error_code;
+    SOCKET out = INVALID_SOCKET;
+
+    if (WSAEnumProtocols(NULL, NULL, &proto_buffers_len) == SOCKET_ERROR) {
+	error_code = WSAGetLastError();
+	if (error_code == WSAENOBUFS) {
+	    WSAPROTOCOL_INFO *proto_buffers;
+	    int protocols_available = 0;
+
+	    proto_buffers = (WSAPROTOCOL_INFO *)malloc(proto_buffers_len);
+	    if (!proto_buffers) {
+		WSASetLastError(WSA_NOT_ENOUGH_MEMORY);
+		return INVALID_SOCKET;
+	    }
+
+	    protocols_available =
+		WSAEnumProtocols(NULL, proto_buffers, &proto_buffers_len);
+	    if (protocols_available != SOCKET_ERROR) {
+		int i;
+		for (i = 0; i < protocols_available; i++) {
+		    if ((af != AF_UNSPEC && af != proto_buffers[i].iAddressFamily) ||
+			(type != proto_buffers[i].iSocketType) ||
+			(protocol != 0 && protocol != proto_buffers[i].iProtocol))
+			continue;
+
+		    if ((proto_buffers[i].dwServiceFlags1 & XP1_IFS_HANDLES) == 0)
+			continue;
+
+		    out = WSASocket(af, type, protocol, &(proto_buffers[i]), 0,
+				    WSA_FLAG_OVERLAPPED);
+		    break;
+		}
+		if (out == INVALID_SOCKET)
+		    out = WSASocket(af, type, protocol, NULL, 0, 0);
+		if (out != INVALID_SOCKET)
+		    SetHandleInformation((HANDLE)out, HANDLE_FLAG_INHERIT, 0);
+	    }
+
+	    free(proto_buffers);
+	}
+    }
+
+    return out;
+}
+
+#undef socket
+
+/* License: Artistic or GPL */
+int WSAAPI
+rb_w32_socket(int af, int type, int protocol)
+{
+    SOCKET s;
+    int fd;
+
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	s = open_ifs_socket(af, type, protocol);
+	if (s == INVALID_SOCKET) {
+	    errno = map_errno(WSAGetLastError());
+	    fd = -1;
+	}
+	else {
+	    fd = rb_w32_open_osfhandle(s, O_RDWR|O_BINARY|O_NOINHERIT);
+	    if (fd != -1)
+		socklist_insert(s, MAKE_SOCKDATA(af, 0));
+	    else
+		closesocket(s);
+	}
+    });
+    return fd;
+}
+
+#undef gethostbyaddr
+
+/* License: Artistic or GPL */
+struct hostent * WSAAPI
+rb_w32_gethostbyaddr(const char *addr, int len, int type)
+{
+    struct hostent *r;
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	r = gethostbyaddr(addr, len, type);
+	if (r == NULL)
+	    errno = map_errno(WSAGetLastError());
+    });
+    return r;
+}
+
+#undef gethostbyname
+
+/* License: Artistic or GPL */
+struct hostent * WSAAPI
+rb_w32_gethostbyname(const char *name)
+{
+    struct hostent *r;
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	r = gethostbyname(name);
+	if (r == NULL)
+	    errno = map_errno(WSAGetLastError());
+    });
+    return r;
+}
+
+#undef gethostname
+
+/* License: Artistic or GPL */
+int WSAAPI
+rb_w32_gethostname(char *name, int len)
+{
+    int r;
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	r = gethostname(name, len);
+	if (r == SOCKET_ERROR)
+	    errno = map_errno(WSAGetLastError());
+    });
+    return r;
+}
+
+#undef getprotobyname
+
+/* License: Artistic or GPL */
+struct protoent * WSAAPI
+rb_w32_getprotobyname(const char *name)
+{
+    struct protoent *r;
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	r = getprotobyname(name);
+	if (r == NULL)
+	    errno = map_errno(WSAGetLastError());
+    });
+    return r;
+}
+
+#undef getprotobynumber
+
+/* License: Artistic or GPL */
+struct protoent * WSAAPI
+rb_w32_getprotobynumber(int num)
+{
+    struct protoent *r;
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	r = getprotobynumber(num);
+	if (r == NULL)
+	    errno = map_errno(WSAGetLastError());
+    });
+    return r;
+}
+
+#undef getservbyname
+
+/* License: Artistic or GPL */
+struct servent * WSAAPI
+rb_w32_getservbyname(const char *name, const char *proto)
+{
+    struct servent *r;
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	r = getservbyname(name, proto);
+	if (r == NULL)
+	    errno = map_errno(WSAGetLastError());
+    });
+    return r;
+}
+
+#undef getservbyport
+
+/* License: Artistic or GPL */
+struct servent * WSAAPI
+rb_w32_getservbyport(int port, const char *proto)
+{
+    struct servent *r;
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+    RUBY_CRITICAL({
+	r = getservbyport(port, proto);
+	if (r == NULL)
+	    errno = map_errno(WSAGetLastError());
+    });
+    return r;
+}
+
+/* License: Ruby's */
+static int
+socketpair_internal(int af, int type, int protocol, SOCKET *sv)
+{
+    SOCKET svr = INVALID_SOCKET, r = INVALID_SOCKET, w = INVALID_SOCKET;
+    struct sockaddr_in sock_in4;
+#ifdef INET6
+    struct sockaddr_in6 sock_in6;
+#endif
+    struct sockaddr *addr;
+    int ret = -1;
+    int len;
+
+    if (!NtSocketsInitialized) {
+	StartSockets();
+    }
+
+    switch (af) {
+      case AF_INET:
+#if defined PF_INET && PF_INET != AF_INET
+      case PF_INET:
+#endif
+	sock_in4.sin_family = AF_INET;
+	sock_in4.sin_port = 0;
+	sock_in4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+	addr = (struct sockaddr *)&sock_in4;
+	len = sizeof(sock_in4);
+	break;
+#ifdef INET6
+      case AF_INET6:
+	memset(&sock_in6, 0, sizeof(sock_in6));
+	sock_in6.sin6_family = AF_INET6;
+	sock_in6.sin6_addr = IN6ADDR_LOOPBACK_INIT;
+	addr = (struct sockaddr *)&sock_in6;
+	len = sizeof(sock_in6);
+	break;
+#endif
+      default:
+	errno = EAFNOSUPPORT;
+	return -1;
+    }
+    if (type != SOCK_STREAM) {
+	errno = EPROTOTYPE;
+	return -1;
+    }
+
+    sv[0] = (SOCKET)INVALID_HANDLE_VALUE;
+    sv[1] = (SOCKET)INVALID_HANDLE_VALUE;
+    RUBY_CRITICAL({
+	do {
+	    svr = open_ifs_socket(af, type, protocol);
+	    if (svr == INVALID_SOCKET)
+		break;
+	    if (bind(svr, addr, len) < 0)
+		break;
+	    if (getsockname(svr, addr, &len) < 0)
+		break;
+	    if (type == SOCK_STREAM)
+		listen(svr, 5);
+
+	    w = open_ifs_socket(af, type, protocol);
+	    if (w == INVALID_SOCKET)
+		break;
+	    if (connect(w, addr, len) < 0)
+		break;
+
+	    r = accept(svr, addr, &len);
+	    if (r == INVALID_SOCKET)
+		break;
+	    SetHandleInformation((HANDLE)r, HANDLE_FLAG_INHERIT, 0);
+
+	    ret = 0;
+	} while (0);
+
+	if (ret < 0) {
+	    errno = map_errno(WSAGetLastError());
+	    if (r != INVALID_SOCKET)
+		closesocket(r);
+	    if (w != INVALID_SOCKET)
+		closesocket(w);
+	}
+	else {
+	    sv[0] = r;
+	    sv[1] = w;
+	}
+	if (svr != INVALID_SOCKET)
+	    closesocket(svr);
+    });
+
+    return ret;
+}
+
+/* License: Ruby's */
+int
+socketpair(int af, int type, int protocol, int *sv)
+{
+    SOCKET pair[2];
+
+    if (socketpair_internal(af, type, protocol, pair) < 0)
+	return -1;
+    sv[0] = rb_w32_open_osfhandle(pair[0], O_RDWR|O_BINARY|O_NOINHERIT);
+    if (sv[0] == -1) {
+	closesocket(pair[0]);
+	closesocket(pair[1]);
+	return -1;
+    }
+    sv[1] = rb_w32_open_osfhandle(pair[1], O_RDWR|O_BINARY|O_NOINHERIT);
+    if (sv[1] == -1) {
+	rb_w32_close(sv[0]);
+	closesocket(pair[1]);
+	return -1;
+    }
+    socklist_insert(pair[0], MAKE_SOCKDATA(af, 0));
+    socklist_insert(pair[1], MAKE_SOCKDATA(af, 0));
+
+    return 0;
+}
+
+#if !defined(_MSC_VER) || _MSC_VER >= 1400
+/* License: Ruby's */
+static void
+str2guid(const char *str, GUID *guid)
+{
+#define hex2byte(str) \
+    ((isdigit(*(str)) ? *(str) - '0' : toupper(*(str)) - 'A' + 10) << 4 | (isdigit(*((str) + 1)) ? *((str) + 1) - '0' : toupper(*((str) + 1)) - 'A' + 10))
+    char *end;
+    int i;
+    if (*str == '{') str++;
+    guid->Data1 = (long)strtoul(str, &end, 16);
+    str += 9;
+    guid->Data2 = (unsigned short)strtoul(str, &end, 16);
+    str += 5;
+    guid->Data3 = (unsigned short)strtoul(str, &end, 16);
+    str += 5;
+    guid->Data4[0] = hex2byte(str);
+    str += 2;
+    guid->Data4[1] = hex2byte(str);
+    str += 3;
+    for (i = 0; i < 6; i++) {
+	guid->Data4[i + 2] = hex2byte(str);
+	str += 2;
+    }
+}
+
+/* License: Ruby's */
+#ifndef HAVE_TYPE_NET_LUID
+    typedef struct {
+	uint64_t Value;
+	struct {
+	    uint64_t Reserved :24;
+	    uint64_t NetLuidIndex :24;
+	    uint64_t IfType :16;
+	} Info;
+    } NET_LUID;
+#endif
+typedef DWORD (WINAPI *cigl_t)(const GUID *, NET_LUID *);
+typedef DWORD (WINAPI *cilnA_t)(const NET_LUID *, char *, size_t);
+static cigl_t pConvertInterfaceGuidToLuid = NULL;
+static cilnA_t pConvertInterfaceLuidToNameA = NULL;
+
+int
+getifaddrs(struct ifaddrs **ifap)
+{
+    ULONG size = 0;
+    ULONG ret;
+    IP_ADAPTER_ADDRESSES *root, *addr;
+    struct ifaddrs *prev;
+
+    ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &size);
+    if (ret != ERROR_BUFFER_OVERFLOW) {
+	errno = map_errno(ret);
+	return -1;
+    }
+    root = ruby_xmalloc(size);
+    ret = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, root, &size);
+    if (ret != ERROR_SUCCESS) {
+	errno = map_errno(ret);
+	ruby_xfree(root);
+	return -1;
+    }
+
+    if (!pConvertInterfaceGuidToLuid)
+	pConvertInterfaceGuidToLuid =
+	    (cigl_t)get_proc_address("iphlpapi.dll",
+				     "ConvertInterfaceGuidToLuid", NULL);
+    if (!pConvertInterfaceLuidToNameA)
+	pConvertInterfaceLuidToNameA =
+	    (cilnA_t)get_proc_address("iphlpapi.dll",
+				      "ConvertInterfaceLuidToNameA", NULL);
+
+    for (prev = NULL, addr = root; addr; addr = addr->Next) {
+	struct ifaddrs *ifa = ruby_xcalloc(1, sizeof(*ifa));
+	char name[IFNAMSIZ];
+	GUID guid;
+	NET_LUID luid;
+
+	if (prev)
+	    prev->ifa_next = ifa;
+	else
+	    *ifap = ifa;
+
+	str2guid(addr->AdapterName, &guid);
+	if (pConvertInterfaceGuidToLuid && pConvertInterfaceLuidToNameA &&
+	    pConvertInterfaceGuidToLuid(&guid, &luid) == NO_ERROR &&
+	    pConvertInterfaceLuidToNameA(&luid, name, sizeof(name)) == NO_ERROR) {
+	    ifa->ifa_name = ruby_xmalloc(lstrlen(name) + 1);
+	    lstrcpy(ifa->ifa_name, name);
+	}
+	else {
+	    ifa->ifa_name = ruby_xmalloc(lstrlen(addr->AdapterName) + 1);
+	    lstrcpy(ifa->ifa_name, addr->AdapterName);
+	}
+
+	if (addr->IfType & IF_TYPE_SOFTWARE_LOOPBACK)
+	    ifa->ifa_flags |= IFF_LOOPBACK;
+	if (addr->OperStatus == IfOperStatusUp) {
+	    ifa->ifa_flags |= IFF_UP;
+
+	    if (addr->FirstUnicastAddress) {
+		IP_ADAPTER_UNICAST_ADDRESS *cur;
+		int added = 0;
+		for (cur = addr->FirstUnicastAddress; cur; cur = cur->Next) {
+		    if (cur->Flags & IP_ADAPTER_ADDRESS_TRANSIENT ||
+			cur->DadState == IpDadStateDeprecated) {
+			continue;
+		    }
+		    if (added) {
+			prev = ifa;
+			ifa = ruby_xcalloc(1, sizeof(*ifa));
+			prev->ifa_next = ifa;
+			ifa->ifa_name =
+			    ruby_xmalloc(lstrlen(prev->ifa_name) + 1);
+			lstrcpy(ifa->ifa_name, prev->ifa_name);
+			ifa->ifa_flags = prev->ifa_flags;
+		    }
+		    ifa->ifa_addr = ruby_xmalloc(cur->Address.iSockaddrLength);
+		    memcpy(ifa->ifa_addr, cur->Address.lpSockaddr,
+			   cur->Address.iSockaddrLength);
+		    added = 1;
+		}
+	    }
+	}
+
+	prev = ifa;
+    }
+
+    ruby_xfree(root);
+    return 0;
+}
+
+/* License: Ruby's */
+void
+freeifaddrs(struct ifaddrs *ifp)
+{
+    while (ifp) {
+	struct ifaddrs *next = ifp->ifa_next;
+	if (ifp->ifa_addr) ruby_xfree(ifp->ifa_addr);
+	if (ifp->ifa_name) ruby_xfree(ifp->ifa_name);
+	ruby_xfree(ifp);
+	ifp = next;
+    }
+}
+#endif
+
+//
+// Networking stubs
+//
+
+void endhostent(void) {}
+void endnetent(void) {}
+void endprotoent(void) {}
+void endservent(void) {}
+
+struct netent *getnetent (void) {return (struct netent *) NULL;}
+
+struct netent *getnetbyaddr(long net, int type) {return (struct netent *)NULL;}
+
+struct netent *getnetbyname(const char *name) {return (struct netent *)NULL;}
+
+struct protoent *getprotoent (void) {return (struct protoent *) NULL;}
+
+struct servent *getservent (void) {return (struct servent *) NULL;}
+
+void sethostent (int stayopen) {}
+
+void setnetent (int stayopen) {}
+
+void setprotoent (int stayopen) {}
+
+void setservent (int stayopen) {}
+
+/* License: Ruby's */
+static int
+setfl(SOCKET sock, int arg)
+{
+    int ret;
+    int af = 0;
+    int flag = 0;
+    u_long ioctlArg;
+
+    socklist_lookup(sock, &flag);
+    af = GET_FAMILY(flag);
+    flag = GET_FLAGS(flag);
+    if (arg & O_NONBLOCK) {
+	flag |= O_NONBLOCK;
+	ioctlArg = 1;
+    }
+    else {
+	flag &= ~O_NONBLOCK;
+	ioctlArg = 0;
+    }
+    RUBY_CRITICAL({
+	ret = ioctlsocket(sock, FIONBIO, &ioctlArg);
+	if (ret == 0)
+	    socklist_insert(sock, MAKE_SOCKDATA(af, flag));
+	else
+	    errno = map_errno(WSAGetLastError());
+    });
+
+    return ret;
+}
+
+/* License: Ruby's */
+static int
+dupfd(HANDLE hDup, char flags, int minfd)
+{
+    int save_errno;
+    int ret;
+    int fds[32];
+    int filled = 0;
+
+    do {
+	ret = _open_osfhandle((intptr_t)hDup, flags | FOPEN);
+	if (ret == -1) {
+	    goto close_fds_and_return;
+	}
+	if (ret >= minfd) {
+	    goto close_fds_and_return;
+	}
+	fds[filled++] = ret;
+    } while (filled < (int)numberof(fds));
+
+    ret = dupfd(hDup, flags, minfd);
+
+  close_fds_and_return:
+    save_errno = errno;
+    while (filled > 0) {
+	int fd = fds[--filled];
+	_osfhnd(fd) = (intptr_t)INVALID_HANDLE_VALUE;
+	close(fd);
+    }
+    errno = save_errno;
+
+    return ret;
+}
+
+/* License: Ruby's */
+int
+fcntl(int fd, int cmd, ...)
+{
+    va_list va;
+    int arg;
+
+    if (cmd == F_SETFL) {
+	SOCKET sock = TO_SOCKET(fd);
+	if (!is_socket(sock)) {
+	    errno = EBADF;
+	    return -1;
+	}
+
+	va_start(va, cmd);
+	arg = va_arg(va, int);
+	va_end(va);
+	return setfl(sock, arg);
+    }
+    else if (cmd == F_DUPFD) {
+	int ret;
+	HANDLE hDup;
+	if (!(DuplicateHandle(GetCurrentProcess(), (HANDLE)_get_osfhandle(fd),
+			      GetCurrentProcess(), &hDup, 0L,
+			      !(_osfile(fd) & FNOINHERIT),
+			      DUPLICATE_SAME_ACCESS))) {
+	    errno = map_errno(GetLastError());
+	    return -1;
+	}
+
+	va_start(va, cmd);
+	arg = va_arg(va, int);
+	va_end(va);
+
+	if ((ret = dupfd(hDup, _osfile(fd), arg)) == -1)
+	    CloseHandle(hDup);
+	return ret;
+    }
+    else {
+	errno = EINVAL;
+	return -1;
+    }
+}
+
+/* License: Ruby's */
+int
+rb_w32_set_nonblock(int fd)
+{
+    SOCKET sock = TO_SOCKET(fd);
+    if (is_socket(sock)) {
+	return setfl(sock, O_NONBLOCK);
+    }
+    else if (is_pipe(sock)) {
+	DWORD state;
+	if (!GetNamedPipeHandleState((HANDLE)sock, &state, NULL, NULL, NULL, NULL, 0)) {
+	    errno = map_errno(GetLastError());
+	    return -1;
+	}
+	state |= PIPE_NOWAIT;
+	if (!SetNamedPipeHandleState((HANDLE)sock, &state, NULL, NULL)) {
+	    errno = map_errno(GetLastError());
+	    return -1;
+	}
+	return 0;
+    }
+    else {
+	errno = EBADF;
+	return -1;
+    }
+}
+
+#ifndef WNOHANG
+#define WNOHANG -1
+#endif
+
+/* License: Ruby's */
+static rb_pid_t
+poll_child_status(struct ChildRecord *child, int *stat_loc)
+{
+    DWORD exitcode;
+    DWORD err;
+
+    if (!GetExitCodeProcess(child->hProcess, &exitcode)) {
+	/* If an error occurred, return immediately. */
+    error_exit:
+	err = GetLastError();
+	switch (err) {
+	  case ERROR_INVALID_PARAMETER:
+	    errno = ECHILD;
+	    break;
+	  case ERROR_INVALID_HANDLE:
+	    errno = EINVAL;
+	    break;
+	  default:
+	    errno = map_errno(err);
+	    break;
+	}
+	CloseChildHandle(child);
+	return -1;
+    }
+    if (exitcode != STILL_ACTIVE) {
+        rb_pid_t pid;
+	/* If already died, wait process's real termination. */
+        if (rb_w32_wait_events_blocking(&child->hProcess, 1, INFINITE) != WAIT_OBJECT_0) {
+	    goto error_exit;
+        }
+	pid = child->pid;
+	CloseChildHandle(child);
+	if (stat_loc) {
+	    *stat_loc = exitcode << 8;
+	    if (exitcode & 0xC0000000) {
+		static const struct {
+		    DWORD status;
+		    int sig;
+		} table[] = {
+		    {STATUS_ACCESS_VIOLATION,        SIGSEGV},
+		    {STATUS_ILLEGAL_INSTRUCTION,     SIGILL},
+		    {STATUS_PRIVILEGED_INSTRUCTION,  SIGILL},
+		    {STATUS_FLOAT_DENORMAL_OPERAND,  SIGFPE},
+		    {STATUS_FLOAT_DIVIDE_BY_ZERO,    SIGFPE},
+		    {STATUS_FLOAT_INEXACT_RESULT,    SIGFPE},
+		    {STATUS_FLOAT_INVALID_OPERATION, SIGFPE},
+		    {STATUS_FLOAT_OVERFLOW,          SIGFPE},
+		    {STATUS_FLOAT_STACK_CHECK,       SIGFPE},
+		    {STATUS_FLOAT_UNDERFLOW,         SIGFPE},
+#ifdef STATUS_FLOAT_MULTIPLE_FAULTS
+		    {STATUS_FLOAT_MULTIPLE_FAULTS,   SIGFPE},
+#endif
+#ifdef STATUS_FLOAT_MULTIPLE_TRAPS
+		    {STATUS_FLOAT_MULTIPLE_TRAPS,    SIGFPE},
+#endif
+		    {STATUS_CONTROL_C_EXIT,          SIGINT},
+		};
+		int i;
+		for (i = 0; i < (int)numberof(table); i++) {
+		    if (table[i].status == exitcode) {
+			*stat_loc |= table[i].sig;
+			break;
+		    }
+		}
+		// if unknown status, assume SEGV
+		if (i >= (int)numberof(table))
+		    *stat_loc |= SIGSEGV;
+	    }
+	}
+	return pid;
+    }
+    return 0;
+}
+
+/* License: Artistic or GPL */
+rb_pid_t
+waitpid(rb_pid_t pid, int *stat_loc, int options)
+{
+    DWORD timeout;
+
+    /* Artistic or GPL part start */
+    if (options == WNOHANG) {
+	timeout = 0;
+    }
+    else {
+	timeout = INFINITE;
+    }
+    /* Artistic or GPL part end */
+
+    if (pid == -1) {
+	int count = 0;
+	int ret;
+	HANDLE events[MAXCHILDNUM];
+	struct ChildRecord* cause;
+
+	FOREACH_CHILD(child) {
+	    if (!child->pid || child->pid < 0) continue;
+	    if ((pid = poll_child_status(child, stat_loc))) return pid;
+	    events[count++] = child->hProcess;
+	} END_FOREACH_CHILD;
+	if (!count) {
+	    errno = ECHILD;
+	    return -1;
+	}
+
+	ret = rb_w32_wait_events_blocking(events, count, timeout);
+	if (ret == WAIT_TIMEOUT) return 0;
+	if ((ret -= WAIT_OBJECT_0) == count) {
+	    return -1;
+	}
+	if (ret > count) {
+	    errno = map_errno(GetLastError());
+	    return -1;
+	}
+
+	cause = FindChildSlotByHandle(events[ret]);
+	if (!cause) {
+	    errno = ECHILD;
+	    return -1;
+	}
+	return poll_child_status(cause, stat_loc);
+    }
+    else {
+	struct ChildRecord* child = FindChildSlot(pid);
+	int retried = 0;
+	if (!child) {
+	    errno = ECHILD;
+	    return -1;
+	}
+
+	while (!(pid = poll_child_status(child, stat_loc))) {
+	    /* wait... */
+	    int ret = rb_w32_wait_events_blocking(&child->hProcess, 1, timeout);
+	    if (ret == WAIT_OBJECT_0 + 1) return -1; /* maybe EINTR */
+	    if (ret != WAIT_OBJECT_0) {
+		/* still active */
+		if (options & WNOHANG) {
+		    pid = 0;
+		    break;
+		}
+		++retried;
+	    }
+	}
+	if (pid == -1 && retried) pid = 0;
+    }
+
+    return pid;
+}
+
+#include <sys/timeb.h>
+
+/* License: Ruby's */
+static int
+filetime_to_timeval(const FILETIME* ft, struct timeval *tv)
+{
+    ULARGE_INTEGER tmp;
+    unsigned LONG_LONG lt;
+
+    tmp.LowPart = ft->dwLowDateTime;
+    tmp.HighPart = ft->dwHighDateTime;
+    lt = tmp.QuadPart;
+
+    /* lt is now 100-nanosec intervals since 1601/01/01 00:00:00 UTC,
+       convert it into UNIX time (since 1970/01/01 00:00:00 UTC).
+       the first leap second is at 1972/06/30, so we doesn't need to think
+       about it. */
+    lt /= 10;	/* to usec */
+    lt -= (LONG_LONG)((1970-1601)*365.2425) * 24 * 60 * 60 * 1000 * 1000;
+
+    tv->tv_sec = (long)(lt / (1000 * 1000));
+    tv->tv_usec = (long)(lt % (1000 * 1000));
+
+    return tv->tv_sec > 0 ? 0 : -1;
+}
+
+/* License: Ruby's */
+int __cdecl
+gettimeofday(struct timeval *tv, struct timezone *tz)
+{
+    FILETIME ft;
+
+    GetSystemTimeAsFileTime(&ft);
+    filetime_to_timeval(&ft, tv);
+
+    return 0;
+}
+
+/* License: Ruby's */
+int
+clock_gettime(clockid_t clock_id, struct timespec *sp)
+{
+    switch (clock_id) {
+      case CLOCK_REALTIME:
+	{
+	    struct timeval tv;
+	    gettimeofday(&tv, NULL);
+	    sp->tv_sec = tv.tv_sec;
+	    sp->tv_nsec = tv.tv_usec * 1000;
+	    return 0;
+	}
+      case CLOCK_MONOTONIC:
+	{
+	    LARGE_INTEGER freq;
+	    LARGE_INTEGER count;
+	    if (!QueryPerformanceFrequency(&freq)) {
+		errno = map_errno(GetLastError());
+		return -1;
+	    }
+	    if (!QueryPerformanceCounter(&count)) {
+		errno = map_errno(GetLastError());
+		return -1;
+	    }
+	    sp->tv_sec = count.QuadPart / freq.QuadPart;
+	    if (freq.QuadPart < 1000000000)
+		sp->tv_nsec = (count.QuadPart % freq.QuadPart) * 1000000000 / freq.QuadPart;
+	    else
+		sp->tv_nsec = (long)((count.QuadPart % freq.QuadPart) * (1000000000.0 / freq.QuadPart));
+	    return 0;
+	}
+      default:
+	errno = EINVAL;
+	return -1;
+    }
+}
+
+/* License: Ruby's */
+int
+clock_getres(clockid_t clock_id, struct timespec *sp)
+{
+    switch (clock_id) {
+      case CLOCK_REALTIME:
+	{
+	    sp->tv_sec = 0;
+	    sp->tv_nsec = 1000;
+	    return 0;
+	}
+      case CLOCK_MONOTONIC:
+	{
+	    LARGE_INTEGER freq;
+	    if (!QueryPerformanceFrequency(&freq)) {
+		errno = map_errno(GetLastError());
+		return -1;
+	    }
+	    sp->tv_sec = 0;
+	    sp->tv_nsec = (long)(1000000000.0 / freq.QuadPart);
+	    return 0;
+	}
+      default:
+	errno = EINVAL;
+	return -1;
+    }
+}
+
+/* License: Ruby's */
+char *
+rb_w32_getcwd(char *buffer, int size)
+{
+    char *p = buffer;
+    int len;
+
+    len = GetCurrentDirectory(0, NULL);
+    if (!len) {
+	errno = map_errno(GetLastError());
+	return NULL;
+    }
+
+    if (p) {
+	if (size < len) {
+	    errno = ERANGE;
+	    return NULL;
+	}
+    }
+    else {
+	p = malloc(len);
+	size = len;
+	if (!p) {
+	    errno = ENOMEM;
+	    return NULL;
+	}
+    }
+
+    if (!GetCurrentDirectory(size, p)) {
+	errno = map_errno(GetLastError());
+	if (!buffer)
+	    free(p);
+        return NULL;
+    }
+
+    translate_char(p, '\\', '/', filecp());
+
+    return p;
+}
+
+/* License: Artistic or GPL */
+int
+chown(const char *path, int owner, int group)
+{
+    return 0;
+}
+
+/* License: Artistic or GPL */
+int
+rb_w32_uchown(const char *path, int owner, int group)
+{
+    return 0;
+}
+
+/* License: Ruby's */
+int
+kill(int pid, int sig)
+{
+    int ret = 0;
+    DWORD err;
+
+    if (pid < 0 || (pid == 0 && sig != SIGINT)) {
+	errno = EINVAL;
+	return -1;
+    }
+
+    if ((unsigned int)pid == GetCurrentProcessId() &&
+	(sig != 0 && sig != SIGKILL)) {
+	if ((ret = raise(sig)) != 0) {
+	    /* MSVCRT doesn't set errno... */
+	    errno = EINVAL;
+	}
+	return ret;
+    }
+
+    switch (sig) {
+      case 0:
+	RUBY_CRITICAL({
+	    HANDLE hProc =
+		OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, (DWORD)pid);
+	    if (hProc == NULL || hProc == INVALID_HANDLE_VALUE) {
+		if (GetLastError() == ERROR_INVALID_PARAMETER) {
+		    errno = ESRCH;
+		}
+		else {
+		    errno = EPERM;
+		}
+		ret = -1;
+	    }
+	    else {
+		CloseHandle(hProc);
+	    }
+	});
+	break;
+
+      case SIGINT:
+	RUBY_CRITICAL({
+	    DWORD ctrlEvent = CTRL_C_EVENT;
+	    if (pid != 0) {
+	        /* CTRL+C signal cannot be generated for process groups.
+		 * Instead, we use CTRL+BREAK signal. */
+	        ctrlEvent = CTRL_BREAK_EVENT;
+	    }
+	    if (!GenerateConsoleCtrlEvent(ctrlEvent, (DWORD)pid)) {
+		if ((err = GetLastError()) == 0)
+		    errno = EPERM;
+		else
+		    errno = map_errno(GetLastError());
+		ret = -1;
+	    }
+	});
+	break;
+
+      case SIGKILL:
+	RUBY_CRITICAL({
+	    HANDLE hProc;
+	    struct ChildRecord* child = FindChildSlot(pid);
+	    if (child) {
+		hProc = child->hProcess;
+	    }
+	    else {
+		hProc = OpenProcess(PROCESS_TERMINATE | PROCESS_QUERY_INFORMATION, FALSE, (DWORD)pid);
+	    }
+	    if (hProc == NULL || hProc == INVALID_HANDLE_VALUE) {
+		if (GetLastError() == ERROR_INVALID_PARAMETER) {
+		    errno = ESRCH;
+		}
+		else {
+		    errno = EPERM;
+		}
+		ret = -1;
+	    }
+	    else {
+		DWORD status;
+		if (!GetExitCodeProcess(hProc, &status)) {
+		    errno = map_errno(GetLastError());
+		    ret = -1;
+		}
+		else if (status == STILL_ACTIVE) {
+		    if (!TerminateProcess(hProc, 0)) {
+			errno = EPERM;
+			ret = -1;
+		    }
+		}
+		else {
+		    errno = ESRCH;
+		    ret = -1;
+		}
+		if (!child) {
+		    CloseHandle(hProc);
+		}
+	    }
+	});
+	break;
+
+      default:
+	errno = EINVAL;
+	ret = -1;
+	break;
+    }
+
+    return ret;
+}
+
+/* License: Ruby's */
+static int
+wlink(const WCHAR *from, const WCHAR *to)
+{
+    typedef BOOL (WINAPI link_func)(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES);
+    static link_func *pCreateHardLinkW = NULL;
+    static int myerrno = 0;
+
+    if (!pCreateHardLinkW && !myerrno) {
+	pCreateHardLinkW = (link_func *)get_proc_address("kernel32", "CreateHardLinkW", NULL);
+	if (!pCreateHardLinkW)
+	    myerrno = ENOSYS;
+    }
+    if (!pCreateHardLinkW) {
+	errno = myerrno;
+	return -1;
+    }
+
+    if (!pCreateHardLinkW(to, from, NULL)) {
+	errno = map_errno(GetLastError());
+	return -1;
+    }
+
+    return 0;
+}
+
+/* License: Ruby's */
+int
+rb_w32_ulink(const char *from, const char *to)
+{
+    WCHAR *wfrom;
+    WCHAR *wto;
+    int ret;
+
+    if (!(wfrom = utf8_to_wstr(from, NULL)))
+	return -1;
+    if (!(wto = utf8_to_wstr(to, NULL))) {
+	free(wfrom);
+	return -1;
+    }
+    ret = wlink(wfrom, wto);
+    free(wto);
+    free(wfrom);
+    return ret;
+}
+
+/* License: Ruby's */
+int
+link(const char *from, const char *to)
+{
+    WCHAR *wfrom;
+    WCHAR *wto;
+    int ret;
+
+    if (!(wfrom = filecp_to_wstr(from, NULL)))
+	return -1;
+    if (!(wto = filecp_to_wstr(to, NULL))) {
+	free(wfrom);
+	return -1;
+    }
+    ret = wlink(wfrom, wto);
+    free(wto);
+    free(wfrom);
+    return ret;
+}
+
+/* License: Ruby's */
+int
+wait(int *status)
+{
+    return waitpid(-1, status, 0);
+}
+
+/* License: Ruby's */
+static char *
+w32_getenv(const char *name, UINT cp)
+{
+    WCHAR *wenvarea, *wenv;
+    int len = strlen(name);
+    char *env;
+    int wlen;
+
+    if (len == 0) return NULL;
+
+    if (uenvarea) {
+	free(uenvarea);
+	uenvarea = NULL;
+    }
+    wenvarea = GetEnvironmentStringsW();
+    if (!wenvarea) {
+	map_errno(GetLastError());
+	return NULL;
+    }
+    for (wenv = wenvarea, wlen = 1; *wenv; wenv += lstrlenW(wenv) + 1)
+	wlen += lstrlenW(wenv) + 1;
+    uenvarea = wstr_to_mbstr(cp, wenvarea, wlen, NULL);
+    FreeEnvironmentStringsW(wenvarea);
+    if (!uenvarea)
+	return NULL;
+
+    for (env = uenvarea; *env; env += strlen(env) + 1)
+	if (strncasecmp(env, name, len) == 0 && *(env + len) == '=')
+	    return env + len + 1;
+
+    return NULL;
+}
+
+/* License: Ruby's */
+char *
+rb_w32_ugetenv(const char *name)
+{
+    return w32_getenv(name, CP_UTF8);
+}
+
+/* License: Ruby's */
+char *
+rb_w32_getenv(const char *name)
+{
+    return w32_getenv(name, CP_ACP);
+}
+
+/* License: Ruby's */
+static DWORD
+get_volume_serial_number(const WCHAR *path)
+{
+    const DWORD share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE;
+    const DWORD creation = OPEN_EXISTING;
+    const DWORD flags = FILE_FLAG_BACKUP_SEMANTICS;
+    BY_HANDLE_FILE_INFORMATION st = {0};
+    HANDLE h = CreateFileW(path, 0, share_mode, NULL, creation, flags, NULL);
+    BOOL ret;
+
+    if (h == INVALID_HANDLE_VALUE) return 0;
+    ret = GetFileInformationByHandle(h, &st);
+    CloseHandle(h);
+    if (!ret) return 0;
+    return st.dwVolumeSerialNumber;
+}
+
+/* License: Ruby's */
+static int
+different_device_p(const WCHAR *oldpath, const WCHAR *newpath)
+{
+    return get_volume_serial_number(oldpath) != get_volume_serial_number(newpath);
+}
+
+/* License: Artistic or GPL */
+static int
+wrename(const WCHAR *oldpath, const WCHAR *newpath)
+{
+    int res = 0;
+    int oldatts;
+    int newatts;
+
+    oldatts = GetFileAttributesW(oldpath);
+    newatts = GetFileAttributesW(newpath);
+
+    if (oldatts == -1) {
+	errno = map_errno(GetLastError());
+	return -1;
+    }
+
+    RUBY_CRITICAL({
+	if (newatts != -1 && newatts & FILE_ATTRIBUTE_READONLY)
+	    SetFileAttributesW(newpath, newatts & ~ FILE_ATTRIBUTE_READONLY);
+
+	if (!MoveFileExW(oldpath, newpath, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED))
+	    res = -1;
+
+	if (res) {
+	    DWORD e = GetLastError();
+	    if ((e == ERROR_ACCESS_DENIED) && (oldatts & FILE_ATTRIBUTE_DIRECTORY) &&
+		different_device_p(oldpath, newpath))
+		errno = EXDEV;
+	    else
+		errno = map_errno(e);
+	}
+	else
+	    SetFileAttributesW(newpath, oldatts);
+    });
+
+    return res;
+}
+
+/* License: Ruby's */
+int rb_w32_urename(const char *from, const char *to)
+{
+    WCHAR *wfrom;
+    WCHAR *wto;
+    int ret = -1;
+
+    if (!(wfrom = utf8_to_wstr(from, NULL)))
+	return -1;
+    if (!(wto = utf8_to_wstr(to, NULL))) {
+	free(wfrom);
+	return -1;
+    }
+    ret = wrename(wfrom, wto);
+    free(wto);
+    free(wfrom);
+    return ret;
+}
+
+/* License: Ruby's */
+int rb_w32_rename(const char *from, const char *to)
+{
+    WCHAR *wfrom;
+    WCHAR *wto;
+    int ret = -1;
+
+    if (!(wfrom = filecp_to_wstr(from, NULL)))
+	return -1;
+    if (!(wto = filecp_to_wstr(to, NULL))) {
+	free(wfrom);
+	return -1;
+    }
+    ret = wrename(wfrom, wto);
+    free(wto);
+    free(wfrom);
+    return ret;
+}
+
+/* License: Ruby's */
+static int
+isUNCRoot(const WCHAR *path)
+{
+    if (path[0] == L'\\' && path[1] == L'\\') {
+	const WCHAR *p = path + 2;
+	if (p[0] == L'?' && p[1] == L'\\') {
+	    p += 2;
+	}
+	for (; *p; p++) {
+	    if (*p == L'\\')
+		break;
+	}
+	if (p[0] && p[1]) {
+	    for (p++; *p; p++) {
+		if (*p == L'\\')
+		    break;
+	    }
+	    if (!p[0] || !p[1] || (p[1] == L'.' && !p[2]))
+		return 1;
+	}
+    }
+    return 0;
+}
+
+#define COPY_STAT(src, dest, size_cast) do {	\
+	(dest).st_dev 	= (src).st_dev;		\
+	(dest).st_ino 	= (src).st_ino;		\
+	(dest).st_mode  = (src).st_mode;	\
+	(dest).st_nlink = (src).st_nlink;	\
+	(dest).st_uid   = (src).st_uid;		\
+	(dest).st_gid   = (src).st_gid;		\
+	(dest).st_rdev 	= (src).st_rdev;	\
+	(dest).st_size 	= size_cast(src).st_size; \
+	(dest).st_atime = (src).st_atime;	\
+	(dest).st_mtime = (src).st_mtime;	\
+	(dest).st_ctime = (src).st_ctime;	\
+    } while (0)
+
+static time_t filetime_to_unixtime(const FILETIME *ft);
+
+#undef fstat
+/* License: Ruby's */
+int
+rb_w32_fstat(int fd, struct stat *st)
+{
+    BY_HANDLE_FILE_INFORMATION info;
+    int ret = fstat(fd, st);
+
+    if (ret) return ret;
+#ifdef __BORLANDC__
+    st->st_mode &= ~(S_IWGRP | S_IWOTH);
+#else
+    if (GetEnvironmentVariableW(L"TZ", NULL, 0) == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND) return ret;
+#endif
+    if (GetFileInformationByHandle((HANDLE)_get_osfhandle(fd), &info)) {
+#ifdef __BORLANDC__
+	if (!(info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) {
+	    st->st_mode |= S_IWUSR;
+	}
+#endif
+	st->st_atime = filetime_to_unixtime(&info.ftLastAccessTime);
+	st->st_mtime = filetime_to_unixtime(&info.ftLastWriteTime);
+	st->st_ctime = filetime_to_unixtime(&info.ftCreationTime);
+    }
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_fstati64(int fd, struct stati64 *st)
+{
+    BY_HANDLE_FILE_INFORMATION info;
+    struct stat tmp;
+    int ret;
+
+#ifndef __BORLANDC__
+    if (GetEnvironmentVariableW(L"TZ", NULL, 0) == 0 && GetLastError() == ERROR_ENVVAR_NOT_FOUND) return _fstati64(fd, st);
+#endif
+    ret = fstat(fd, &tmp);
+
+    if (ret) return ret;
+#ifdef __BORLANDC__
+    tmp.st_mode &= ~(S_IWGRP | S_IWOTH);
+#endif
+    COPY_STAT(tmp, *st, +);
+    if (GetFileInformationByHandle((HANDLE)_get_osfhandle(fd), &info)) {
+#ifdef __BORLANDC__
+	if (!(info.dwFileAttributes & FILE_ATTRIBUTE_READONLY)) {
+	    st->st_mode |= S_IWUSR;
+	}
+#endif
+	st->st_size = ((__int64)info.nFileSizeHigh << 32) | info.nFileSizeLow;
+	st->st_atime = filetime_to_unixtime(&info.ftLastAccessTime);
+	st->st_mtime = filetime_to_unixtime(&info.ftLastWriteTime);
+	st->st_ctime = filetime_to_unixtime(&info.ftCreationTime);
+    }
+    return ret;
+}
+
+/* License: Ruby's */
+static time_t
+filetime_to_unixtime(const FILETIME *ft)
+{
+    struct timeval tv;
+
+    if (filetime_to_timeval(ft, &tv) == (time_t)-1)
+	return 0;
+    else
+	return tv.tv_sec;
+}
+
+/* License: Ruby's */
+static unsigned
+fileattr_to_unixmode(DWORD attr, const WCHAR *path)
+{
+    unsigned mode = 0;
+
+    if (attr & FILE_ATTRIBUTE_READONLY) {
+	mode |= S_IREAD;
+    }
+    else {
+	mode |= S_IREAD | S_IWRITE | S_IWUSR;
+    }
+
+    if (attr & FILE_ATTRIBUTE_DIRECTORY) {
+	mode |= S_IFDIR | S_IEXEC;
+    }
+    else {
+	mode |= S_IFREG;
+    }
+
+    if (path && (mode & S_IFREG)) {
+	const WCHAR *end = path + lstrlenW(path);
+	while (path < end) {
+	    end = CharPrevW(path, end);
+	    if (*end == L'.') {
+		if ((_wcsicmp(end, L".bat") == 0) ||
+		    (_wcsicmp(end, L".cmd") == 0) ||
+		    (_wcsicmp(end, L".com") == 0) ||
+		    (_wcsicmp(end, L".exe") == 0)) {
+		    mode |= S_IEXEC;
+		}
+		break;
+	    }
+	}
+    }
+
+    mode |= (mode & 0700) >> 3;
+    mode |= (mode & 0700) >> 6;
+
+    return mode;
+}
+
+/* License: Ruby's */
+static int
+check_valid_dir(const WCHAR *path)
+{
+    WIN32_FIND_DATAW fd;
+    HANDLE fh;
+    WCHAR full[MAX_PATH];
+    WCHAR *dmy;
+    WCHAR *p, *q;
+
+    /* GetFileAttributes() determines "..." as directory. */
+    /* We recheck it by FindFirstFile(). */
+    if (!(p = wcsstr(path, L"...")))
+	return 0;
+    q = p + wcsspn(p, L".");
+    if ((p == path || wcschr(L":/\\", *(p - 1))) &&
+	(!*q || wcschr(L":/\\", *q))) {
+	errno = ENOENT;
+	return -1;
+    }
+
+    /* if the specified path is the root of a drive and the drive is empty, */
+    /* FindFirstFile() returns INVALID_HANDLE_VALUE. */
+    if (!GetFullPathNameW(path, sizeof(full) / sizeof(WCHAR), full, &dmy)) {
+	errno = map_errno(GetLastError());
+	return -1;
+    }
+    if (full[1] == L':' && !full[3] && GetDriveTypeW(full) != DRIVE_NO_ROOT_DIR)
+	return 0;
+
+    fh = open_dir_handle(path, &fd);
+    if (fh == INVALID_HANDLE_VALUE)
+	return -1;
+    FindClose(fh);
+    return 0;
+}
+
+/* License: Ruby's */
+static int
+winnt_stat(const WCHAR *path, struct stati64 *st)
+{
+    HANDLE h;
+    WIN32_FIND_DATAW wfd;
+    WIN32_FILE_ATTRIBUTE_DATA wfa;
+    const WCHAR *p = path;
+
+    memset(st, 0, sizeof(*st));
+    st->st_nlink = 1;
+
+    if (wcsncmp(p, L"\\\\?\\", 4) == 0) p += 4;
+    if (wcspbrk(p, L"?*")) {
+	errno = ENOENT;
+	return -1;
+    }
+    if (GetFileAttributesExW(path, GetFileExInfoStandard, (void*)&wfa)) {
+	if (wfa.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+	    if (check_valid_dir(path)) return -1;
+	    st->st_size = 0;
+	}
+	else {
+	    st->st_size = ((__int64)wfa.nFileSizeHigh << 32) | wfa.nFileSizeLow;
+	}
+	st->st_mode  = fileattr_to_unixmode(wfa.dwFileAttributes, path);
+	st->st_atime = filetime_to_unixtime(&wfa.ftLastAccessTime);
+	st->st_mtime = filetime_to_unixtime(&wfa.ftLastWriteTime);
+	st->st_ctime = filetime_to_unixtime(&wfa.ftCreationTime);
+    }
+    else {
+	/* GetFileAttributesEx failed; check why. */
+	int e = GetLastError();
+
+	if ((e == ERROR_FILE_NOT_FOUND) || (e == ERROR_INVALID_NAME)
+	    || (e == ERROR_PATH_NOT_FOUND || (e == ERROR_BAD_NETPATH))) {
+	    errno = map_errno(e);
+	    return -1;
+	}
+
+	/* Fall back to FindFirstFile for ERROR_SHARING_VIOLATION */
+	h = FindFirstFileW(path, &wfd);
+	if (h != INVALID_HANDLE_VALUE) {
+	    FindClose(h);
+	    st->st_mode  = fileattr_to_unixmode(wfd.dwFileAttributes, path);
+	    st->st_atime = filetime_to_unixtime(&wfd.ftLastAccessTime);
+	    st->st_mtime = filetime_to_unixtime(&wfd.ftLastWriteTime);
+	    st->st_ctime = filetime_to_unixtime(&wfd.ftCreationTime);
+	    st->st_size = ((__int64)wfd.nFileSizeHigh << 32) | wfd.nFileSizeLow;
+	}
+	else {
+	    errno = map_errno(GetLastError());
+	    return -1;
+	}
+    }
+
+    st->st_dev = st->st_rdev = (iswalpha(path[0]) && path[1] == L':') ?
+	towupper(path[0]) - L'A' : _getdrive() - 1;
+
+    return 0;
+}
+
+/* License: Ruby's */
+int
+rb_w32_stat(const char *path, struct stat *st)
+{
+    struct stati64 tmp;
+
+    if (rb_w32_stati64(path, &tmp)) return -1;
+    COPY_STAT(tmp, *st, (_off_t));
+    return 0;
+}
+
+/* License: Ruby's */
+static int
+wstati64(const WCHAR *path, struct stati64 *st)
+{
+    const WCHAR *p;
+    WCHAR *buf1, *s, *end;
+    int len, size;
+    int ret;
+    VALUE v;
+
+    if (!path || !st) {
+	errno = EFAULT;
+	return -1;
+    }
+    size = lstrlenW(path) + 2;
+    buf1 = ALLOCV_N(WCHAR, v, size);
+    for (p = path, s = buf1; *p; p++, s++) {
+	if (*p == L'/')
+	    *s = L'\\';
+	else
+	    *s = *p;
+    }
+    *s = '\0';
+    len = s - buf1;
+    if (!len || L'\"' == *(--s)) {
+	errno = ENOENT;
+	return -1;
+    }
+    end = buf1 + len - 1;
+
+    if (isUNCRoot(buf1)) {
+	if (*end == L'.')
+	    *end = L'\0';
+	else if (*end != L'\\')
+	    lstrcatW(buf1, L"\\");
+    }
+    else if (*end == L'\\' || (buf1 + 1 == end && *end == L':'))
+	lstrcatW(buf1, L".");
+
+    ret = winnt_stat(buf1, st);
+    if (ret == 0) {
+	st->st_mode &= ~(S_IWGRP | S_IWOTH);
+    }
+    if (v)
+	ALLOCV_END(v);
+
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_ustati64(const char *path, struct stati64 *st)
+{
+    return w32_stati64(path, st, CP_UTF8);
+}
+
+/* License: Ruby's */
+int
+rb_w32_stati64(const char *path, struct stati64 *st)
+{
+    return w32_stati64(path, st, filecp());
+}
+
+/* License: Ruby's */
+static int
+w32_stati64(const char *path, struct stati64 *st, UINT cp)
+{
+    WCHAR *wpath;
+    int ret;
+
+    if (!(wpath = mbstr_to_wstr(cp, path, -1, NULL)))
+	return -1;
+    ret = wstati64(wpath, st);
+    free(wpath);
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_access(const char *path, int mode)
+{
+    struct stati64 stat;
+    if (rb_w32_stati64(path, &stat) != 0)
+	return -1;
+    mode <<= 6;
+    if ((stat.st_mode & mode) != mode) {
+	errno = EACCES;
+	return -1;
+    }
+    return 0;
+}
+
+/* License: Ruby's */
+int
+rb_w32_uaccess(const char *path, int mode)
+{
+    struct stati64 stat;
+    if (rb_w32_ustati64(path, &stat) != 0)
+	return -1;
+    mode <<= 6;
+    if ((stat.st_mode & mode) != mode) {
+	errno = EACCES;
+	return -1;
+    }
+    return 0;
+}
+
+/* License: Ruby's */
+static int
+rb_chsize(HANDLE h, off_t size)
+{
+    long upos, lpos, usize, lsize;
+    int ret = -1;
+    DWORD e;
+
+    if ((lpos = SetFilePointer(h, 0, (upos = 0, &upos), SEEK_CUR)) == -1L &&
+	(e = GetLastError())) {
+	errno = map_errno(e);
+	return -1;
+    }
+    usize = (long)(size >> 32);
+    lsize = (long)size;
+    if (SetFilePointer(h, lsize, &usize, SEEK_SET) == (DWORD)-1L &&
+	(e = GetLastError())) {
+	errno = map_errno(e);
+    }
+    else if (!SetEndOfFile(h)) {
+	errno = map_errno(GetLastError());
+    }
+    else {
+	ret = 0;
+    }
+    SetFilePointer(h, lpos, &upos, SEEK_SET);
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_truncate(const char *path, off_t length)
+{
+    HANDLE h;
+    int ret;
+    h = CreateFile(path, GENERIC_WRITE, 0, 0, OPEN_EXISTING, 0, 0);
+    if (h == INVALID_HANDLE_VALUE) {
+	errno = map_errno(GetLastError());
+	return -1;
+    }
+    ret = rb_chsize(h, length);
+    CloseHandle(h);
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_ftruncate(int fd, off_t length)
+{
+    HANDLE h;
+
+    h = (HANDLE)_get_osfhandle(fd);
+    if (h == (HANDLE)-1) return -1;
+    return rb_chsize(h, length);
+}
+
+#ifdef __BORLANDC__
+/* License: Ruby's */
+off_t
+_filelengthi64(int fd)
+{
+    DWORD u, l;
+    int e;
+
+    l = GetFileSize((HANDLE)_get_osfhandle(fd), &u);
+    if (l == (DWORD)-1L && (e = GetLastError())) {
+	errno = map_errno(e);
+	return (off_t)-1;
+    }
+    return ((off_t)u << 32) | l;
+}
+
+/* License: Ruby's */
+off_t
+_lseeki64(int fd, off_t offset, int whence)
+{
+    long u, l;
+    int e;
+    HANDLE h = (HANDLE)_get_osfhandle(fd);
+
+    if (!h) {
+	errno = EBADF;
+	return -1;
+    }
+    u = (long)(offset >> 32);
+    if ((l = SetFilePointer(h, (long)offset, &u, whence)) == -1L &&
+	(e = GetLastError())) {
+	errno = map_errno(e);
+	return -1;
+    }
+    return ((off_t)u << 32) | l;
+}
+#endif
+
+/* License: Ruby's */
+static long
+filetime_to_clock(FILETIME *ft)
+{
+    __int64 qw = ft->dwHighDateTime;
+    qw <<= 32;
+    qw |= ft->dwLowDateTime;
+    qw /= 10000;  /* File time ticks at 0.1uS, clock at 1mS */
+    return (long) qw;
+}
+
+/* License: Ruby's */
+int
+rb_w32_times(struct tms *tmbuf)
+{
+    FILETIME create, exit, kernel, user;
+
+    if (GetProcessTimes(GetCurrentProcess(),&create, &exit, &kernel, &user)) {
+	tmbuf->tms_utime = filetime_to_clock(&user);
+	tmbuf->tms_stime = filetime_to_clock(&kernel);
+	tmbuf->tms_cutime = 0;
+	tmbuf->tms_cstime = 0;
+    }
+    else {
+	tmbuf->tms_utime = clock();
+	tmbuf->tms_stime = 0;
+	tmbuf->tms_cutime = 0;
+	tmbuf->tms_cstime = 0;
+    }
+    return 0;
+}
+
+#define yield_once() Sleep(0)
+#define yield_until(condition) do yield_once(); while (!(condition))
+
+/* License: Ruby's */
+static void
+catch_interrupt(void)
+{
+    yield_once();
+    RUBY_CRITICAL(rb_w32_wait_events(NULL, 0, 0));
+}
+
+#if defined __BORLANDC__
+#undef read
+/* License: Ruby's */
+int
+read(int fd, void *buf, size_t size)
+{
+    int ret = _read(fd, buf, size);
+    if ((ret < 0) && (errno == EPIPE)) {
+	errno = 0;
+	ret = 0;
+    }
+    catch_interrupt();
+    return ret;
+}
+#endif
+
+
+#define FILE_COUNT _cnt
+#define FILE_READPTR _ptr
+
+#undef fgetc
+/* License: Ruby's */
+int
+rb_w32_getc(FILE* stream)
+{
+    int c;
+    if (enough_to_get(stream->FILE_COUNT)) {
+	c = (unsigned char)*stream->FILE_READPTR++;
+    }
+    else {
+	c = _filbuf(stream);
+#if defined __BORLANDC__
+        if ((c == EOF) && (errno == EPIPE)) {
+	    clearerr(stream);
+        }
+#endif
+	catch_interrupt();
+    }
+    return c;
+}
+
+#undef fputc
+/* License: Ruby's */
+int
+rb_w32_putc(int c, FILE* stream)
+{
+    if (enough_to_put(stream->FILE_COUNT)) {
+	c = (unsigned char)(*stream->FILE_READPTR++ = (char)c);
+    }
+    else {
+	c = _flsbuf(c, stream);
+	catch_interrupt();
+    }
+    return c;
+}
+
+/* License: Ruby's */
+struct asynchronous_arg_t {
+    /* output field */
+    void* stackaddr;
+    int errnum;
+
+    /* input field */
+    uintptr_t (*func)(uintptr_t self, int argc, uintptr_t* argv);
+    uintptr_t self;
+    int argc;
+    uintptr_t* argv;
+};
+
+/* License: Ruby's */
+static DWORD WINAPI
+call_asynchronous(PVOID argp)
+{
+    DWORD ret;
+    struct asynchronous_arg_t *arg = argp;
+    arg->stackaddr = &argp;
+    ret = (DWORD)arg->func(arg->self, arg->argc, arg->argv);
+    arg->errnum = errno;
+    return ret;
+}
+
+/* License: Ruby's */
+uintptr_t
+rb_w32_asynchronize(asynchronous_func_t func, uintptr_t self,
+		    int argc, uintptr_t* argv, uintptr_t intrval)
+{
+    DWORD val;
+    BOOL interrupted = FALSE;
+    HANDLE thr;
+
+    RUBY_CRITICAL({
+	struct asynchronous_arg_t arg;
+
+	arg.stackaddr = NULL;
+	arg.errnum = 0;
+	arg.func = func;
+	arg.self = self;
+	arg.argc = argc;
+	arg.argv = argv;
+
+	thr = CreateThread(NULL, 0, call_asynchronous, &arg, 0, &val);
+
+	if (thr) {
+	    yield_until(arg.stackaddr);
+
+	    if (rb_w32_wait_events_blocking(&thr, 1, INFINITE) != WAIT_OBJECT_0) {
+		interrupted = TRUE;
+
+		if (TerminateThread(thr, intrval)) {
+		    yield_once();
+		}
+	    }
+
+	    GetExitCodeThread(thr, &val);
+	    CloseHandle(thr);
+
+	    if (interrupted) {
+		/* must release stack of killed thread, why doesn't Windows? */
+		MEMORY_BASIC_INFORMATION m;
+
+		memset(&m, 0, sizeof(m));
+		if (!VirtualQuery(arg.stackaddr, &m, sizeof(m))) {
+		    Debug(fprintf(stderr, "couldn't get stack base:%p:%d\n",
+				  arg.stackaddr, GetLastError()));
+		}
+		else if (!VirtualFree(m.AllocationBase, 0, MEM_RELEASE)) {
+		    Debug(fprintf(stderr, "couldn't release stack:%p:%d\n",
+				  m.AllocationBase, GetLastError()));
+		}
+		errno = EINTR;
+	    }
+	    else {
+		errno = arg.errnum;
+	    }
+	}
+    });
+
+    if (!thr) {
+	rb_fatal("failed to launch waiter thread:%ld", GetLastError());
+    }
+
+    return val;
+}
+
+/* License: Ruby's */
+char **
+rb_w32_get_environ(void)
+{
+    WCHAR *envtop, *env;
+    char **myenvtop, **myenv;
+    int num;
+
+    /*
+     * We avoid values started with `='. If you want to deal those values,
+     * change this function, and some functions in hash.c which recognize
+     * `=' as delimiter or rb_w32_getenv() and ruby_setenv().
+     * CygWin deals these values by changing first `=' to '!'. But we don't
+     * use such trick and follow cmd.exe's way that just doesn't show these
+     * values.
+     *
+     * This function returns UTF-8 strings.
+     */
+    envtop = GetEnvironmentStringsW();
+    for (env = envtop, num = 0; *env; env += lstrlenW(env) + 1)
+	if (*env != '=') num++;
+
+    myenvtop = (char **)malloc(sizeof(char *) * (num + 1));
+    for (env = envtop, myenv = myenvtop; *env; env += lstrlenW(env) + 1) {
+	if (*env != '=') {
+	    if (!(*myenv = wstr_to_utf8(env, NULL))) {
+		break;
+	    }
+	    myenv++;
+	}
+    }
+    *myenv = NULL;
+    FreeEnvironmentStringsW(envtop);
+
+    return myenvtop;
+}
+
+/* License: Ruby's */
+void
+rb_w32_free_environ(char **env)
+{
+    char **t = env;
+
+    while (*t) free(*t++);
+    free(env);
+}
+
+/* License: Ruby's */
+rb_pid_t
+rb_w32_getpid(void)
+{
+    return GetCurrentProcessId();
+}
+
+
+/* License: Ruby's */
+rb_pid_t
+rb_w32_getppid(void)
+{
+    typedef long (WINAPI query_func)(HANDLE, int, void *, ULONG, ULONG *);
+    static query_func *pNtQueryInformationProcess = NULL;
+    rb_pid_t ppid = 0;
+
+    if (rb_w32_osver() >= 5) {
+	if (!pNtQueryInformationProcess)
+	    pNtQueryInformationProcess = (query_func *)get_proc_address("ntdll.dll", "NtQueryInformationProcess", NULL);
+	if (pNtQueryInformationProcess) {
+	    struct {
+		long ExitStatus;
+		void* PebBaseAddress;
+		uintptr_t AffinityMask;
+		uintptr_t BasePriority;
+		uintptr_t UniqueProcessId;
+		uintptr_t ParentProcessId;
+	    } pbi;
+	    ULONG len;
+	    long ret = pNtQueryInformationProcess(GetCurrentProcess(), 0, &pbi, sizeof(pbi), &len);
+	    if (!ret) {
+		ppid = pbi.ParentProcessId;
+	    }
+	}
+    }
+
+    return ppid;
+}
+
+STATIC_ASSERT(std_handle, (STD_OUTPUT_HANDLE-STD_INPUT_HANDLE)==(STD_ERROR_HANDLE-STD_OUTPUT_HANDLE));
+
+/* License: Ruby's */
+#define set_new_std_handle(newfd, handle) do { \
+	if ((unsigned)(newfd) > 2) break; \
+	SetStdHandle(STD_INPUT_HANDLE+(STD_OUTPUT_HANDLE-STD_INPUT_HANDLE)*(newfd), \
+		     (handle)); \
+    } while (0)
+#define set_new_std_fd(newfd) set_new_std_handle(newfd, (HANDLE)rb_w32_get_osfhandle(newfd))
+
+/* License: Ruby's */
+int
+rb_w32_dup2(int oldfd, int newfd)
+{
+    int ret;
+
+    if (oldfd == newfd) return newfd;
+    ret = dup2(oldfd, newfd);
+    set_new_std_fd(newfd);
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_uopen(const char *file, int oflag, ...)
+{
+    WCHAR *wfile;
+    int ret;
+    int pmode;
+
+    va_list arg;
+    va_start(arg, oflag);
+    pmode = va_arg(arg, int);
+    va_end(arg);
+
+    if (!(wfile = utf8_to_wstr(file, NULL)))
+	return -1;
+    ret = rb_w32_wopen(wfile, oflag, pmode);
+    free(wfile);
+    return ret;
+}
+
+/* License: Ruby's */
+static int
+check_if_wdir(const WCHAR *wfile)
+{
+    DWORD attr = GetFileAttributesW(wfile);
+    if (attr == (DWORD)-1L ||
+	!(attr & FILE_ATTRIBUTE_DIRECTORY) ||
+	check_valid_dir(wfile)) {
+	return FALSE;
+    }
+    errno = EISDIR;
+    return TRUE;
+}
+
+/* License: Ruby's */
+static int
+check_if_dir(const char *file)
+{
+    WCHAR *wfile;
+    int ret;
+
+    if (!(wfile = filecp_to_wstr(file, NULL)))
+	return FALSE;
+    ret = check_if_wdir(wfile);
+    free(wfile);
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_open(const char *file, int oflag, ...)
+{
+    WCHAR *wfile;
+    int ret;
+    int pmode;
+
+    va_list arg;
+    va_start(arg, oflag);
+    pmode = va_arg(arg, int);
+    va_end(arg);
+
+    if ((oflag & O_TEXT) || !(oflag & O_BINARY)) {
+	ret = _open(file, oflag, pmode);
+	if (ret == -1 && errno == EACCES) check_if_dir(file);
+	return ret;
+    }
+
+    if (!(wfile = filecp_to_wstr(file, NULL)))
+	return -1;
+    ret = rb_w32_wopen(wfile, oflag, pmode);
+    free(wfile);
+    return ret;
+}
+
+int
+rb_w32_wopen(const WCHAR *file, int oflag, ...)
+{
+    char flags = 0;
+    int fd;
+    DWORD access;
+    DWORD create;
+    DWORD attr = FILE_ATTRIBUTE_NORMAL;
+    SECURITY_ATTRIBUTES sec;
+    HANDLE h;
+
+    if ((oflag & O_TEXT) || !(oflag & O_BINARY)) {
+	va_list arg;
+	int pmode;
+	va_start(arg, oflag);
+	pmode = va_arg(arg, int);
+	va_end(arg);
+	fd = _wopen(file, oflag, pmode);
+	if (fd == -1 && errno == EACCES) check_if_wdir(file);
+	return fd;
+    }
+
+    sec.nLength = sizeof(sec);
+    sec.lpSecurityDescriptor = NULL;
+    if (oflag & O_NOINHERIT) {
+	sec.bInheritHandle = FALSE;
+	flags |= FNOINHERIT;
+    }
+    else {
+	sec.bInheritHandle = TRUE;
+    }
+    oflag &= ~O_NOINHERIT;
+
+    /* always open with binary mode */
+    oflag &= ~(O_BINARY | O_TEXT);
+
+    switch (oflag & (O_RDWR | O_RDONLY | O_WRONLY)) {
+      case O_RDWR:
+	access = GENERIC_READ | GENERIC_WRITE;
+	break;
+      case O_RDONLY:
+	access = GENERIC_READ;
+	break;
+      case O_WRONLY:
+	access = GENERIC_WRITE;
+	break;
+      default:
+	errno = EINVAL;
+	return -1;
+    }
+    oflag &= ~(O_RDWR | O_RDONLY | O_WRONLY);
+
+    switch (oflag & (O_CREAT | O_EXCL | O_TRUNC)) {
+      case O_CREAT:
+	create = OPEN_ALWAYS;
+	break;
+      case 0:
+      case O_EXCL:
+	create = OPEN_EXISTING;
+	break;
+      case O_CREAT | O_EXCL:
+      case O_CREAT | O_EXCL | O_TRUNC:
+	create = CREATE_NEW;
+	break;
+      case O_TRUNC:
+      case O_TRUNC | O_EXCL:
+	create = TRUNCATE_EXISTING;
+	break;
+      case O_CREAT | O_TRUNC:
+	create = CREATE_ALWAYS;
+	break;
+      default:
+	errno = EINVAL;
+	return -1;
+    }
+    if (oflag & O_CREAT) {
+	va_list arg;
+	int pmode;
+	va_start(arg, oflag);
+	pmode = va_arg(arg, int);
+	va_end(arg);
+	/* TODO: we need to check umask here, but it's not exported... */
+	if (!(pmode & S_IWRITE))
+	    attr = FILE_ATTRIBUTE_READONLY;
+    }
+    oflag &= ~(O_CREAT | O_EXCL | O_TRUNC);
+
+    if (oflag & O_TEMPORARY) {
+	attr |= FILE_FLAG_DELETE_ON_CLOSE;
+	access |= DELETE;
+    }
+    oflag &= ~O_TEMPORARY;
+
+    if (oflag & _O_SHORT_LIVED)
+	attr |= FILE_ATTRIBUTE_TEMPORARY;
+    oflag &= ~_O_SHORT_LIVED;
+
+    switch (oflag & (O_SEQUENTIAL | O_RANDOM)) {
+      case 0:
+	break;
+      case O_SEQUENTIAL:
+	attr |= FILE_FLAG_SEQUENTIAL_SCAN;
+	break;
+      case O_RANDOM:
+	attr |= FILE_FLAG_RANDOM_ACCESS;
+	break;
+      default:
+	errno = EINVAL;
+	return -1;
+    }
+    oflag &= ~(O_SEQUENTIAL | O_RANDOM);
+
+    if (oflag & ~O_APPEND) {
+	errno = EINVAL;
+	return -1;
+    }
+
+    /* allocate a C Runtime file handle */
+    RUBY_CRITICAL({
+	h = CreateFile("NUL", 0, 0, NULL, OPEN_ALWAYS, 0, NULL);
+	fd = _open_osfhandle((intptr_t)h, 0);
+	CloseHandle(h);
+    });
+    if (fd == -1) {
+	errno = EMFILE;
+	return -1;
+    }
+    RUBY_CRITICAL({
+	MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fd)->lock)));
+	_set_osfhnd(fd, (intptr_t)INVALID_HANDLE_VALUE);
+	_set_osflags(fd, 0);
+
+	h = CreateFileW(file, access, FILE_SHARE_READ | FILE_SHARE_WRITE, &sec,
+			create, attr, NULL);
+	if (h == INVALID_HANDLE_VALUE) {
+	    DWORD e = GetLastError();
+	    if (e != ERROR_ACCESS_DENIED || !check_if_wdir(file))
+		errno = map_errno(e);
+	    MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+	    fd = -1;
+	    goto quit;
+	}
+
+	switch (GetFileType(h)) {
+	  case FILE_TYPE_CHAR:
+	    flags |= FDEV;
+	    break;
+	  case FILE_TYPE_PIPE:
+	    flags |= FPIPE;
+	    break;
+	  case FILE_TYPE_UNKNOWN:
+	    errno = map_errno(GetLastError());
+	    CloseHandle(h);
+	    MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+	    fd = -1;
+	    goto quit;
+	}
+	if (!(flags & (FDEV | FPIPE)) && (oflag & O_APPEND))
+	    flags |= FAPPEND;
+
+	_set_osfhnd(fd, (intptr_t)h);
+	_osfile(fd) = flags | FOPEN;
+
+	MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+      quit:
+	;
+    });
+
+    return fd;
+}
+
+/* License: Ruby's */
+int
+rb_w32_fclose(FILE *fp)
+{
+    int fd = fileno(fp);
+    SOCKET sock = TO_SOCKET(fd);
+    int save_errno = errno;
+
+    if (fflush(fp)) return -1;
+    if (!is_socket(sock)) {
+	UnlockFile((HANDLE)sock, 0, 0, LK_LEN, LK_LEN);
+	return fclose(fp);
+    }
+    _set_osfhnd(fd, (SOCKET)INVALID_HANDLE_VALUE);
+    fclose(fp);
+    errno = save_errno;
+    if (closesocket(sock) == SOCKET_ERROR) {
+	errno = map_errno(WSAGetLastError());
+	return -1;
+    }
+    return 0;
+}
+
+/* License: Ruby's */
+int
+rb_w32_pipe(int fds[2])
+{
+    static DWORD serial = 0;
+    static const char prefix[] = "\\\\.\\pipe\\ruby";
+    enum {
+	width_of_prefix = (int)sizeof(prefix) - 1,
+	width_of_pid = (int)sizeof(rb_pid_t) * 2,
+	width_of_serial = (int)sizeof(serial) * 2,
+	width_of_ids = width_of_pid + 1 + width_of_serial + 1
+    };
+    char name[sizeof(prefix) + width_of_ids];
+    SECURITY_ATTRIBUTES sec;
+    HANDLE hRead, hWrite, h;
+    int fdRead, fdWrite;
+    int ret;
+
+    /* if doesn't have CancelIo, use default pipe function */
+    if (!cancel_io)
+	return _pipe(fds, 65536L, _O_NOINHERIT);
+
+    memcpy(name, prefix, width_of_prefix);
+    snprintf(name + width_of_prefix, width_of_ids, "%.*"PRI_PIDT_PREFIX"x-%.*lx",
+	     width_of_pid, rb_w32_getpid(), width_of_serial, serial++);
+
+    sec.nLength = sizeof(sec);
+    sec.lpSecurityDescriptor = NULL;
+    sec.bInheritHandle = FALSE;
+
+    RUBY_CRITICAL({
+	hRead = CreateNamedPipe(name, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
+				0, 2, 65536, 65536, 0, &sec);
+    });
+    if (hRead == INVALID_HANDLE_VALUE) {
+	DWORD err = GetLastError();
+	if (err == ERROR_PIPE_BUSY)
+	    errno = EMFILE;
+	else
+	    errno = map_errno(GetLastError());
+	return -1;
+    }
+
+    RUBY_CRITICAL({
+	hWrite = CreateFile(name, GENERIC_READ | GENERIC_WRITE, 0, &sec,
+			    OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
+    });
+    if (hWrite == INVALID_HANDLE_VALUE) {
+	errno = map_errno(GetLastError());
+	CloseHandle(hRead);
+	return -1;
+    }
+
+    RUBY_CRITICAL(do {
+	ret = 0;
+	h = CreateFile("NUL", 0, 0, NULL, OPEN_ALWAYS, 0, NULL);
+	fdRead = _open_osfhandle((intptr_t)h, 0);
+	CloseHandle(h);
+	if (fdRead == -1) {
+	    errno = EMFILE;
+	    CloseHandle(hWrite);
+	    CloseHandle(hRead);
+	    ret = -1;
+	    break;
+	}
+
+	MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fdRead)->lock)));
+	_set_osfhnd(fdRead, (intptr_t)hRead);
+	_set_osflags(fdRead, FOPEN | FPIPE | FNOINHERIT);
+	MTHREAD_ONLY(LeaveCriticalSection(&(_pioinfo(fdRead)->lock)));
+    } while (0));
+    if (ret)
+	return ret;
+
+    RUBY_CRITICAL(do {
+	h = CreateFile("NUL", 0, 0, NULL, OPEN_ALWAYS, 0, NULL);
+	fdWrite = _open_osfhandle((intptr_t)h, 0);
+	CloseHandle(h);
+	if (fdWrite == -1) {
+	    errno = EMFILE;
+	    CloseHandle(hWrite);
+	    ret = -1;
+	    break;
+	}
+	MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fdWrite)->lock)));
+	_set_osfhnd(fdWrite, (intptr_t)hWrite);
+	_set_osflags(fdWrite, FOPEN | FPIPE | FNOINHERIT);
+	MTHREAD_ONLY(LeaveCriticalSection(&(_pioinfo(fdWrite)->lock)));
+    } while (0));
+    if (ret) {
+	rb_w32_close(fdRead);
+	return ret;
+    }
+
+    fds[0] = fdRead;
+    fds[1] = fdWrite;
+
+    return 0;
+}
+
+/* License: Ruby's */
+static int
+console_emulator_p(void)
+{
+#ifdef _WIN32_WCE
+    return FALSE;
+#else
+    const void *const func = WriteConsoleW;
+    HMODULE k;
+    MEMORY_BASIC_INFORMATION m;
+
+    memset(&m, 0, sizeof(m));
+    if (!VirtualQuery(func, &m, sizeof(m))) {
+	return FALSE;
+    }
+    k = GetModuleHandle("kernel32.dll");
+    if (!k) return FALSE;
+    return (HMODULE)m.AllocationBase != k;
+#endif
+}
+
+/* License: Ruby's */
+static struct constat *
+constat_handle(HANDLE h)
+{
+    st_data_t data;
+    struct constat *p;
+    if (!conlist) {
+	if (console_emulator_p()) {
+	    conlist = conlist_disabled;
+	    return NULL;
+	}
+	conlist = st_init_numtable();
+    }
+    else if (conlist == conlist_disabled) {
+	return NULL;
+    }
+    if (st_lookup(conlist, (st_data_t)h, &data)) {
+	p = (struct constat *)data;
+    }
+    else {
+	CONSOLE_SCREEN_BUFFER_INFO csbi;
+	p = ALLOC(struct constat);
+	p->vt100.state = constat_init;
+	p->vt100.attr = FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED;
+	p->vt100.reverse = 0;
+	p->vt100.saved.X = p->vt100.saved.Y = 0;
+	if (GetConsoleScreenBufferInfo(h, &csbi)) {
+	    p->vt100.attr = csbi.wAttributes;
+	}
+	st_insert(conlist, (st_data_t)h, (st_data_t)p);
+    }
+    return p;
+}
+
+/* License: Ruby's */
+static void
+constat_reset(HANDLE h)
+{
+    st_data_t data;
+    struct constat *p;
+    if (!conlist || conlist == conlist_disabled) return;
+    if (!st_lookup(conlist, (st_data_t)h, &data)) return;
+    p = (struct constat *)data;
+    p->vt100.state = constat_init;
+}
+
+#define FOREGROUND_MASK (FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_INTENSITY)
+#define BACKGROUND_MASK (BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_INTENSITY)
+
+#define constat_attr_color_reverse(attr) \
+    ((attr) & ~(FOREGROUND_MASK | BACKGROUND_MASK)) | \
+	   (((attr) & FOREGROUND_MASK) << 4) | \
+	   (((attr) & BACKGROUND_MASK) >> 4)
+
+/* License: Ruby's */
+static WORD
+constat_attr(int count, const int *seq, WORD attr, WORD default_attr, int *reverse)
+{
+    int rev = *reverse;
+    WORD bold;
+
+    if (!count) return attr;
+    if (rev) attr = constat_attr_color_reverse(attr);
+    bold = attr & FOREGROUND_INTENSITY;
+    attr &= ~(FOREGROUND_INTENSITY | BACKGROUND_INTENSITY);
+
+    while (count-- > 0) {
+	switch (*seq++) {
+	  case 0:
+	    attr = default_attr;
+	    rev = 0;
+	    bold = 0;
+	    break;
+	  case 1:
+	    bold = FOREGROUND_INTENSITY;
+	    break;
+	  case 4:
+#ifndef COMMON_LVB_UNDERSCORE
+#define COMMON_LVB_UNDERSCORE 0x8000
+#endif
+	    attr |= COMMON_LVB_UNDERSCORE;
+	    break;
+	  case 7:
+	    rev = 1;
+	    break;
+
+	  case 30:
+	    attr &= ~(FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED);
+	    break;
+	  case 17:
+	  case 31:
+	    attr = (attr & ~(FOREGROUND_BLUE | FOREGROUND_GREEN)) | FOREGROUND_RED;
+	    break;
+	  case 18:
+	  case 32:
+	    attr = (attr & ~(FOREGROUND_BLUE | FOREGROUND_RED)) | FOREGROUND_GREEN;
+	    break;
+	  case 19:
+	  case 33:
+	    attr = (attr & ~FOREGROUND_BLUE) | FOREGROUND_GREEN | FOREGROUND_RED;
+	    break;
+	  case 20:
+	  case 34:
+	    attr = (attr & ~(FOREGROUND_GREEN | FOREGROUND_RED)) | FOREGROUND_BLUE;
+	    break;
+	  case 21:
+	  case 35:
+	    attr = (attr & ~FOREGROUND_GREEN) | FOREGROUND_BLUE | FOREGROUND_RED;
+	    break;
+	  case 22:
+	  case 36:
+	    attr = (attr & ~FOREGROUND_RED) | FOREGROUND_BLUE | FOREGROUND_GREEN;
+	    break;
+	  case 23:
+	  case 37:
+	    attr |= FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED;
+	    break;
+
+	  case 40:
+	    attr &= ~(BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED);
+	    break;
+	  case 41:
+	    attr = (attr & ~(BACKGROUND_BLUE | BACKGROUND_GREEN)) | BACKGROUND_RED;
+	    break;
+	  case 42:
+	    attr = (attr & ~(BACKGROUND_BLUE | BACKGROUND_RED)) | BACKGROUND_GREEN;
+	    break;
+	  case 43:
+	    attr = (attr & ~BACKGROUND_BLUE) | BACKGROUND_GREEN | BACKGROUND_RED;
+	    break;
+	  case 44:
+	    attr = (attr & ~(BACKGROUND_GREEN | BACKGROUND_RED)) | BACKGROUND_BLUE;
+	    break;
+	  case 45:
+	    attr = (attr & ~BACKGROUND_GREEN) | BACKGROUND_BLUE | BACKGROUND_RED;
+	    break;
+	  case 46:
+	    attr = (attr & ~BACKGROUND_RED) | BACKGROUND_BLUE | BACKGROUND_GREEN;
+	    break;
+	  case 47:
+	    attr |= BACKGROUND_BLUE | BACKGROUND_GREEN | BACKGROUND_RED;
+	    break;
+	}
+    }
+    attr |= bold;
+    if (rev) attr = constat_attr_color_reverse(attr);
+    *reverse = rev;
+    return attr;
+}
+
+/* License: Ruby's */
+static void
+constat_apply(HANDLE handle, struct constat *s, WCHAR w)
+{
+    CONSOLE_SCREEN_BUFFER_INFO csbi;
+    const int *seq = s->vt100.seq;
+    int count = s->vt100.state;
+    int arg1 = 1;
+    COORD pos;
+    DWORD written;
+
+    if (!GetConsoleScreenBufferInfo(handle, &csbi)) return;
+    if (count > 0 && seq[0] > 0) arg1 = seq[0];
+    switch (w) {
+      case L'm':
+	SetConsoleTextAttribute(handle, constat_attr(count, seq, csbi.wAttributes, s->vt100.attr, &s->vt100.reverse));
+	break;
+      case L'F':
+	csbi.dwCursorPosition.X = 0;
+      case L'A':
+	csbi.dwCursorPosition.Y -= arg1;
+	if (csbi.dwCursorPosition.Y < 0)
+	    csbi.dwCursorPosition.Y = 0;
+	SetConsoleCursorPosition(handle, csbi.dwCursorPosition);
+	break;
+      case L'E':
+	csbi.dwCursorPosition.X = 0;
+      case L'B':
+      case L'e':
+	csbi.dwCursorPosition.Y += arg1;
+	if (csbi.dwCursorPosition.Y >= csbi.dwSize.Y)
+	    csbi.dwCursorPosition.Y = csbi.dwSize.Y;
+	SetConsoleCursorPosition(handle, csbi.dwCursorPosition);
+	break;
+      case L'C':
+	csbi.dwCursorPosition.X += arg1;
+	if (csbi.dwCursorPosition.X >= csbi.dwSize.X)
+	    csbi.dwCursorPosition.X = csbi.dwSize.X;
+	SetConsoleCursorPosition(handle, csbi.dwCursorPosition);
+	break;
+      case L'D':
+	csbi.dwCursorPosition.X -= arg1;
+	if (csbi.dwCursorPosition.X < 0)
+	    csbi.dwCursorPosition.X = 0;
+	SetConsoleCursorPosition(handle, csbi.dwCursorPosition);
+	break;
+      case L'G':
+      case L'`':
+	csbi.dwCursorPosition.X = (arg1 > csbi.dwSize.X ? csbi.dwSize.X : arg1) - 1;
+	SetConsoleCursorPosition(handle, csbi.dwCursorPosition);
+	break;
+      case L'd':
+	csbi.dwCursorPosition.Y = (arg1 > csbi.dwSize.Y ? csbi.dwSize.Y : arg1) - 1;
+	SetConsoleCursorPosition(handle, csbi.dwCursorPosition);
+	break;
+      case L'H':
+      case L'f':
+	pos.Y = (arg1 > csbi.dwSize.Y ? csbi.dwSize.Y : arg1) - 1;
+	if (count < 2 || (arg1 = seq[1]) <= 0) arg1 = 1;
+	pos.X = (arg1 > csbi.dwSize.X ? csbi.dwSize.X : arg1) - 1;
+	SetConsoleCursorPosition(handle, pos);
+	break;
+      case L'J':
+	switch (arg1) {
+	  case 0:	/* erase after cursor */
+	    FillConsoleOutputCharacterW(handle, L' ',
+					csbi.dwSize.X * (csbi.dwSize.Y - csbi.dwCursorPosition.Y) - csbi.dwCursorPosition.X,
+					csbi.dwCursorPosition, &written);
+	    break;
+	  case 1:	/* erase before cursor */
+	    pos.X = 0;
+	    pos.Y = csbi.dwCursorPosition.Y;
+	    FillConsoleOutputCharacterW(handle, L' ',
+					csbi.dwSize.X * csbi.dwCursorPosition.Y + csbi.dwCursorPosition.X,
+					pos, &written);
+	    break;
+	  case 2:	/* erase entire line */
+	    pos.X = 0;
+	    pos.Y = 0;
+	    FillConsoleOutputCharacterW(handle, L' ', csbi.dwSize.X * csbi.dwSize.Y, pos, &written);
+	    break;
+	}
+	break;
+      case L'K':
+	switch (arg1) {
+	  case 0:	/* erase after cursor */
+	    FillConsoleOutputCharacterW(handle, L' ', csbi.dwSize.X - csbi.dwCursorPosition.X, csbi.dwCursorPosition, &written);
+	    break;
+	  case 1:	/* erase before cursor */
+	    pos.X = 0;
+	    pos.Y = csbi.dwCursorPosition.Y;
+	    FillConsoleOutputCharacterW(handle, L' ', csbi.dwCursorPosition.X, pos, &written);
+	    break;
+	  case 2:	/* erase entire line */
+	    pos.X = 0;
+	    pos.Y = csbi.dwCursorPosition.Y;
+	    FillConsoleOutputCharacterW(handle, L' ', csbi.dwSize.X, pos, &written);
+	    break;
+	}
+	break;
+      case L's':
+	s->vt100.saved = csbi.dwCursorPosition;
+	break;
+      case L'u':
+	SetConsoleCursorPosition(handle, s->vt100.saved);
+	break;
+      case L'h':
+	if (count >= 2 && seq[0] == -1 && seq[1] == 25) {
+	    CONSOLE_CURSOR_INFO cci;
+	    GetConsoleCursorInfo(handle, &cci);
+	    cci.bVisible = TRUE;
+	    SetConsoleCursorInfo(handle, &cci);
+	}
+	break;
+      case L'l':
+	if (count >= 2 && seq[0] == -1 && seq[1] == 25) {
+	    CONSOLE_CURSOR_INFO cci;
+	    GetConsoleCursorInfo(handle, &cci);
+	    cci.bVisible = FALSE;
+	    SetConsoleCursorInfo(handle, &cci);
+	}
+	break;
+    }
+}
+
+/* License: Ruby's */
+static long
+constat_parse(HANDLE h, struct constat *s, const WCHAR **ptrp, long *lenp)
+{
+    const WCHAR *ptr = *ptrp;
+    long rest, len = *lenp;
+    while (len-- > 0) {
+	WCHAR wc = *ptr++;
+	if (wc == 0x1b) {
+	    rest = *lenp - len - 1;
+	    if (s->vt100.state == constat_esc) {
+		rest++;		/* reuse this ESC */
+	    }
+	    s->vt100.state = constat_init;
+	    if (len > 0 && *ptr != L'[') continue;
+	    s->vt100.state = constat_esc;
+	}
+	else if (s->vt100.state == constat_esc) {
+	    if (wc != L'[') {
+		/* TODO: supply dropped ESC at beginning */
+		s->vt100.state = constat_init;
+		continue;
+	    }
+	    rest = *lenp - len - 1;
+	    if (rest > 0) --rest;
+	    s->vt100.state = constat_seq;
+	    s->vt100.seq[0] = 0;
+	}
+	else if (s->vt100.state >= constat_seq) {
+	    if (wc >= L'0' && wc <= L'9') {
+		if (s->vt100.state < (int)numberof(s->vt100.seq)) {
+		    int *seq = &s->vt100.seq[s->vt100.state];
+		    *seq = (*seq * 10) + (wc - L'0');
+		}
+	    }
+	    else if (s->vt100.state == constat_seq && s->vt100.seq[0] == 0 && wc == L'?') {
+		s->vt100.seq[s->vt100.state++] = -1;
+	    }
+	    else {
+		do {
+		    if (++s->vt100.state < (int)numberof(s->vt100.seq)) {
+			s->vt100.seq[s->vt100.state] = 0;
+		    }
+		    else {
+			s->vt100.state = (int)numberof(s->vt100.seq);
+		    }
+		} while (0);
+		if (wc != L';') {
+		    constat_apply(h, s, wc);
+		    s->vt100.state = constat_init;
+		}
+	    }
+	    rest = 0;
+	}
+	else {
+	    continue;
+	}
+	*ptrp = ptr;
+	*lenp = len;
+	return rest;
+    }
+    len = *lenp;
+    *ptrp = ptr;
+    *lenp = 0;
+    return len;
+}
+
+
+/* License: Ruby's */
+int
+rb_w32_close(int fd)
+{
+    SOCKET sock = TO_SOCKET(fd);
+    int save_errno = errno;
+
+    if (!is_socket(sock)) {
+	UnlockFile((HANDLE)sock, 0, 0, LK_LEN, LK_LEN);
+	constat_delete((HANDLE)sock);
+	return _close(fd);
+    }
+    _set_osfhnd(fd, (SOCKET)INVALID_HANDLE_VALUE);
+    socklist_delete(&sock, NULL);
+    _close(fd);
+    errno = save_errno;
+    if (closesocket(sock) == SOCKET_ERROR) {
+	errno = map_errno(WSAGetLastError());
+	return -1;
+    }
+    return 0;
+}
+
+static int
+setup_overlapped(OVERLAPPED *ol, int fd, int iswrite)
+{
+    memset(ol, 0, sizeof(*ol));
+    if (!(_osfile(fd) & (FDEV | FPIPE))) {
+	LONG high = 0;
+	/* On mode:a, it can write only FILE_END.
+	 * On mode:a+, though it can write only FILE_END,
+	 * it can read from everywhere.
+	 */
+	DWORD method = ((_osfile(fd) & FAPPEND) && iswrite) ? FILE_END : FILE_CURRENT;
+	DWORD low = SetFilePointer((HANDLE)_osfhnd(fd), 0, &high, method);
+#ifndef INVALID_SET_FILE_POINTER
+#define INVALID_SET_FILE_POINTER ((DWORD)-1)
+#endif
+	if (low == INVALID_SET_FILE_POINTER) {
+	    DWORD err = GetLastError();
+	    if (err != NO_ERROR) {
+		errno = map_errno(err);
+		return -1;
+	    }
+	}
+	ol->Offset = low;
+	ol->OffsetHigh = high;
+    }
+    ol->hEvent = CreateEvent(NULL, TRUE, TRUE, NULL);
+    if (!ol->hEvent) {
+	errno = map_errno(GetLastError());
+	return -1;
+    }
+    return 0;
+}
+
+static void
+finish_overlapped(OVERLAPPED *ol, int fd, DWORD size)
+{
+    CloseHandle(ol->hEvent);
+
+    if (!(_osfile(fd) & (FDEV | FPIPE))) {
+	LONG high = ol->OffsetHigh;
+	DWORD low = ol->Offset + size;
+	if (low < ol->Offset)
+	    ++high;
+	SetFilePointer((HANDLE)_osfhnd(fd), low, &high, FILE_BEGIN);
+    }
+}
+
+#undef read
+/* License: Ruby's */
+ssize_t
+rb_w32_read(int fd, void *buf, size_t size)
+{
+    SOCKET sock = TO_SOCKET(fd);
+    DWORD read;
+    DWORD wait;
+    DWORD err;
+    size_t len;
+    size_t ret;
+    OVERLAPPED ol, *pol = NULL;
+    BOOL isconsole;
+    BOOL islineinput = FALSE;
+    int start = 0;
+
+    if (is_socket(sock))
+	return rb_w32_recv(fd, buf, size, 0);
+
+    // validate fd by using _get_osfhandle() because we cannot access _nhandle
+    if (_get_osfhandle(fd) == -1) {
+	return -1;
+    }
+
+    if (_osfile(fd) & FTEXT) {
+	return _read(fd, buf, size);
+    }
+
+    MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fd)->lock)));
+
+    if (!size || _osfile(fd) & FEOFLAG) {
+	_set_osflags(fd, _osfile(fd) & ~FEOFLAG);
+	MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+	return 0;
+    }
+
+    ret = 0;
+    isconsole = is_console(_osfhnd(fd)) && (osver.dwMajorVersion < 6 || (osver.dwMajorVersion == 6 && osver.dwMinorVersion < 2));
+    if (isconsole) {
+	DWORD mode;
+	GetConsoleMode((HANDLE)_osfhnd(fd),&mode);
+	islineinput = (mode & ENABLE_LINE_INPUT) != 0;
+    }
+  retry:
+    /* get rid of console reading bug */
+    if (isconsole) {
+	constat_reset((HANDLE)_osfhnd(fd));
+	if (start)
+	    len = 1;
+	else {
+	    len = 0;
+	    start = 1;
+	}
+    }
+    else
+	len = size;
+    size -= len;
+
+    /* if have cancel_io, use Overlapped I/O */
+    if (cancel_io) {
+	if (setup_overlapped(&ol, fd, FALSE)) {
+	    MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+	    return -1;
+	}
+
+	pol = &ol;
+    }
+
+    if (!ReadFile((HANDLE)_osfhnd(fd), buf, len, &read, pol)) {
+	err = GetLastError();
+	if (err == ERROR_NO_DATA && (_osfile(fd) & FPIPE)) {
+	    DWORD state;
+	    if (GetNamedPipeHandleState((HANDLE)_osfhnd(fd), &state, NULL, NULL, NULL, NULL, 0) && (state & PIPE_NOWAIT)) {
+		errno = EWOULDBLOCK;
+	    }
+	    else {
+		errno = map_errno(err);
+	    }
+	    MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+	    return -1;
+	}
+	else if (err != ERROR_IO_PENDING) {
+	    if (pol) CloseHandle(ol.hEvent);
+	    if (err == ERROR_ACCESS_DENIED)
+		errno = EBADF;
+	    else if (err == ERROR_BROKEN_PIPE || err == ERROR_HANDLE_EOF) {
+		MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+		return 0;
+	    }
+	    else
+		errno = map_errno(err);
+
+	    MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+	    return -1;
+	}
+
+	if (pol) {
+	    wait = rb_w32_wait_events_blocking(&ol.hEvent, 1, INFINITE);
+	    if (wait != WAIT_OBJECT_0) {
+		if (wait == WAIT_OBJECT_0 + 1)
+		    errno = EINTR;
+		else
+		    errno = map_errno(GetLastError());
+		CloseHandle(ol.hEvent);
+		cancel_io((HANDLE)_osfhnd(fd));
+		MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+		return -1;
+	    }
+
+	    if (!GetOverlappedResult((HANDLE)_osfhnd(fd), &ol, &read, TRUE) &&
+		(err = GetLastError()) != ERROR_HANDLE_EOF) {
+		int ret = 0;
+		if (err != ERROR_BROKEN_PIPE) {
+		    errno = map_errno(err);
+		    ret = -1;
+		}
+		CloseHandle(ol.hEvent);
+		cancel_io((HANDLE)_osfhnd(fd));
+		MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+		return ret;
+	    }
+	}
+    }
+    else {
+	err = GetLastError();
+	errno = map_errno(err);
+    }
+
+    if (pol) {
+	finish_overlapped(&ol, fd, read);
+    }
+
+    ret += read;
+    if (read >= len) {
+	buf = (char *)buf + read;
+	if (err != ERROR_OPERATION_ABORTED &&
+	    !(isconsole && len == 1 && (!islineinput || *((char *)buf - 1) == '\n')) && size > 0)
+	    goto retry;
+    }
+    if (read == 0)
+	_set_osflags(fd, _osfile(fd) | FEOFLAG);
+
+
+    MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+
+    return ret;
+}
+
+#undef write
+/* License: Ruby's */
+ssize_t
+rb_w32_write(int fd, const void *buf, size_t size)
+{
+    SOCKET sock = TO_SOCKET(fd);
+    DWORD written;
+    DWORD wait;
+    DWORD err;
+    size_t len;
+    size_t ret;
+    OVERLAPPED ol, *pol = NULL;
+
+    if (is_socket(sock))
+	return rb_w32_send(fd, buf, size, 0);
+
+    // validate fd by using _get_osfhandle() because we cannot access _nhandle
+    if (_get_osfhandle(fd) == -1) {
+	return -1;
+    }
+
+    if ((_osfile(fd) & FTEXT) &&
+        (!(_osfile(fd) & FPIPE) || fd == fileno(stdout) || fd == fileno(stderr))) {
+	return _write(fd, buf, size);
+    }
+
+    MTHREAD_ONLY(EnterCriticalSection(&(_pioinfo(fd)->lock)));
+
+    if (!size || _osfile(fd) & FEOFLAG) {
+	MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+	return 0;
+    }
+
+    ret = 0;
+  retry:
+    /* get rid of console writing bug */
+    len = (_osfile(fd) & FDEV) ? min(32 * 1024, size) : size;
+    size -= len;
+  retry2:
+
+    /* if have cancel_io, use Overlapped I/O */
+    if (cancel_io) {
+	if (setup_overlapped(&ol, fd, TRUE)) {
+	    MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+	    return -1;
+	}
+
+	pol = &ol;
+    }
+
+    if (!WriteFile((HANDLE)_osfhnd(fd), buf, len, &written, pol)) {
+	err = GetLastError();
+	if (err != ERROR_IO_PENDING) {
+	    if (pol) CloseHandle(ol.hEvent);
+	    if (err == ERROR_ACCESS_DENIED)
+		errno = EBADF;
+	    else
+		errno = map_errno(err);
+
+	    MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+	    return -1;
+	}
+
+	if (pol) {
+	    wait = rb_w32_wait_events_blocking(&ol.hEvent, 1, INFINITE);
+	    if (wait != WAIT_OBJECT_0) {
+		if (wait == WAIT_OBJECT_0 + 1)
+		    errno = EINTR;
+		else
+		    errno = map_errno(GetLastError());
+		CloseHandle(ol.hEvent);
+		cancel_io((HANDLE)_osfhnd(fd));
+		MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+		return -1;
+	    }
+
+	    if (!GetOverlappedResult((HANDLE)_osfhnd(fd), &ol, &written,
+				     TRUE)) {
+		errno = map_errno(GetLastError());
+		CloseHandle(ol.hEvent);
+		cancel_io((HANDLE)_osfhnd(fd));
+		MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+		return -1;
+	    }
+	}
+    }
+
+    if (pol) {
+	finish_overlapped(&ol, fd, written);
+    }
+
+    ret += written;
+    if (written == len) {
+	buf = (const char *)buf + len;
+	if (size > 0)
+	    goto retry;
+    }
+    if (ret == 0) {
+	size_t newlen = len / 2;
+	if (newlen > 0) {
+	    size += len - newlen;
+	    len = newlen;
+	    goto retry2;
+	}
+	ret = -1;
+	errno = EWOULDBLOCK;
+    }
+
+    MTHREAD_ONLY(LeaveCriticalSection(&_pioinfo(fd)->lock));
+
+    return ret;
+}
+
+/* License: Ruby's */
+long
+rb_w32_write_console(uintptr_t strarg, int fd)
+{
+    static int disable;
+    HANDLE handle;
+    DWORD dwMode, reslen;
+    VALUE str = strarg;
+    int encindex;
+    WCHAR *wbuffer = 0;
+    const WCHAR *ptr, *next;
+    struct constat *s;
+    long len;
+
+    if (disable) return -1L;
+    handle = (HANDLE)_osfhnd(fd);
+    if (!GetConsoleMode(handle, &dwMode))
+	return -1L;
+
+    s = constat_handle(handle);
+    if (!s) return -1L;
+    encindex = ENCODING_GET(str);
+    switch (encindex) {
+      default:
+	if (!rb_econv_has_convpath_p(rb_enc_name(rb_enc_from_index(encindex)), "UTF-8"))
+	    return -1L;
+	str = rb_str_conv_enc_opts(str, NULL, rb_enc_from_index(ENCINDEX_UTF_8),
+				   ECONV_INVALID_REPLACE|ECONV_UNDEF_REPLACE, Qnil);
+	/* fall through */
+      case ENCINDEX_US_ASCII:
+      case ENCINDEX_ASCII:
+	/* assume UTF-8 */
+      case ENCINDEX_UTF_8:
+	ptr = wbuffer = mbstr_to_wstr(CP_UTF8, RSTRING_PTR(str), RSTRING_LEN(str), &len);
+	if (!ptr) return -1L;
+	break;
+      case ENCINDEX_UTF_16LE:
+	ptr = (const WCHAR *)RSTRING_PTR(str);
+	len = RSTRING_LEN(str) / sizeof(WCHAR);
+	break;
+    }
+    while (len > 0) {
+	long curlen = constat_parse(handle, s, (next = ptr, &next), &len);
+	if (curlen > 0) {
+	    if (!WriteConsoleW(handle, ptr, curlen, &reslen, NULL)) {
+		if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
+		    disable = TRUE;
+		reslen = (DWORD)-1L;
+		break;
+	    }
+	}
+	ptr = next;
+    }
+    RB_GC_GUARD(str);
+    if (wbuffer) free(wbuffer);
+    return (long)reslen;
+}
+
+/* License: Ruby's */
+static int
+unixtime_to_filetime(time_t time, FILETIME *ft)
+{
+    ULARGE_INTEGER tmp;
+
+    tmp.QuadPart = ((LONG_LONG)time + (LONG_LONG)((1970-1601)*365.2425) * 24 * 60 * 60) * 10 * 1000 * 1000;
+    ft->dwLowDateTime = tmp.LowPart;
+    ft->dwHighDateTime = tmp.HighPart;
+    return 0;
+}
+
+/* License: Ruby's */
+static int
+wutime(const WCHAR *path, const struct utimbuf *times)
+{
+    HANDLE hFile;
+    FILETIME atime, mtime;
+    struct stati64 stat;
+    int ret = 0;
+
+    if (wstati64(path, &stat)) {
+	return -1;
+    }
+
+    if (times) {
+	if (unixtime_to_filetime(times->actime, &atime)) {
+	    return -1;
+	}
+	if (unixtime_to_filetime(times->modtime, &mtime)) {
+	    return -1;
+	}
+    }
+    else {
+	GetSystemTimeAsFileTime(&atime);
+	mtime = atime;
+    }
+
+    RUBY_CRITICAL({
+	const DWORD attr = GetFileAttributesW(path);
+	if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY))
+	    SetFileAttributesW(path, attr & ~FILE_ATTRIBUTE_READONLY);
+	hFile = CreateFileW(path, GENERIC_WRITE, 0, 0, OPEN_EXISTING,
+			    FILE_FLAG_BACKUP_SEMANTICS, 0);
+	if (hFile == INVALID_HANDLE_VALUE) {
+	    errno = map_errno(GetLastError());
+	    ret = -1;
+	}
+	else {
+	    if (!SetFileTime(hFile, NULL, &atime, &mtime)) {
+		errno = map_errno(GetLastError());
+		ret = -1;
+	    }
+	    CloseHandle(hFile);
+	}
+	if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY))
+	    SetFileAttributesW(path, attr);
+    });
+
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_uutime(const char *path, const struct utimbuf *times)
+{
+    WCHAR *wpath;
+    int ret;
+
+    if (!(wpath = utf8_to_wstr(path, NULL)))
+	return -1;
+    ret = wutime(wpath, times);
+    free(wpath);
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_utime(const char *path, const struct utimbuf *times)
+{
+    WCHAR *wpath;
+    int ret;
+
+    if (!(wpath = filecp_to_wstr(path, NULL)))
+	return -1;
+    ret = wutime(wpath, times);
+    free(wpath);
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_uchdir(const char *path)
+{
+    WCHAR *wpath;
+    int ret;
+
+    if (!(wpath = utf8_to_wstr(path, NULL)))
+	return -1;
+    ret = _wchdir(wpath);
+    free(wpath);
+    return ret;
+}
+
+/* License: Ruby's */
+static int
+wmkdir(const WCHAR *wpath, int mode)
+{
+    int ret = -1;
+
+    RUBY_CRITICAL(do {
+	if (CreateDirectoryW(wpath, NULL) == FALSE) {
+	    errno = map_errno(GetLastError());
+	    break;
+	}
+	if (_wchmod(wpath, mode) == -1) {
+	    RemoveDirectoryW(wpath);
+	    break;
+	}
+	ret = 0;
+    } while (0));
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_umkdir(const char *path, int mode)
+{
+    WCHAR *wpath;
+    int ret;
+
+    if (!(wpath = utf8_to_wstr(path, NULL)))
+	return -1;
+    ret = wmkdir(wpath, mode);
+    free(wpath);
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_mkdir(const char *path, int mode)
+{
+    WCHAR *wpath;
+    int ret;
+
+    if (!(wpath = filecp_to_wstr(path, NULL)))
+	return -1;
+    ret = wmkdir(wpath, mode);
+    free(wpath);
+    return ret;
+}
+
+/* License: Ruby's */
+static int
+wrmdir(const WCHAR *wpath)
+{
+    int ret = 0;
+    RUBY_CRITICAL({
+	const DWORD attr = GetFileAttributesW(wpath);
+	if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) {
+	    SetFileAttributesW(wpath, attr & ~FILE_ATTRIBUTE_READONLY);
+	}
+	if (RemoveDirectoryW(wpath) == FALSE) {
+	    errno = map_errno(GetLastError());
+	    ret = -1;
+	    if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) {
+		SetFileAttributesW(wpath, attr);
+	    }
+	}
+    });
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_rmdir(const char *path)
+{
+    WCHAR *wpath;
+    int ret;
+
+    if (!(wpath = filecp_to_wstr(path, NULL)))
+	return -1;
+    ret = wrmdir(wpath);
+    free(wpath);
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_urmdir(const char *path)
+{
+    WCHAR *wpath;
+    int ret;
+
+    if (!(wpath = utf8_to_wstr(path, NULL)))
+	return -1;
+    ret = wrmdir(wpath);
+    free(wpath);
+    return ret;
+}
+
+/* License: Ruby's */
+static int
+wunlink(const WCHAR *path)
+{
+    int ret = 0;
+    RUBY_CRITICAL({
+	const DWORD attr = GetFileAttributesW(path);
+	if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) {
+	    SetFileAttributesW(path, attr & ~FILE_ATTRIBUTE_READONLY);
+	}
+	if (!DeleteFileW(path)) {
+	    errno = map_errno(GetLastError());
+	    ret = -1;
+	    if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) {
+		SetFileAttributesW(path, attr);
+	    }
+	}
+    });
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_uunlink(const char *path)
+{
+    WCHAR *wpath;
+    int ret;
+
+    if (!(wpath = utf8_to_wstr(path, NULL)))
+	return -1;
+    ret = wunlink(wpath);
+    free(wpath);
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_unlink(const char *path)
+{
+    WCHAR *wpath;
+    int ret;
+
+    if (!(wpath = filecp_to_wstr(path, NULL)))
+	return -1;
+    ret = wunlink(wpath);
+    free(wpath);
+    return ret;
+}
+
+/* License: Ruby's */
+int
+rb_w32_uchmod(const char *path, int mode)
+{
+    WCHAR *wpath;
+    int ret;
+
+    if (!(wpath = utf8_to_wstr(path, NULL)))
+	return -1;
+    ret = _wchmod(wpath, mode);
+    free(wpath);
+    return ret;
+}
+
+#if !defined(__BORLANDC__)
+/* License: Ruby's */
+int
+rb_w32_isatty(int fd)
+{
+    DWORD mode;
+
+    // validate fd by using _get_osfhandle() because we cannot access _nhandle
+    if (_get_osfhandle(fd) == -1) {
+	return 0;
+    }
+    if (!GetConsoleMode((HANDLE)_osfhnd(fd), &mode)) {
+	errno = ENOTTY;
+	return 0;
+    }
+    return 1;
+}
+#endif
+
+//
+// Fix bcc32's stdio bug
+//
+
+#ifdef __BORLANDC__
+/* License: Ruby's */
+static int
+too_many_files(void)
+{
+    FILE *f;
+    for (f = _streams; f < _streams + _nfile; f++) {
+	if (f->fd < 0) return 0;
+    }
+    return 1;
+}
+
+#undef fopen
+/* License: Ruby's */
+FILE *
+rb_w32_fopen(const char *path, const char *mode)
+{
+    FILE *f = (errno = 0, fopen(path, mode));
+    if (f == NULL && errno == 0) {
+	if (too_many_files())
+	    errno = EMFILE;
+    }
+    return f;
+}
+
+/* License: Ruby's */
+FILE *
+rb_w32_fdopen(int handle, const char *type)
+{
+    FILE *f = (errno = 0, _fdopen(handle, (char *)type));
+    if (f == NULL && errno == 0) {
+	if (handle < 0)
+	    errno = EBADF;
+	else if (too_many_files())
+	    errno = EMFILE;
+    }
+    return f;
+}
+
+/* License: Ruby's */
+FILE *
+rb_w32_fsopen(const char *path, const char *mode, int shflags)
+{
+    FILE *f = (errno = 0, _fsopen(path, mode, shflags));
+    if (f == NULL && errno == 0) {
+	if (too_many_files())
+	    errno = EMFILE;
+    }
+    return f;
+}
+#endif
+
+#if defined(_MSC_VER) && RUBY_MSVCRT_VERSION <= 60
+extern long _ftol(double);
+/* License: Ruby's */
+long
+_ftol2(double d)
+{
+    return _ftol(d);
+}
+
+/* License: Ruby's */
+long
+_ftol2_sse(double d)
+{
+    return _ftol(d);
+}
+#endif
+
+#ifndef signbit
+/* License: Ruby's */
+int
+signbit(double x)
+{
+    int *ip = (int *)(&x + 1) - 1;
+    return *ip < 0;
+}
+#endif
+
+/* License: Ruby's */
+const char * WSAAPI
+rb_w32_inet_ntop(int af, const void *addr, char *numaddr, size_t numaddr_len)
+{
+    typedef char *(WSAAPI inet_ntop_t)(int, void *, char *, size_t);
+    inet_ntop_t *pInetNtop;
+    pInetNtop = (inet_ntop_t *)get_proc_address("ws2_32", "inet_ntop", NULL);
+    if (pInetNtop) {
+	return pInetNtop(af, (void *)addr, numaddr, numaddr_len);
+    }
+    else {
+	struct in_addr in;
+	memcpy(&in.s_addr, addr, sizeof(in.s_addr));
+	snprintf(numaddr, numaddr_len, "%s", inet_ntoa(in));
+    }
+    return numaddr;
+}
+
+/* License: Ruby's */
+int WSAAPI
+rb_w32_inet_pton(int af, const char *src, void *dst)
+{
+    typedef int (WSAAPI inet_pton_t)(int, const char*, void *);
+    inet_pton_t *pInetPton;
+    pInetPton = (inet_pton_t *)get_proc_address("ws2_32", "inet_pton", NULL);
+    if (pInetPton) {
+	return pInetPton(af, src, dst);
+    }
+    return 0;
+}
+
+/* License: Ruby's */
+char
+rb_w32_fd_is_text(int fd)
+{
+    return _osfile(fd) & FTEXT;
+}
+
+#if RUBY_MSVCRT_VERSION < 80 && !defined(HAVE__GMTIME64_S)
+/* License: Ruby's */
+static int
+unixtime_to_systemtime(const time_t t, SYSTEMTIME *st)
+{
+    FILETIME ft;
+    if (unixtime_to_filetime(t, &ft)) return -1;
+    if (!FileTimeToSystemTime(&ft, st)) return -1;
+    return 0;
+}
+
+/* License: Ruby's */
+static void
+systemtime_to_tm(const SYSTEMTIME *st, struct tm *t)
+{
+    int y = st->wYear, m = st->wMonth, d = st->wDay;
+    t->tm_sec  = st->wSecond;
+    t->tm_min  = st->wMinute;
+    t->tm_hour = st->wHour;
+    t->tm_mday = st->wDay;
+    t->tm_mon  = st->wMonth - 1;
+    t->tm_year = y - 1900;
+    t->tm_wday = st->wDayOfWeek;
+    switch (m) {
+      case 1:
+	break;
+      case 2:
+	d += 31;
+	break;
+      default:
+	d += 31 + 28 + (!(y % 4) && ((y % 100) || !(y % 400)));
+	d += ((m - 3) * 153 + 2) / 5;
+	break;
+    }
+    t->tm_yday = d - 1;
+}
+
+/* License: Ruby's */
+static int
+systemtime_to_localtime(TIME_ZONE_INFORMATION *tz, SYSTEMTIME *gst, SYSTEMTIME *lst)
+{
+    TIME_ZONE_INFORMATION stdtz;
+    SYSTEMTIME sst;
+
+    if (!SystemTimeToTzSpecificLocalTime(tz, gst, lst)) return -1;
+    if (!tz) {
+	GetTimeZoneInformation(&stdtz);
+	tz = &stdtz;
+    }
+    if (tz->StandardBias == tz->DaylightBias) return 0;
+    if (!tz->StandardDate.wMonth) return 0;
+    if (!tz->DaylightDate.wMonth) return 0;
+    if (tz != &stdtz) stdtz = *tz;
+
+    stdtz.StandardDate.wMonth = stdtz.DaylightDate.wMonth = 0;
+    if (!SystemTimeToTzSpecificLocalTime(&stdtz, gst, &sst)) return 0;
+    if (lst->wMinute == sst.wMinute && lst->wHour == sst.wHour)
+	return 0;
+    return 1;
+}
+#endif
+
+#ifdef HAVE__GMTIME64_S
+# ifndef HAVE__LOCALTIME64_S
+/* assume same as _gmtime64_s() */
+#  define HAVE__LOCALTIME64_S 1
+# endif
+# ifndef MINGW_HAS_SECURE_API
+   _CRTIMP errno_t __cdecl _gmtime64_s(struct tm* tm, const __time64_t *time);
+   _CRTIMP errno_t __cdecl _localtime64_s(struct tm* tm, const __time64_t *time);
+# endif
+# define gmtime_s _gmtime64_s
+# define localtime_s _localtime64_s
+#endif
+
+/* License: Ruby's */
+struct tm *
+gmtime_r(const time_t *tp, struct tm *rp)
+{
+    int e = EINVAL;
+    if (!tp || !rp) {
+      error:
+	errno = e;
+	return NULL;
+    }
+#if RUBY_MSVCRT_VERSION >= 80 || defined(HAVE__GMTIME64_S)
+    e = gmtime_s(rp, tp);
+    if (e != 0) goto error;
+#else
+    {
+	SYSTEMTIME st;
+	if (unixtime_to_systemtime(*tp, &st)) goto error;
+	rp->tm_isdst = 0;
+	systemtime_to_tm(&st, rp);
+    }
+#endif
+    return rp;
+}
+
+/* License: Ruby's */
+struct tm *
+localtime_r(const time_t *tp, struct tm *rp)
+{
+    int e = EINVAL;
+    if (!tp || !rp) {
+      error:
+	errno = e;
+	return NULL;
+    }
+#if RUBY_MSVCRT_VERSION >= 80 || defined(HAVE__LOCALTIME64_S)
+    e = localtime_s(rp, tp);
+    if (e) goto error;
+#else
+    {
+	SYSTEMTIME gst, lst;
+	if (unixtime_to_systemtime(*tp, &gst)) goto error;
+	rp->tm_isdst = systemtime_to_localtime(NULL, &gst, &lst);
+	systemtime_to_tm(&lst, rp);
+    }
+#endif
+    return rp;
+}
+
+/* License: Ruby's */
+int
+rb_w32_wrap_io_handle(HANDLE h, int flags)
+{
+    BOOL tmp;
+    int len = sizeof(tmp);
+    int r = getsockopt((SOCKET)h, SOL_SOCKET, SO_DEBUG, (char *)&tmp, &len);
+    if (r != SOCKET_ERROR || WSAGetLastError() != WSAENOTSOCK) {
+        int f = 0;
+        if (flags & O_NONBLOCK) {
+            flags &= ~O_NONBLOCK;
+            f = O_NONBLOCK;
+        }
+        socklist_insert((SOCKET)h, f);
+    }
+    else if (flags & O_NONBLOCK) {
+        errno = EINVAL;
+        return -1;
+    }
+    return rb_w32_open_osfhandle((intptr_t)h, flags);
+}
+
+/* License: Ruby's */
+int
+rb_w32_unwrap_io_handle(int fd)
+{
+    SOCKET sock = TO_SOCKET(fd);
+    _set_osfhnd(fd, (SOCKET)INVALID_HANDLE_VALUE);
+    if (!is_socket(sock)) {
+	UnlockFile((HANDLE)sock, 0, 0, LK_LEN, LK_LEN);
+	constat_delete((HANDLE)sock);
+    }
+    else {
+	socklist_delete(&sock, NULL);
+    }
+    return _close(fd);
+}
+
+#if !defined(__MINGW64__) && defined(__MINGW64_VERSION_MAJOR)
+/*
+ * Set floating point precision for pow() of mingw-w64 x86.
+ * With default precision the result is not proper on WinXP.
+ */
+double
+rb_w32_pow(double x, double y)
+{
+#undef pow
+    double r;
+    unsigned int default_control = _controlfp(0, 0);
+    _controlfp(_PC_64, _MCW_PC);
+    r = pow(x, y);
+    /* Restore setting */
+    _controlfp(default_control, _MCW_PC);
+    return r;
+}
+#endif
+
+#if RUBY_MSVCRT_VERSION < 120
+#include "missing/nextafter.c"
+#endif
diff --git a/jni/ruby/win32/winmain.c b/jni/ruby/win32/winmain.c
new file mode 100644
index 0000000..467a835
--- /dev/null
+++ b/jni/ruby/win32/winmain.c
@@ -0,0 +1,10 @@
+#include <windows.h>
+#include <stdio.h>
+
+extern int main(int, char**);
+
+int WINAPI
+WinMain(HINSTANCE current, HINSTANCE prev, LPSTR cmdline, int showcmd)
+{
+    return main(0, NULL);
+}