summaryrefslogtreecommitdiff
path: root/ruby_1_8_6/win32
diff options
context:
space:
mode:
Diffstat (limited to 'ruby_1_8_6/win32')
-rw-r--r--ruby_1_8_6/win32/Makefile.sub522
-rw-r--r--ruby_1_8_6/win32/README.win32126
-rwxr-xr-xruby_1_8_6/win32/configure.bat100
-rw-r--r--ruby_1_8_6/win32/dir.h39
-rwxr-xr-xruby_1_8_6/win32/ifchange.bat32
-rwxr-xr-xruby_1_8_6/win32/mkexports.rb37
-rwxr-xr-xruby_1_8_6/win32/resource.rb95
-rwxr-xr-xruby_1_8_6/win32/rm.bat8
-rw-r--r--ruby_1_8_6/win32/setup.mak182
-rw-r--r--ruby_1_8_6/win32/win32.c3961
-rw-r--r--ruby_1_8_6/win32/win32.h560
-rw-r--r--ruby_1_8_6/win32/winmain.c10
12 files changed, 5672 insertions, 0 deletions
diff --git a/ruby_1_8_6/win32/Makefile.sub b/ruby_1_8_6/win32/Makefile.sub
new file mode 100644
index 0000000000..955f634862
--- /dev/null
+++ b/ruby_1_8_6/win32/Makefile.sub
@@ -0,0 +1,522 @@
+# -*- makefile -*-
+
+SHELL = $(COMSPEC)
+MKFILES = Makefile
+NULL = nul
+
+#### Start of system configuration section. ####
+
+## variables may be overridden by $(compile_dir)/Makefile
+!ifndef srcdir
+srcdir = ..
+!endif
+!ifndef RUBY_INSTALL_NAME
+RUBY_INSTALL_NAME = ruby$(RUBY_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
+!if !defined(icondirs) && defined(ICONDIRS)
+icondirs=$(ICONDIRS)
+!endif
+!if defined(icondirs)
+icondirs=$(icondirs:\=/)
+iconinc=-I$(icondirs: = -I)
+!endif
+###############
+
+VPATH = $(srcdir);$(srcdir)/missing;$(srcdir)/win32
+.SUFFIXES: .y .def .lib
+
+!if !defined(CC)
+CC = cl
+!endif
+!if !defined(CPP) || "$(CPP)" == "cl"
+CPP = $(CC) -E
+!endif
+!if !defined(YACC)
+YACC = byacc
+!endif
+AR = lib -nologo
+PURIFY =
+AUTOCONF = autoconf
+RM = $(COMSPEC) /C $(srcdir:/=\)\win32\rm.bat
+
+!if !defined(PROCESSOR_ARCHITECTURE)
+PROCESSOR_ARCHITECTURE = x86
+!endif
+MACHINE = $(PROCESSOR_ARCHITECTURE)
+!if "$(PROCESSOR_ARCHITECTURE)" == "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 = $(PROCESSOR_ARCHITECTURE)
+ARCH = $(PROCESSOR_ARCHITECTURE)
+!endif
+!if !defined(DEBUGFLAGS) && $(MSC_VER) < 1400
+DEBUGFLAGS = -Zi
+!endif
+!if !defined(OPTFLAGS)
+!if $(MSC_VER) < 1400
+OPTFLAGS = -O2b2xg-
+!else
+OPTFLAGS = -O2b2xty-
+!endif
+!endif
+!if !defined(OS)
+OS = mswin32
+!endif
+!if !defined(RT)
+!error RT not defined. Retry from configure pass.
+!endif
+
+!ifndef RUBY_SO_NAME
+RUBY_SO_NAME = $(RT)-$(RUBY_INSTALL_NAME)$(MAJOR)$(MINOR)
+!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 = /share
+!endif
+!ifndef EXTOUT
+EXTOUT = .ext
+!endif
+!ifndef RIDATADIR
+RIDATADIR = $(DESTDIR)$(datadir)/ri/$(MAJOR).$(MINOR)/system
+!endif
+!ifndef TESTUI
+TESTUI = console
+!endif
+!ifndef TESTS
+TESTS =
+!endif
+!ifndef RDOCTARGET
+RDOCTARGET = install-nodoc
+!endif
+
+OUTFLAG = -Fe
+!if !defined(CFLAGS)
+CFLAGS = -MD $(DEBUGFLAGS) $(OPTFLAGS) $(PROCESSOR_FLAG)
+!endif
+!if !defined(LDFLAGS)
+LDFLAGS = -link -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
+LIBS = oldnames.lib user32.lib advapi32.lib shell32.lib
+!if !defined(USE_WINSOCK2)
+LIBS = $(LIBS) wsock32.lib
+!else
+LIBS = $(LIBS) ws2_32.lib
+!endif
+LIBS = $(LIBS) $(EXTLIBS)
+MISSING = acosh.obj crypt.obj erf.obj win32.obj
+
+ARFLAGS = -machine:$(MACHINE) -out:
+CC = $(CC) -nologo
+LD = $(CC)
+LDSHARED = $(LD) -LD
+XCFLAGS = -DRUBY_EXPORT -I. -I$(srcdir) -I$(srcdir)/missing
+!if $(MSC_VER) >= 1400
+# Prevents VC++ 2005 (cl ver 14) warnings
+CPPFLAGS = $(CPPFLAGS) -D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE
+MANIFESTTOOL = mt -nologo
+LDSHARED_1 = $(MANIFESTTOOL) -manifest $(@).manifest -outputresource:$(@);2
+LDSHARED_2 = @$(RM) $(@:/=\).manifest
+!endif
+
+DLDFLAGS = $(LDFLAGS) -dll
+SOLIBS =
+
+LIBRUBY_LDSHARED = $(LDSHARED)
+LIBRUBY_DLDFLAGS = $(EXTLDFLAGS) -def:$(RUBYDEF)
+
+EXEEXT = .exe
+PROGRAM=$(RUBY_INSTALL_NAME)$(EXEEXT)
+WPROGRAM=$(RUBYW_INSTALL_NAME)$(EXEEXT)
+RUBYDEF = $(RUBY_SO_NAME).def
+MINIRUBY = .\miniruby$(EXEEXT) $(MINIRUBYOPT)
+RUNRUBY = .\ruby$(EXEEXT) "$(srcdir)/runruby.rb" --extout="$(EXTOUT)" --
+
+!if !defined(STACK)
+STACK = 0x2000000
+!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)
+
+PREP = miniruby$(EXEEXT)
+
+!if !defined(EXTSTATIC)
+EXTSTATIC =
+!endif
+
+OBJEXT = obj
+
+INSTALLED_LIST= .installed.list
+
+WINMAINOBJ = winmain.$(OBJEXT)
+MINIOBJS = dmydln.$(OBJEXT)
+
+all: $(srcdir)/win32/Makefile.sub $(srcdir)/common.mk
+
+ruby: $(PROGRAM)
+rubyw: $(WPROGRAM)
+
+!include $(srcdir)/common.mk
+
+CONFIG_H = ./.config.h.time
+
+config: config.status
+
+config.status: $(CONFIG_H)
+
+$(CONFIG_H): $(MKFILES) $(srcdir)/win32/Makefile.sub
+ @echo Creating config.h
+ @$(COMSPEC) /C $(srcdir:/=\)\win32\ifchange.bat config.h <<
+#if _MSC_VER != $(MSC_VER)
+#error MSC version unmatch
+#endif
+!if defined(USE_WINSOCK2)
+#define USE_WINSOCK2 1
+!endif
+#define STDC_HEADERS 1
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_SYS_STAT_H 1
+#define HAVE_STDLIB_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 SIZEOF_OFF_T 4
+#define SIZEOF_VOIDP 4
+#define SIZEOF_FLOAT 4
+#define SIZEOF_DOUBLE 8
+!if $(MSC_VER) >= 1400
+#define SIZEOF_TIME_T 8
+!else
+#define SIZEOF_TIME_T 4
+!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
+#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 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 GETGROUPS_T int
+#define RETSIGTYPE void
+#define HAVE_ALLOCA 1
+#define HAVE_DUP2 1
+#define HAVE_MEMCMP 1
+#define HAVE_MEMMOVE 1
+#define HAVE_MKDIR 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_VSNPRINTF 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_CHSIZE 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_TZNAME 1
+#define HAVE_DAYLIGHT 1
+#define SETPGRP_VOID 1
+#define RSHIFT(x,y) ((x)>>(int)y)
+#define FILE_COUNT _cnt
+#define FILE_READPTR _ptr
+#define inline __inline
+#define NEED_IO_SEEK_BETWEEN_RW 1
+#define STACK_GROW_DIRECTION -1
+#define DEFAULT_KCODE KCODE_NONE
+#define DLEXT ".so"
+#define DLEXT2 ".dll"
+#define RUBY_LIB "/lib/ruby/$(MAJOR).$(MINOR)"
+#define RUBY_SITE_LIB "/lib/ruby/site_ruby"
+#define RUBY_SITE_LIB2 "/lib/ruby/site_ruby/$(MAJOR).$(MINOR)"
+#define RUBY_PLATFORM "$(ARCH)-$(OS)"
+#define RUBY_ARCHLIB "/lib/ruby/$(MAJOR).$(MINOR)/$(ARCH)-$(OS)"
+#define RUBY_SITE_ARCHLIB "/lib/ruby/site_ruby/$(MAJOR).$(MINOR)/$(ARCH)-$(RT)"
+<<
+ @exit > $(@:/=\)
+
+config.status: $(MKFILES) $(srcdir)/win32/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,@CPPFLAGS@,$(CPPFLAGS),;t t
+s,@CXXFLAGS@,$(CXXFLAGS),;t t
+s,@FFLAGS@,$(FFLAGS),;t t
+s,@LDFLAGS@,,;t t
+s,@LIBS@,$(LIBS),;t t
+s,@exec_prefix@,$${prefix},;t t
+s,@prefix@,,;t t
+s,@program_transform_name@,s,$$,$(RUBY_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@,$${prefix}/info,;t t
+s,@mandir@,$${prefix}/man,;t t
+s,@build@,$(CPU)-pc-$(OS),;t t
+s,@build_alias@,$(CPU)-$(OS),;t t
+s,@build_cpu@,$(CPU),;t t
+s,@build_vendor@,pc,;t t
+s,@build_os@,$(OS),;t t
+s,@host@,$(CPU)-pc-$(OS),;t t
+s,@host_alias@,$(CPU)-$(OS),;t t
+s,@host_cpu@,$(CPU),;t t
+s,@host_vendor@,pc,;t t
+s,@host_os@,$(OS),;t t
+s,@target@,$(ARCH)-pc-$(OS),;t t
+s,@target_alias@,$(ARCH)-$(OS),;t t
+s,@target_cpu@,$(ARCH),;t t
+s,@target_vendor@,pc,;t t
+s,@target_os@,$(OS),;t t
+s,@CC@,$(CC),;t t
+s,@CPP@,$(CPP),;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@,$(SET_MAKE),;t t
+s,@CP@,copy > nul,;t t
+s,@LIBOBJS@, acosh.obj crypt.obj erf.obj win32.obj,;t t
+s,@ALLOCA@,$(ALLOCA),;t t
+s,@DEFAULT_KCODE@,$(DEFAULT_KCODE),;t t
+s,@EXEEXT@,.exe,;t t
+s,@OBJEXT@,$(OBJEXT),;t t
+s,@XCFLAGS@,$(XCFLAGS),;t t
+s,@XLDFLAGS@,$(XLDFLAGS),;t t
+s,@DLDFLAGS@,$(DLDFLAGS) $$(LIBPATH) -def:$$(DEFFILE) -implib:$$(*F:.so=)-$$(arch).lib -pdb:$$(*F:.so=)-$$(arch).pdb,;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,@DLEXT2@,dll,;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@,$(RDOCTARGET),;t t
+s,@LIBRUBY_LDSHARED@,$(LIBRUBY_LDSHARED),;t t
+s,@LIBRUBY_DLDFLAGS@,$(LIBRUBY_DLDFLAGS),;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,@OUTFLAG@,$(OUTFLAG),;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) $$(DLDFLAGS),;t t
+!if $(MSC_VER) >= 1400
+s,@LINK_SO@,$(MANIFESTTOOL) -manifest $$(@).manifest -outputresource:$$(@);2,;t t
+s,@LINK_SO@,@$$(RM) $$(@:/=\).manifest,;t t
+!endif
+s,@COMPILE_C@,$$(CC) $$(INCFLAGS) $$(CFLAGS) $$(CPPFLAGS) -c -Tc$$(<:\=/),;t t
+s,@COMPILE_CXX@,$$(CXX) $$(INCFLAGS) $$(CXXFLAGS) $$(CPPFLAGS) -c -Tp$$(<:\=/),;t t
+s,@COMPILE_RULES@,{$$(srcdir)}.%s{}.%s: {$$(topdir)}.%s{}.%s: {$$(hdrdir)}.%s{}.%s: .%s.%s:,;t t
+s,@RULE_SUBST@,{.;$$(srcdir);$$(topdir);$$(hdrdir)}%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@,m,;t t
+s,@COMMON_MACROS@,WIN32_LEAN_AND_MEAN WIN32,;t t
+!if defined(USE_WINSOCK2)
+s,@COMMON_HEADERS@,winsock2.h windows.h,;t t
+!else
+s,@COMMON_HEADERS@,windows.h winsock.h,;t t
+!endif
+s,@DISTCLEANFILES@,vc*.pdb,;t t
+s,@EXPORT_PREFIX@, ,;t t
+s,@arch@,$(ARCH)-$(OS),;t t
+s,@sitearch@,$(ARCH)-$(RT),;t t
+s,@sitedir@,$${prefix}/lib/ruby/site_ruby,;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
+<<KEEP
+
+miniruby$(EXEEXT):
+ @echo. $(LIBS)
+ $(PURIFY) $(CC) $(MAINOBJ) $(MINIOBJS) $(LIBRUBY_A) $(LIBS) -Fe$@ $(LDFLAGS)
+ $(LDSHARED_1)
+ $(LDSHARED_2)
+
+$(PROGRAM): $(RUBY_INSTALL_NAME).res
+ $(PURIFY) $(CC) $(MAINOBJ) $(RUBY_INSTALL_NAME).res \
+ $(OUTFLAG)$@ $(LIBRUBYARG) $(LDFLAGS) $(XLDFLAGS)
+ $(LDSHARED_1)
+ $(LDSHARED_2)
+
+$(WPROGRAM): $(MAINOBJ) $(WINMAINOBJ) $(LIBRUBY_SO) $(RUBYW_INSTALL_NAME).res
+ $(PURIFY) $(CC) $(MAINOBJ) $(WINMAINOBJ) \
+ $(RUBYW_INSTALL_NAME).res $(OUTFLAG)$@ $(LIBRUBYARG) \
+ $(LDFLAGS) $(XLDFLAGS) -subsystem:Windows
+ $(LDSHARED_1)
+ $(LDSHARED_2)
+
+$(LIBRUBY_A): $(OBJS) $(DMYEXT)
+ $(AR) $(ARFLAGS)$@ $(OBJS) $(DMYEXT)
+
+$(LIBRUBY): $(RUBYDEF)
+ $(AR) $(ARFLAGS)$@ -def:$(RUBYDEF)
+
+$(LIBRUBY_SO): $(LIBRUBY_A) $(DLDOBJS) $(RUBYDEF) $(RUBY_SO_NAME).res
+ @echo. $(DLDOBJS)
+ @-$(PRE_LIBRUBY_UPDATE)
+ $(LDSHARED) $(MAINOBJ) $(DLDOBJS) $(LIBRUBY_A) \
+ $(RUBY_SO_NAME).res $(LIBS) -Fe$@ $(LDFLAGS) \
+ $(LIBRUBY_DLDFLAGS)
+ $(LDSHARED_1)
+ $(LDSHARED_2)
+
+$(RUBYDEF): $(LIBRUBY_A) $(PREP)
+ $(MINIRUBY) $(srcdir)/win32/mkexports.rb -output=$@ $(LIBRUBY_A)
+
+{$(srcdir)/win32}.def.lib:
+ $(AR) $(ARFLAGS)$@ -def:$<
+
+clean-local::
+ @$(RM) ext\extinit.c ext\extinit.$(OBJEXT) ext\vc*.pdb miniruby.lib
+ @$(RM) $(RUBY_INSTALL_NAME).res $(RUBYW_INSTALL_NAME).res $(RUBY_SO_NAME).res
+
+distclean-local::
+ @$(RM) ext\config.cache $(RBCONFIG:/=\)
+ @$(RM) *.map *.pdb *.ilk *.exp $(RUBYDEF)
+ @$(RM) $(RUBY_INSTALL_NAME).rc $(RUBYW_INSTALL_NAME).rc $(RUBY_SO_NAME).rc
+
+$(RUBY_INSTALL_NAME).rc $(RUBYW_INSTALL_NAME).rc $(RUBY_SO_NAME).rc: $(RBCONFIG)
+ @$(MINIRUBY) $(srcdir)/win32/resource.rb \
+ -ruby_name=$(RUBY_INSTALL_NAME) \
+ -rubyw_name=$(RUBYW_INSTALL_NAME) \
+ -so_name=$(RUBY_SO_NAME) \
+ . $(icondirs) $(srcdir)/win32
+
+{$(srcdir)/missing}.c.obj:
+ $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -c -Tc$(<:\=/)
+{$(srcdir)/win32}.c.obj:
+ $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -c -Tc$(<:\=/)
+{$(srcdir)}.c.obj:
+ $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -c -Tc$(<:\=/)
+.c.obj:
+ $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -c -Tc$(<:\=/)
+
+.rc.res:
+ $(RC) -I. -I$(<D) $(iconinc) -I$(srcdir)/win32 $(RFLAGS) -fo$@ $(<:\=/)
+
+{$(srcdir)}.y.c:
+ $(YACC) $(YFLAGS) $(<:\=/)
+ sed -e "s!^ *extern char \*getenv();!/* & */!;s/^\(#.*\)y\.tab/\1parse/" y.tab.c > $@
+ @del y.tab.c
+
+$(OBJS): {$(srcdir)}win32/win32.h
+
+dir.$(OBJEXT): {$(srcdir)}win32/dir.h
+
+ext/extinit.obj: ext/extinit.c $(SETUP)
+ $(CC) $(CFLAGS) $(XCFLAGS) $(CPPFLAGS) -Fo$@ -c ext/extinit.c
diff --git a/ruby_1_8_6/win32/README.win32 b/ruby_1_8_6/win32/README.win32
new file mode 100644
index 0000000000..e7d589759c
--- /dev/null
+++ b/ruby_1_8_6/win32/README.win32
@@ -0,0 +1,126 @@
+=begin
+
+= How to build ruby using Visual C++
+
+== Requirement
+
+(1) Visual C++ 5.0 or later.
+
+(2) If you want to run `((%nmake clean%))' or `((%nmake distclean%))'
+ properly, you must install UNIX compatible `((%rm%))' command on
+ your ((|PATH|)) if you want to clean after compile.
+
+(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
+
+== 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 i686-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) If you want to make rubyw.exe, run `((%nmake rubyw.exe%))'
+
+(5) Run `((%nmake test%))'
+
+(6) Run `((%nmake DESTDIR=<install_directory> install%))'
+
+ This command will create following directories and install files onto them.
+ * <install_directory>\bin
+ * <install_directory>\lib
+ * <install_directory>\lib\ruby
+ * <install_directory>\lib\ruby\<MAJOR>.<MINOR>
+ * <install_directory>\lib\ruby\<MAJOR>.<MINOR>\<PLATFORM>
+ * <install_directory>\lib\ruby\site_ruby
+ * <install_directory>\lib\ruby\site_ruby\<MAJOR>.<MINOR>
+ * <install_directory>\lib\ruby\site_ruby\<MAJOR>.<MINOR>\<PLATFORM>
+ * <install_directory>\man\man1
+ If Ruby's version is `x.y.z', the ((|<MAJOR>|)) is `x' and the ((|<MINOR>|)) is `y'.
+ The default ((|<PLATFORM>|)) is `(({i386-mswin32}))'.
+
+== 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://member.nifty.ne.jp/ueivu/rubyico.html>)) or
+ ((<zipped icons|URL:http://member.nifty.ne.jp/ueivu/Ruby_ico.zip>))
+* ((<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
+ nmake
+ nmake test
+ nmake DESTDIR=/usr/local 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
+ nmake
+ nmake test
+ nmake DESTDIR=/usr/local 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
+ nmake
+ nmake test
+ nmake DESTDIR=C:/usr/local install
+
+== Bugs
+
+You can ((*NOT*)) use a path name 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. -))
+
+=end
diff --git a/ruby_1_8_6/win32/configure.bat b/ruby_1_8_6/win32/configure.bat
new file mode 100755
index 0000000000..f4f24a5ed7
--- /dev/null
+++ b/ruby_1_8_6/win32/configure.bat
@@ -0,0 +1,100 @@
+@echo off
+::: Don't set environment variable in batch file other than autoexec.bat
+::: to avoid "Out of environment space" problem on Windows 95/98.
+::: set TMPMAKE=~tmp~.mak
+
+echo> ~tmp~.mak ####
+echo>> ~tmp~.mak conf = %0
+echo>> ~tmp~.mak $(conf:\=/): nul
+echo>> ~tmp~.mak @del ~tmp~.mak
+echo>> ~tmp~.mak @-$(MAKE) -l$(MAKEFLAGS) -f $(@D)/setup.mak \
+:loop
+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" == "--with-winsock2" goto :winsock2
+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" == "--extout" goto :extout
+if "%1" == "-h" goto :help
+if "%1" == "--help" goto :help
+ echo>> ~tmp~.mak "%1" \
+ shift
+goto :loop
+:srcdir
+ echo>> ~tmp~.mak "srcdir=%2" \
+ shift
+ shift
+goto :loop
+:prefix
+ echo>> ~tmp~.mak "prefix=%2" \
+ shift
+ shift
+goto :loop
+:suffix
+ echo>> ~tmp~.mak "RUBY_SUFFIX=%2" \
+ shift
+ shift
+goto :loop
+:installname
+ echo>> ~tmp~.mak "RUBY_INSTALL_NAME=%2" \
+ shift
+ shift
+goto :loop
+:soname
+ echo>> ~tmp~.mak "RUBY_SO_NAME=%2" \
+ shift
+ shift
+goto :loop
+:target
+ echo>> ~tmp~.mak "%2" \
+ shift
+ shift
+goto :loop
+:extstatic
+ echo>> ~tmp~.mak "EXTSTATIC=static" \
+ shift
+goto :loop
+:winsock2
+ echo>> ~tmp~.mak "USE_WINSOCK2=1" \
+ shift
+goto :loop
+:enable-rdoc
+ echo>> ~tmp~.mak "RDOCTARGET=install-doc" \
+ shift
+goto :loop
+:disable-rdoc
+ echo>> ~tmp~.mak "RDOCTARGET=install-nodoc" \
+ shift
+goto :loop
+:extout
+ echo>> ~tmp~.mak "EXTOUT=%2" \
+ shift
+ 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 (ignored currently)
+ echo System types:
+ echo --target=TARGET configure for TARGET [i386-mswin32]
+ echo Optional Package:
+ echo --with-winsock2 link winsock2
+ echo --with-static-linked-ext link external modules statically
+ echo --enable-install-doc install rdoc indexes during install
+ del ~tmp~.mak
+goto :exit
+:end
+echo>> ~tmp~.mak WIN32DIR=$(@D)
+nmake -alf ~tmp~.mak
+:exit
diff --git a/ruby_1_8_6/win32/dir.h b/ruby_1_8_6/win32/dir.h
new file mode 100644
index 0000000000..183d9efc4a
--- /dev/null
+++ b/ruby_1_8_6/win32/dir.h
@@ -0,0 +1,39 @@
+#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[256];
+ char d_isdir; /* directory */
+ char d_isrep; /* reparse point */
+};
+typedef struct {
+ char *start;
+ char *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*);
+struct direct* rb_w32_readdir(DIR *);
+long rb_w32_telldir(DIR *);
+void rb_w32_seekdir(DIR *, long);
+void rb_w32_rewinddir(DIR *);
+void rb_w32_closedir(DIR *);
+
+#define opendir rb_w32_opendir
+#define readdir rb_w32_readdir
+#define telldir rb_w32_telldir
+#define seekdir rb_w32_seekdir
+#define rewinddir rb_w32_rewinddir
+#define closedir rb_w32_closedir
diff --git a/ruby_1_8_6/win32/ifchange.bat b/ruby_1_8_6/win32/ifchange.bat
new file mode 100755
index 0000000000..4fca646ea2
--- /dev/null
+++ b/ruby_1_8_6/win32/ifchange.bat
@@ -0,0 +1,32 @@
+@echo off
+:: usage: ifchange target temporary
+
+:: check if fc.exe works.
+echo foo > conftest1.tmp
+echo bar > conftest2.tmp
+fc.exe conftest1.tmp conftest2.tmp > nul
+if not errorlevel 1 goto :brokenfc
+del conftest1.tmp > nul
+del conftest2.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
+copy %2 %1 > nul
+:end
diff --git a/ruby_1_8_6/win32/mkexports.rb b/ruby_1_8_6/win32/mkexports.rb
new file mode 100755
index 0000000000..092b349a22
--- /dev/null
+++ b/ruby_1_8_6/win32/mkexports.rb
@@ -0,0 +1,37 @@
+#!./miniruby -s
+
+$name = $library = $description = nil
+
+SYM = {}
+
+objs = ARGV.collect {|s| s.tr('/', '\\')}
+IO.foreach("|dumpbin -symbols " + objs.join(' ')) do |l|
+ next if /^[0-9A-F]+ 0+ UNDEF / =~ l
+ next unless l.sub!(/.*?\s(\(\)\s+)?External\s+\|\s+/, "")
+ is_data = !$1
+ if /^[@_](?!\w+@\d+$)/ =~ l
+ next if /(?!^)@.*@/ =~ l || /@[0-9a-f]{16}$/ =~ l
+ l.sub!(/^[@_]/, '')
+ elsif !l.sub!(/^(\S+) \([^@?\`\']*\)$/, '\1')
+ next
+ end
+ SYM[l.strip] = is_data
+end
+
+exports = []
+if $name
+ exports << "Name " + $name
+elsif $library
+ exports << "Library " + $library
+end
+exports << "Description " + $description.dump if $description
+exports << "EXPORTS"
+SYM.sort.each do |sym, is_data|
+ exports << (is_data ? "#{sym} DATA" : sym)
+end
+
+if $output
+ open($output, 'w') {|f| f.puts exports.join("\n")}
+else
+ puts exports.join("\n")
+end
diff --git a/ruby_1_8_6/win32/resource.rb b/ruby_1_8_6/win32/resource.rb
new file mode 100755
index 0000000000..1c12075183
--- /dev/null
+++ b/ruby_1_8_6/win32/resource.rb
@@ -0,0 +1,95 @@
+#!./miniruby -sI.
+
+require 'rbconfig'
+
+CONFIG = Config::MAKEFILE_CONFIG
+
+fversion = "#{CONFIG['MAJOR']},#{CONFIG['MINOR']},#{CONFIG['TEENY']},0"
+
+$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, icons|
+ open(base + '.rc', "w") { |f|
+ f.binmode if /mingw/ =~ RUBY_PLATFORM
+
+ f.print <<EOF
+#ifndef __BORLANDC__
+#include <windows.h>
+#include <winver.h>
+#endif
+
+#{icons || ''}
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION #{fversion}
+ PRODUCTVERSION #{fversion}
+ FILEFLAGSMASK 0x3fL
+ FILEFLAGS 0x0L
+ FILEOS VOS__WINDOWS32
+ FILETYPE #{type}
+ FILESUBTYPE VFT2_UNKNOWN
+BEGIN
+ BLOCK "StringFileInfo"
+ BEGIN
+ BLOCK "000004b0"
+ BEGIN
+ VALUE "FileDescription", "Ruby interpreter (#{desc}) #{RUBY_VERSION} [#{RUBY_PLATFORM}]\\0"
+ VALUE "FileVersion", "#{fversion}\\0"
+ VALUE "Home Page", "http://www.ruby-lang.org/\\0"
+ VALUE "InternalName", "#{base + ext}\\0"
+ VALUE "LegalCopyright", "Copyright (C) 1993-#{RUBY_RELEASE_DATE[/\d+/]} Yukihiro Matsumoto\\0"
+ VALUE "OriginalFilename", "#{base + ext}\\0"
+ VALUE "Platform", "#{RUBY_PLATFORM}\\0"
+ VALUE "ProductVersion", "#{fversion}\\0"
+ VALUE "Release Date", "#{RUBY_RELEASE_DATE}\\0"
+ VALUE "Version", "#{RUBY_VERSION}\\0"
+ END
+ END
+ BLOCK "VarFileInfo"
+ BEGIN
+ VALUE "Translation", 0x0, 0x4b0
+ END
+END
+EOF
+ }
+end
+
diff --git a/ruby_1_8_6/win32/rm.bat b/ruby_1_8_6/win32/rm.bat
new file mode 100755
index 0000000000..eb415d67f9
--- /dev/null
+++ b/ruby_1_8_6/win32/rm.bat
@@ -0,0 +1,8 @@
+@echo off
+if "%1" == "-f" shift
+:begin
+if "%1" == "" goto :end
+if exist "%1" del "%1"
+shift
+goto :begin
+:end
diff --git a/ruby_1_8_6/win32/setup.mak b/ruby_1_8_6/win32/setup.mak
new file mode 100644
index 0000000000..13b5edd23f
--- /dev/null
+++ b/ruby_1_8_6/win32/setup.mak
@@ -0,0 +1,182 @@
+# -*- 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
+OS = mswin32
+BANG = !
+APPEND = echo>>$(MAKEFILE)
+!ifdef MAKEFILE
+MAKE = $(MAKE) -f $(MAKEFILE)
+!else
+MAKEFILE = Makefile
+!endif
+ARCH = PROCESSOR_ARCHITECTURE
+CPU = PROCESSOR_LEVEL
+CC = cl -nologo
+CPP = $(CC) -EP
+
+all: -prologue- -generic- -epilogue-
+i386-$(OS): -prologue- -i386- -epilogue-
+i486-$(OS): -prologue- -i486- -epilogue-
+i586-$(OS): -prologue- -i586- -epilogue-
+i686-$(OS): -prologue- -i686- -epilogue-
+alpha-$(OS): -prologue- -alpha- -epilogue-
+
+-prologue-: -basic-vars- -system-vars- -version- -program-name-
+
+-basic-vars-: nul
+ @type << > $(MAKEFILE)
+### Makefile for ruby $(OS) ###
+MAKE = nmake
+srcdir = $(srcdir:\=/)
+prefix = $(prefix:\=/)
+EXTSTATIC = $(EXTSTATIC)
+!if defined(USE_WINSOCK2)
+USE_WINSOCK2 = $(USE_WINSOCK2)
+!endif
+!if defined(RDOCTARGET)
+RDOCTARGET = $(RDOCTARGET)
+!endif
+!if defined(EXTOUT)
+EXTOUT = $(EXTOUT)
+!endif
+<<
+
+-system-vars-: -osname- -runtime-
+
+-osname-: nul
+ @echo OS = mswin32 >>$(MAKEFILE)
+
+-runtime-: nul
+ @$(CC) -MD <<rtname.c user32.lib > nul
+#include <windows.h>
+#include <memory.h>
+#include <string.h>
+#include <stddef.h>
+#include <stdio.h>
+#ifndef MAXPATHLEN
+# define MAXPATHLEN 1024
+#endif
+
+int
+runtime_name()
+{
+ char libpath[MAXPATHLEN+1];
+ char *p, *base = NULL, *ver = NULL;
+ HMODULE msvcrt = NULL;
+ MEMORY_BASIC_INFORMATION m;
+
+ memset(&m, 0, sizeof(m));
+ if (VirtualQuery(stdin, &m, sizeof(m)) && m.State == MEM_COMMIT)
+ msvcrt = (HMODULE)m.AllocationBase;
+ GetModuleFileName(msvcrt, libpath, sizeof libpath);
+
+ libpath[sizeof(libpath) - 1] = '\0';
+ for (p = libpath; *p; p = CharNext(p)) {
+ if (*p == '\\') {
+ base = ++p;
+ }
+ }
+ if (!base) return 0;
+ if (p = strchr(base, '.')) *p = '\0';
+ for (p = base; *p; p = CharNext(p)) {
+ if (!isascii(*p)) continue;
+ if (isupper(*p)) {
+ *p = tolower(*p);
+ }
+ if (!isdigit(*p)) {
+ ver = NULL;
+ } else if (!ver) {
+ ver = p;
+ }
+ }
+ if (ver) printf("OS = $$(OS)_%s\n", ver);
+ printf("RT = %s\n", base);
+ return 1;
+}
+
+int main(int argc, char **argv)
+{
+ if (!runtime_name()) return EXIT_FAILURE;
+ return EXIT_SUCCESS;
+}
+<<
+ @.\rtname >>$(MAKEFILE)
+ @del rtname.*
+
+-version-: nul
+ @$(CPP) -I$(srcdir) <<"Creating $(MAKEFILE)" >>$(MAKEFILE)
+#include "version.h"
+MAJOR = RUBY_VERSION_MAJOR
+MINOR = RUBY_VERSION_MINOR
+TEENY = RUBY_VERSION_TEENY
+MSC_VER = _MSC_VER
+<<
+
+-program-name-:
+ @type << >>$(MAKEFILE)
+!ifdef RUBY_SUFFIX
+RUBY_SUFFIX = $(RUBY_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
+!if defined($(ARCH)) || defined($(CPU))
+ @type << >>$(MAKEFILE)
+!if defined($(ARCH))
+$(ARCH) = $(PROCESSOR_ARCHITECTURE)
+!endif
+!if defined($(CPU))
+$(CPU) = $(PROCESSOR_LEVEL)
+!endif
+
+<<
+!endif
+
+-alpha-: nul
+ @$(APPEND) $(ARCH) = alpha
+-ix86-: nul
+ @$(APPEND) $(ARCH) = x86
+
+-i386-: -ix86-
+ @$(APPEND) $(CPU) = 3
+-i486-: -ix86-
+ @$(APPEND) $(CPU) = 4
+-i586-: -ix86-
+ @$(APPEND) $(CPU) = 5
+-i686-: -ix86-
+ @$(APPEND) $(CPU) = 6
+
+-epilogue-: nul
+ @type << >>$(MAKEFILE)
+# OS = $(OS)
+# 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 `$(MAKE)' to make ruby for $(OS).
diff --git a/ruby_1_8_6/win32/win32.c b/ruby_1_8_6/win32/win32.c
new file mode 100644
index 0000000000..3c16e57df1
--- /dev/null
+++ b/ruby_1_8_6/win32/win32.c
@@ -0,0 +1,3961 @@
+/*
+ * 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.
+ *
+ */
+
+#include "ruby.h"
+#include "rubysig.h"
+#include "dln.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 <windows.h>
+#include <winbase.h>
+#include <wincon.h>
+#include <shlobj.h>
+#ifdef __MINGW32__
+#include <mswsock.h>
+#include <mbstring.h>
+#endif
+#include "win32.h"
+#include "win32/dir.h"
+#ifdef _WIN32_WCE
+#include "wince.h"
+#endif
+#ifndef index
+#define index(x, y) strchr((x), (y))
+#endif
+#define isdirsep(x) ((x) == '/' || (x) == '\\')
+
+#undef stat
+#undef fclose
+#undef close
+#undef setsockopt
+
+#ifndef bool
+#define bool int
+#endif
+
+#if defined __BORLANDC__ || defined _WIN32_WCE
+# 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
+
+#if HAVE_WSAWAITFORMULTIPLEEVENTS
+# define USE_INTERRUPT_WINSOCK
+#endif
+
+#if USE_INTERRUPT_WINSOCK
+# define WaitForMultipleEvents WSAWaitForMultipleEvents
+# define CreateSignal() (HANDLE)WSACreateEvent()
+# define SetSignal(ev) WSASetEvent(ev)
+# define ResetSignal(ev) WSAResetEvent(ev)
+#else /* USE_INTERRUPT_WINSOCK */
+# define WaitForMultipleEvents WaitForMultipleObjectsEx
+# define CreateSignal() CreateEvent(NULL, FALSE, FALSE, NULL);
+# define SetSignal(ev) SetEvent(ev)
+# define ResetSignal(ev) (void)0
+#endif /* USE_INTERRUPT_WINSOCK */
+
+#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 char *, const char *, SECURITY_ATTRIBUTES *, HANDLE, HANDLE, HANDLE);
+static bool has_redirection(const char *);
+static void StartSockets ();
+static DWORD wait_events(HANDLE event, DWORD timeout);
+#if !defined(_WIN32_WCE)
+static int rb_w32_open_osfhandle(long osfhandle, int flags);
+#else
+#define rb_w32_open_osfhandle(osfhandle, flags) _open_osfhandle(osfhandle, flags)
+#endif
+
+/* 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 },
+ { ERROR_NOT_ENOUGH_QUOTA, ENOMEM },
+ { WSAENAMETOOLONG, ENAMETOOLONG },
+ { WSAENOTEMPTY, ENOTEMPTY },
+ { WSAEINTR, EINTR },
+ { WSAEBADF, EBADF },
+ { WSAEACCES, EACCES },
+ { WSAEFAULT, EFAULT },
+ { WSAEINVAL, EINVAL },
+ { WSAEMFILE, EMFILE },
+};
+
+static int
+map_errno(DWORD winerr)
+{
+ int i;
+
+ if (winerr == 0) {
+ return 0;
+ }
+
+ for (i = 0; i < sizeof(errmap) / sizeof(*errmap); i++) {
+ if (errmap[i].winerr == winerr) {
+ return errmap[i].err;
+ }
+ }
+
+ if (winerr >= WSABASEERR) {
+ return winerr;
+ }
+ return EINVAL;
+}
+
+static char *NTLoginName;
+
+#ifdef WIN95
+static DWORD Win32System = (DWORD)-1;
+
+DWORD
+rb_w32_osid(void)
+{
+ static OSVERSIONINFO osver;
+
+ if (osver.dwPlatformId != Win32System) {
+ memset(&osver, 0, sizeof(OSVERSIONINFO));
+ osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+ GetVersionEx(&osver);
+ Win32System = osver.dwPlatformId;
+ }
+ return (Win32System);
+}
+#endif
+
+#define IsWinNT() rb_w32_iswinnt()
+#define IsWin95() rb_w32_iswin95()
+
+/* main thread constants */
+static struct {
+ HANDLE handle;
+ DWORD id;
+} main_thread;
+
+/* interrupt stuff */
+static HANDLE interrupted_event;
+
+HANDLE
+GetCurrentThreadHandle(void)
+{
+ static HANDLE current_process_handle = NULL;
+ HANDLE h;
+
+ if (!current_process_handle)
+ current_process_handle = GetCurrentProcess();
+ if (!DuplicateHandle(current_process_handle, GetCurrentThread(),
+ current_process_handle, &h,
+ 0, FALSE, DUPLICATE_SAME_ACCESS))
+ return NULL;
+ return h;
+}
+
+/* simulate flock by locking a range on the file */
+
+
+#define LK_ERR(f,i) \
+ do { \
+ if (f) \
+ i = 0; \
+ else { \
+ DWORD err = GetLastError(); \
+ if (err == ERROR_LOCK_VIOLATION) \
+ errno = EWOULDBLOCK; \
+ else if (err == ERROR_NOT_LOCKED) \
+ i = 0; \
+ else \
+ errno = map_errno(err); \
+ } \
+ } while (0)
+#define LK_LEN ULONG_MAX
+
+static VALUE
+flock_winnt(VALUE self, int argc, VALUE* 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;
+}
+
+#ifdef WIN95
+static VALUE
+flock_win95(VALUE self, int argc, VALUE* argv)
+{
+ int i = -1;
+ const HANDLE fh = (HANDLE)self;
+ const int oper = argc;
+
+ switch(oper) {
+ case LOCK_EX:
+ do {
+ LK_ERR(LockFile(fh, 0, 0, LK_LEN, LK_LEN), i);
+ } while (i && errno == EWOULDBLOCK);
+ break;
+ case LOCK_EX|LOCK_NB:
+ LK_ERR(LockFile(fh, 0, 0, LK_LEN, LK_LEN), i);
+ break;
+ case LOCK_UN:
+ case LOCK_UN|LOCK_NB:
+ LK_ERR(UnlockFile(fh, 0, 0, LK_LEN, LK_LEN), i);
+ break;
+ default:
+ errno = EINVAL;
+ break;
+ }
+ return i;
+}
+#endif
+
+#undef LK_ERR
+
+int
+flock(int fd, int oper)
+{
+#ifdef WIN95
+ static asynchronous_func_t locker = NULL;
+
+ if (!locker) {
+ if (IsWinNT())
+ locker = flock_winnt;
+ else
+ locker = flock_win95;
+ }
+#else
+ const asynchronous_func_t locker = flock_winnt;
+#endif
+
+ return rb_w32_asynchronize(locker,
+ (VALUE)_get_osfhandle(fd), oper, NULL,
+ (DWORD)-1);
+}
+
+static void init_stdhandle(void);
+
+#if _MSC_VER >= 1400
+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
+}
+#endif
+
+static BOOL fWinsock;
+static char *envarea;
+static void
+exit_handler(void)
+{
+ if (fWinsock) {
+ WSACleanup();
+ fWinsock = FALSE;
+ }
+ if (envarea) {
+ FreeEnvironmentStrings(envarea);
+ envarea = NULL;
+ }
+}
+
+static void
+init_env(void)
+{
+ char env[_MAX_PATH];
+ DWORD len;
+ BOOL f;
+ LPITEMIDLIST pidl;
+
+ if (!GetEnvironmentVariable("HOME", env, sizeof(env))) {
+ f = FALSE;
+ if (GetEnvironmentVariable("HOMEDRIVE", env, sizeof(env)))
+ len = strlen(env);
+ else
+ len = 0;
+ if (GetEnvironmentVariable("HOMEPATH", env + len, sizeof(env) - len) || len) {
+ f = TRUE;
+ }
+ else if (GetEnvironmentVariable("USERPROFILE", env, sizeof(env))) {
+ f = TRUE;
+ }
+ else if (SHGetSpecialFolderLocation(NULL, CSIDL_PERSONAL, &pidl) == 0) {
+ LPMALLOC alloc;
+ f = SHGetPathFromIDList(pidl, env);
+ SHGetMalloc(&alloc);
+ alloc->lpVtbl->Free(alloc, pidl);
+ alloc->lpVtbl->Release(alloc);
+ }
+ if (f) {
+ char *p = env;
+ while (*p) {
+ if (*p == '\\') *p = '/';
+ p = CharNext(p);
+ }
+ if (p - env == 2 && env[1] == ':') {
+ *p++ = '/';
+ *p = 0;
+ }
+ SetEnvironmentVariable("HOME", env);
+ }
+ }
+
+ if (!GetEnvironmentVariable("USER", env, sizeof env)) {
+ if (GetEnvironmentVariable("USERNAME", env, sizeof env) ||
+ GetUserName(env, (len = sizeof env, &len))) {
+ SetEnvironmentVariable("USER", env);
+ }
+ else {
+ NTLoginName = "<Unknown>";
+ return;
+ }
+ }
+ NTLoginName = strdup(env);
+}
+
+//
+// Initialization stuff
+//
+void
+NtInitialize(int *argc, char ***argv)
+{
+
+ WORD version;
+ int ret;
+
+#if _MSC_VER >= 1400
+ static void set_pioinfo_extra(void);
+
+ _set_invalid_parameter_handler(invalid_parameter);
+ set_pioinfo_extra();
+#endif
+
+ //
+ // subvert cmd.exe's feeble attempt at command line parsing
+ //
+ *argc = rb_w32_cmdvector(GetCommandLine(), argv);
+
+ //
+ // Now set up the correct time stuff
+ //
+
+ tzset();
+
+ init_env();
+
+ init_stdhandle();
+
+ atexit(exit_handler);
+
+ // Initialize Winsock
+ StartSockets();
+
+#ifdef _WIN32_WCE
+ // free commandline buffer
+ wce_FreeCommandLine();
+#endif
+}
+
+char *
+getlogin()
+{
+ return NTLoginName;
+}
+
+#define MAXCHILDNUM 256 /* max num of child processes */
+
+static struct ChildRecord {
+ HANDLE hProcess; /* process handle */
+ rb_pid_t pid; /* process id */
+} ChildRecord[MAXCHILDNUM];
+
+#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)
+
+static struct ChildRecord *
+FindFirstChildSlot(void)
+{
+ FOREACH_CHILD(child) {
+ if (child->pid) return child;
+ } END_FOREACH_CHILD;
+ return NULL;
+}
+
+static struct ChildRecord *
+FindChildSlot(rb_pid_t pid)
+{
+
+ FOREACH_CHILD(child) {
+ if (child->pid == pid) {
+ return child;
+ }
+ } END_FOREACH_CHILD;
+ return NULL;
+}
+
+static void
+CloseChildHandle(struct ChildRecord *child)
+{
+ HANDLE h = child->hProcess;
+ child->hProcess = NULL;
+ child->pid = 0;
+ CloseHandle(h);
+}
+
+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" + 1,
+ "\3" "break" + 1,
+ "\3" "call" + 1,
+ "\3" "cd" + 1,
+ "\1" "chcp" + 1,
+ "\3" "chdir" + 1,
+ "\3" "cls" + 1,
+ "\2" "color" + 1,
+ "\3" "copy" + 1,
+ "\1" "ctty" + 1,
+ "\3" "date" + 1,
+ "\3" "del" + 1,
+ "\3" "dir" + 1,
+ "\3" "echo" + 1,
+ "\2" "endlocal" + 1,
+ "\3" "erase" + 1,
+ "\3" "exit" + 1,
+ "\3" "for" + 1,
+ "\2" "ftype" + 1,
+ "\3" "goto" + 1,
+ "\3" "if" + 1,
+ "\1" "lfnfor" + 1,
+ "\1" "lh" + 1,
+ "\1" "lock" + 1,
+ "\3" "md" + 1,
+ "\3" "mkdir" + 1,
+ "\2" "move" + 1,
+ "\3" "path" + 1,
+ "\3" "pause" + 1,
+ "\2" "popd" + 1,
+ "\3" "prompt" + 1,
+ "\2" "pushd" + 1,
+ "\3" "rd" + 1,
+ "\3" "rem" + 1,
+ "\3" "ren" + 1,
+ "\3" "rename" + 1,
+ "\3" "rmdir" + 1,
+ "\3" "set" + 1,
+ "\2" "setlocal" + 1,
+ "\3" "shift" + 1,
+ "\2" "start" + 1,
+ "\3" "time" + 1,
+ "\2" "title" + 1,
+ "\1" "truename" + 1,
+ "\3" "type" + 1,
+ "\1" "unlock" + 1,
+ "\3" "ver" + 1,
+ "\3" "verify" + 1,
+ "\3" "vol" + 1,
+};
+
+static int
+internal_match(const void *key, const void *elem)
+{
+ return strcmp(key, *(const char *const *)elem);
+}
+
+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
+is_internal_cmd(const char *cmd, int nt)
+{
+ char cmdname[9], *b = cmdname, c, **nm;
+
+ do {
+ if (!(c = *cmd++)) return 0;
+ } while (isspace(c));
+ 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;
+ nm = bsearch(cmdname, szInternalCmds,
+ sizeof(szInternalCmds) / sizeof(*szInternalCmds),
+ sizeof(*szInternalCmds),
+ internal_match);
+ if (!nm || !(nm[0][-1] & (nt ? 2 : 1)))
+ return 0;
+ return 1;
+}
+
+
+SOCKET
+rb_w32_get_osfhandle(int fh)
+{
+ return _get_osfhandle(fh);
+}
+
+rb_pid_t
+pipe_exec(char *cmd, int mode, FILE **fpr, FILE **fpw)
+{
+ struct ChildRecord* child;
+ HANDLE hReadIn, hReadOut;
+ HANDLE hWriteIn, hWriteOut;
+ HANDLE hDupInFile, hDupOutFile;
+ HANDLE hCurProc;
+ SECURITY_ATTRIBUTES sa;
+ BOOL fRet;
+ BOOL reading, writing;
+ int fd;
+ int pipemode;
+ char modes[3];
+ int ret;
+
+ /* Figure out what we're doing... */
+ writing = (mode & (O_WRONLY | O_RDWR)) ? TRUE : FALSE;
+ reading = ((mode & O_RDWR) || !writing) ? TRUE : FALSE;
+ if (mode & O_BINARY) {
+ pipemode = O_BINARY;
+ modes[1] = 'b';
+ modes[2] = '\0';
+ }
+ else {
+ pipemode = O_TEXT;
+ modes[1] = '\0';
+ }
+
+ sa.nLength = sizeof (SECURITY_ATTRIBUTES);
+ sa.lpSecurityDescriptor = NULL;
+ sa.bInheritHandle = TRUE;
+ ret = -1;
+ hWriteIn = hReadOut = NULL;
+
+ RUBY_CRITICAL(do {
+ /* create pipe */
+ hCurProc = GetCurrentProcess();
+ if (reading) {
+ fRet = CreatePipe(&hReadIn, &hReadOut, &sa, 2048L);
+ if (!fRet) {
+ errno = map_errno(GetLastError());
+ break;
+ }
+ if (!DuplicateHandle(hCurProc, hReadIn, hCurProc, &hDupInFile, 0,
+ FALSE, DUPLICATE_SAME_ACCESS)) {
+ errno = map_errno(GetLastError());
+ CloseHandle(hReadIn);
+ CloseHandle(hReadOut);
+ CloseHandle(hCurProc);
+ break;
+ }
+ CloseHandle(hReadIn);
+ }
+ if (writing) {
+ fRet = CreatePipe(&hWriteIn, &hWriteOut, &sa, 2048L);
+ if (!fRet) {
+ errno = map_errno(GetLastError());
+ write_pipe_failed:
+ if (reading) {
+ CloseHandle(hDupInFile);
+ CloseHandle(hReadOut);
+ }
+ break;
+ }
+ if (!DuplicateHandle(hCurProc, hWriteOut, hCurProc, &hDupOutFile, 0,
+ FALSE, DUPLICATE_SAME_ACCESS)) {
+ errno = map_errno(GetLastError());
+ CloseHandle(hWriteIn);
+ CloseHandle(hWriteOut);
+ CloseHandle(hCurProc);
+ goto write_pipe_failed;
+ }
+ CloseHandle(hWriteOut);
+ }
+ CloseHandle(hCurProc);
+
+ /* create child process */
+ child = CreateChild(cmd, NULL, &sa, hWriteIn, hReadOut, NULL);
+ if (!child) {
+ if (reading) {
+ CloseHandle(hReadOut);
+ CloseHandle(hDupInFile);
+ }
+ if (writing) {
+ CloseHandle(hWriteIn);
+ CloseHandle(hDupOutFile);
+ }
+ break;
+ }
+
+ /* associate handle to fp */
+ if (reading) {
+ fd = rb_w32_open_osfhandle((long)hDupInFile,
+ (_O_RDONLY | pipemode));
+ CloseHandle(hReadOut);
+ if (fd == -1) {
+ CloseHandle(hDupInFile);
+ read_open_failed:
+ if (writing) {
+ CloseHandle(hWriteIn);
+ CloseHandle(hDupOutFile);
+ }
+ CloseChildHandle(child);
+ break;
+ }
+ modes[0] = 'r';
+ if ((*fpr = (FILE *)fdopen(fd, modes)) == NULL) {
+ _close(fd);
+ goto read_open_failed;
+ }
+ }
+ if (writing) {
+ fd = rb_w32_open_osfhandle((long)hDupOutFile,
+ (_O_WRONLY | pipemode));
+ CloseHandle(hWriteIn);
+ if (fd == -1) {
+ CloseHandle(hDupOutFile);
+ write_open_failed:
+ if (reading) {
+ fclose(*fpr);
+ }
+ CloseChildHandle(child);
+ break;
+ }
+ modes[0] = 'w';
+ if ((*fpw = (FILE *)fdopen(fd, modes)) == NULL) {
+ _close(fd);
+ goto write_open_failed;
+ }
+ }
+ ret = child->pid;
+ } while (0));
+
+ return ret;
+}
+
+extern VALUE rb_last_status;
+
+int
+do_spawn(int mode, char *cmd)
+{
+ struct ChildRecord *child;
+ DWORD exitcode;
+
+ switch (mode) {
+ case P_WAIT:
+ case P_NOWAIT:
+ case P_OVERLAY:
+ break;
+ default:
+ errno = EINVAL;
+ return -1;
+ }
+
+ child = CreateChild(cmd, NULL, NULL, NULL, NULL, NULL);
+ if (!child) {
+ return -1;
+ }
+
+ switch (mode) {
+ case P_WAIT:
+ rb_syswait(child->pid);
+ return NUM2INT(rb_last_status);
+ case P_NOWAIT:
+ return child->pid;
+ case P_OVERLAY:
+ WaitForSingleObject(child->hProcess, INFINITE);
+ GetExitCodeProcess(child->hProcess, &exitcode);
+ CloseChildHandle(child);
+ _exit(exitcode);
+ default:
+ return -1; /* not reached */
+ }
+}
+
+int
+do_aspawn(int mode, char *prog, char **argv)
+{
+ char *cmd, *p, *q, *s, **t;
+ int len, n, bs, quote;
+ struct ChildRecord *child;
+ DWORD exitcode;
+
+ switch (mode) {
+ case P_WAIT:
+ case P_NOWAIT:
+ case P_OVERLAY:
+ break;
+ default:
+ errno = EINVAL;
+ return -1;
+ }
+
+ for (t = argv, len = 0; *t; t++) {
+ for (p = *t, n = quote = bs = 0; *p; ++p) {
+ switch (*p) {
+ case '\\':
+ ++bs;
+ break;
+ case '"':
+ n += bs + 1; bs = 0;
+ quote = 1;
+ break;
+ case ' ': case '\t':
+ quote = 1;
+ default:
+ bs = 0;
+ p = CharNext(p) - 1;
+ break;
+ }
+ }
+ len += p - *t + n + 1;
+ if (quote) len += 2;
+ }
+ cmd = ALLOCA_N(char, len);
+ for (t = argv, q = cmd; p = *t; t++) {
+ quote = 0;
+ s = p;
+ if (!*p || strpbrk(p, " \t\"")) {
+ quote = 1;
+ *q++ = '"';
+ }
+ for (bs = 0; *p; ++p) {
+ switch (*p) {
+ case '\\':
+ ++bs;
+ break;
+ case '"':
+ memcpy(q, s, n = p - s); q += n; s = p;
+ memset(q, '\\', ++bs); q += bs; bs = 0;
+ break;
+ default:
+ bs = 0;
+ p = CharNext(p) - 1;
+ break;
+ }
+ }
+ memcpy(q, s, n = p - s);
+ q += n;
+ if (quote) *q++ = '"';
+ *q++ = ' ';
+ }
+ if (q > cmd) --q;
+ *q = '\0';
+
+ child = CreateChild(cmd, prog, NULL, NULL, NULL, NULL);
+ if (!child) {
+ return -1;
+ }
+
+ switch (mode) {
+ case P_WAIT:
+ rb_syswait(child->pid);
+ return NUM2INT(rb_last_status);
+ case P_NOWAIT:
+ return child->pid;
+ case P_OVERLAY:
+ WaitForSingleObject(child->hProcess, INFINITE);
+ GetExitCodeProcess(child->hProcess, &exitcode);
+ CloseChildHandle(child);
+ _exit(exitcode);
+ default:
+ return -1; /* not reached */
+ }
+}
+
+static struct ChildRecord *
+CreateChild(const char *cmd, const char *prog, SECURITY_ATTRIBUTES *psa,
+ HANDLE hInput, HANDLE hOutput, HANDLE hError)
+{
+ BOOL fRet;
+ DWORD dwCreationFlags;
+ STARTUPINFO aStartupInfo;
+ PROCESS_INFORMATION aProcessInformation;
+ SECURITY_ATTRIBUTES sa;
+ const char *shell;
+ struct ChildRecord *child;
+ char *p = NULL;
+
+ 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 (STARTUPINFO));
+ memset(&aProcessInformation, 0, sizeof (PROCESS_INFORMATION));
+ aStartupInfo.cb = sizeof (STARTUPINFO);
+ if (hInput || hOutput || hError) {
+ 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 (prog) {
+ if (!(p = dln_find_exe(prog, NULL))) {
+ shell = prog;
+ }
+ }
+ else {
+ int redir = -1;
+ int len = 0;
+ int nt;
+ while (ISSPACE(*cmd)) cmd++;
+ for (prog = cmd; *prog; prog = CharNext(prog)) {
+ if (ISSPACE(*prog)) {
+ len = prog - cmd;
+ do ++prog; while (ISSPACE(*prog));
+ if (!*prog--) break;
+ }
+ else {
+ len = 0;
+ }
+ }
+ if (!len) len = strlen(cmd);
+ if ((shell = getenv("RUBYSHELL")) && (redir = has_redirection(cmd))) {
+ char *tmp = ALLOCA_N(char, strlen(shell) + len + sizeof(" -c ") + 2);
+ sprintf(tmp, "%s -c \"%.*s\"", shell, len, cmd);
+ cmd = tmp;
+ }
+ else if ((shell = getenv("COMSPEC")) &&
+ (nt = !is_command_com(shell),
+ (redir < 0 ? has_redirection(cmd) : redir) ||
+ is_internal_cmd(cmd, nt))) {
+ char *tmp = ALLOCA_N(char, strlen(shell) + len + sizeof(" /c ")
+ + (nt ? 2 : 0));
+ sprintf(tmp, nt ? "%s /c \"%.*s\"" : "%s /c %.*s", shell, len, cmd);
+ cmd = tmp;
+ }
+ else {
+ shell = NULL;
+ prog = cmd;
+ for (;;) {
+ if (!*prog) {
+ p = dln_find_exe(cmd, NULL);
+ break;
+ }
+ if (strchr(".:*?\"/\\", *prog)) {
+ if (cmd[len]) {
+ char *tmp = ALLOCA_N(char, len + 1);
+ memcpy(tmp, cmd, len);
+ tmp[len] = 0;
+ cmd = tmp;
+ }
+ break;
+ }
+ if (ISSPACE(*prog) || strchr("<>|", *prog)) {
+ len = prog - cmd;
+ p = ALLOCA_N(char, len + 1);
+ memcpy(p, cmd, len);
+ p[len] = 0;
+ p = dln_find_exe(p, NULL);
+ break;
+ }
+ prog++;
+ }
+ }
+ }
+ if (p) {
+ shell = p;
+ while (*p) {
+ if ((unsigned char)*p == '/')
+ *p = '\\';
+ p = CharNext(p);
+ }
+ }
+
+ RUBY_CRITICAL({
+ fRet = CreateProcess(shell, (char *)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;
+
+ if (!IsWinNT()) {
+ /* On Win9x, make pid positive similarly to cygwin and perl */
+ child->pid = -child->pid;
+ }
+
+ return child;
+}
+
+typedef struct _NtCmdLineElement {
+ struct _NtCmdLineElement *next;
+ char *str;
+ int 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
+
+static int
+insert(const char *path, VALUE vinfo)
+{
+ 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;
+}
+
+#ifdef HAVE_SYS_PARAM_H
+# include <sys/param.h>
+#else
+# define MAXPATHLEN 512
+#endif
+
+
+static NtCmdLineElement **
+cmdglob(NtCmdLineElement *patt, NtCmdLineElement **tail)
+{
+ char buffer[MAXPATHLEN], *buf = buffer;
+ char *p;
+ NtCmdLineElement **last = tail;
+ int status;
+
+ if (patt->len >= MAXPATHLEN)
+ if (!(buf = malloc(patt->len + 1))) return 0;
+
+ strncpy (buf, patt->str, patt->len);
+ buf[patt->len] = '\0';
+ for (p = buf; *p; p = CharNext(p))
+ if (*p == '\\')
+ *p = '/';
+ status = ruby_glob(buf, 0, insert, (VALUE)&tail);
+ 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
+//
+
+static bool
+has_redirection(const char *cmd)
+{
+ char quote = '\0';
+ const char *ptr;
+
+ //
+ // Scan the string, looking for redirection (< or >) or pipe
+ // characters (|) 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 '|':
+ if (!quote)
+ return TRUE;
+ ptr++;
+ break;
+
+ case '\\':
+ ptr++;
+ default:
+ ptr = CharNext(ptr);
+ break;
+ }
+ }
+ return FALSE;
+}
+
+static inline char *
+skipspace(char *ptr)
+{
+ while (ISSPACE(*ptr))
+ ptr++;
+ return ptr;
+}
+
+int
+rb_w32_cmdvector(const char *cmd, char ***vec)
+{
+ int cmdlen, globbing, len, i;
+ int elements, strsz, done;
+ int slashes, escape;
+ char *ptr, *base, *buffer, *cmdline;
+ char **vptr;
+ char quote;
+ NtCmdLineElement *curr, **tail;
+ NtCmdLineElement *cmdhead = NULL, **cmdtail = &cmdhead;
+
+ //
+ // just return if we don't have a command line
+ //
+
+ while (ISSPACE(*cmd))
+ cmd++;
+ if (!*cmd) {
+ *vec = NULL;
+ return 0;
+ }
+
+ ptr = cmdline = strdup(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 interation for each element seen.
+ // The inner loop does one interation 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 '\\':
+ if (quote != '\'') slashes++;
+ break;
+
+ case ' ':
+ case '\t':
+ case '\n':
+ //
+ // if we're not in a string, then we're finished with this
+ // element
+ //
+
+ if (!quote) {
+ *ptr = 0;
+ done = 1;
+ }
+ break;
+
+ case '*':
+ case '?':
+ case '[':
+ case '{':
+ //
+ // record the fact that this element has a wildcard character
+ // N.B. Don't glob if inside a single quoted string
+ //
+
+ if (quote != '\'')
+ globbing++;
+ slashes = 0;
+ break;
+
+ case '\'':
+ case '\"':
+ //
+ // 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 neccessarily 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 == '"' && quote == ptr[1])
+ ptr++;
+ quote = '\0';
+ }
+ }
+ escape++;
+ slashes = 0;
+ break;
+
+ default:
+ ptr = CharNext(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) {
+ char *p = base, c;
+ slashes = quote = 0;
+ while (p < base + len) {
+ switch (c = *p) {
+ case '\\':
+ p++;
+ if (quote != '\'') slashes++;
+ break;
+
+ case '\'':
+ case '"':
+ if (!(slashes & 1) && quote && quote != c) {
+ p++;
+ slashes = 0;
+ break;
+ }
+ memcpy(p - ((slashes + 1) >> 1), p + (~slashes & 1),
+ base + len - p);
+ len -= ((slashes + 1) >> 1) + (~slashes & 1);
+ p -= (slashes + 1) >> 1;
+ if (!(slashes & 1)) {
+ if (quote) {
+ if (quote == '"' && quote == *p)
+ p++;
+ quote = '\0';
+ }
+ else
+ quote = c;
+ }
+ else
+ p++;
+ slashes = 0;
+ break;
+
+ default:
+ p = CharNext(p);
+ slashes = 0;
+ break;
+ }
+ }
+ }
+
+ curr = (NtCmdLineElement *)calloc(sizeof(NtCmdLineElement), 1);
+ if (!curr) goto do_nothing;
+ curr->str = base;
+ curr->len = len;
+
+ if (globbing && (tail = cmdglob(curr, cmdtail))) {
+ 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) {
+ 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 ptr 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;
+
+ ptr = buffer + (elements+1) * sizeof(char *);
+
+ while (curr = cmdhead) {
+ memcpy(ptr, curr->str, curr->len + 1);
+ *vptr++ = ptr;
+ ptr += 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
+//
+
+#define PATHLEN 1024
+
+//
+// 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.
+//
+
+#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)
+
+DIR *
+rb_w32_opendir(const char *filename)
+{
+ DIR *p;
+ long len;
+ long idx;
+ char scannamespc[PATHLEN];
+ char *scanname = scannamespc;
+ struct stat sbuf;
+ WIN32_FIND_DATA fd;
+ HANDLE fh;
+
+ //
+ // check to see if we've got a directory
+ //
+
+ if (rb_w32_stat(filename, &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;
+ }
+
+ //
+ // Get us a DIR structure
+ //
+
+ p = xcalloc(sizeof(DIR), 1);
+ if (p == NULL)
+ return NULL;
+
+ //
+ // Create the search pattern
+ //
+
+ strcpy(scanname, filename);
+
+ if (index("/\\:", *CharPrev(scanname, scanname + strlen(scanname))) == NULL)
+ strcat(scanname, "/*");
+ else
+ strcat(scanname, "*");
+
+ //
+ // do the FindFirstFile call
+ //
+
+ fh = FindFirstFile(scanname, &fd);
+ if (fh == INVALID_HANDLE_VALUE) {
+ errno = map_errno(GetLastError());
+ free(p);
+ return NULL;
+ }
+
+ //
+ // now allocate the first part of the string table for the
+ // filenames that we find.
+ //
+
+ idx = strlen(fd.cFileName)+1;
+ if (!(p->start = (char *)malloc(idx)) || !(p->bits = (char *)malloc(1))) {
+ error:
+ rb_w32_closedir(p);
+ FindClose(fh);
+ errno = ENOMEM;
+ return NULL;
+ }
+ strcpy(p->start, fd.cFileName);
+ p->bits[0] = 0;
+ if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+ SetBit(p->bits, BitOfIsDir(0));
+ if (fd.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
+ SetBit(p->bits, BitOfIsRep(0));
+ p->nfiles++;
+
+ //
+ // 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.
+ //
+ while (FindNextFile(fh, &fd)) {
+ char *newpath;
+
+ len = strlen(fd.cFileName) + 1;
+
+ //
+ // bump the string table size by enough for the
+ // new name and it's null terminator
+ //
+
+ newpath = (char *)realloc(p->start, idx + len);
+ if (newpath == NULL) {
+ goto error;
+ }
+ p->start = newpath;
+ strcpy(&p->start[idx], fd.cFileName);
+
+ if (p->nfiles % DIRENT_PER_CHAR == 0) {
+ char *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;
+ }
+ FindClose(fh);
+ p->size = idx;
+ p->curr = p->start;
+ return p;
+}
+
+//
+// Move to next entry
+//
+
+static void
+move_to_next_entry(DIR *dirp)
+{
+ if (dirp->curr) {
+ dirp->loc++;
+ dirp->curr += strlen(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.
+//
+
+struct direct *
+rb_w32_readdir(DIR *dirp)
+{
+ static int dummy = 0;
+
+ if (dirp->curr) {
+
+ //
+ // first set up the structure to return
+ //
+
+ strcpy(dirp->dirstr.d_name, dirp->curr);
+ dirp->dirstr.d_namlen = strlen(dirp->curr);
+
+ //
+ // 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;
+}
+
+//
+// Telldir returns the current string pointer position
+//
+
+long
+rb_w32_telldir(DIR *dirp)
+{
+ long loc = 0; char *p = dirp->curr;
+
+ rb_w32_rewinddir(dirp);
+
+ while (p != dirp->curr) {
+ move_to_next_entry(dirp); loc++;
+ }
+
+ return loc;
+}
+
+//
+// Seekdir moves the string pointer to a previously saved position
+// (Saved by telldir).
+
+void
+rb_w32_seekdir(DIR *dirp, long loc)
+{
+ rb_w32_rewinddir(dirp);
+
+ while (dirp->curr && loc-- > 0) {
+ move_to_next_entry(dirp);
+ }
+}
+
+//
+// Rewinddir resets the string pointer to the start
+//
+
+void
+rb_w32_rewinddir(DIR *dirp)
+{
+ dirp->curr = dirp->start;
+}
+
+//
+// This just free's the memory allocated by opendir
+//
+
+void
+rb_w32_closedir(DIR *dirp)
+{
+ free(dirp->start);
+ free(dirp->bits);
+ free(dirp);
+}
+
+EXTERN_C void __cdecl _lock_fhandle(int);
+EXTERN_C void __cdecl _unlock_fhandle(int);
+EXTERN_C void __cdecl _unlock(int);
+
+#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
+
+typedef struct {
+ long 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;
+#if _MSC_VER >= 1400
+ char textmode;
+ char pipech2[2];
+#endif
+#endif
+} ioinfo;
+
+#if !defined _CRTIMP || defined __MINGW32__
+#undef _CRTIMP
+#define _CRTIMP __declspec(dllimport)
+#endif
+
+#if !defined(__BORLANDC__) && !defined(_WIN32_WCE)
+EXTERN_C _CRTIMP ioinfo * __pioinfo[];
+
+#define IOINFO_L2E 5
+#define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E)
+#define _pioinfo(i) ((ioinfo*)((char*)(__pioinfo[i >> IOINFO_L2E]) + (i & (IOINFO_ARRAY_ELTS - 1)) * (sizeof(ioinfo) + pioinfo_extra)))
+#define _osfhnd(i) (_pioinfo(i)->osfhnd)
+#define _osfile(i) (_pioinfo(i)->osfile)
+#define _pipech(i) (_pioinfo(i)->pipech)
+
+#if _MSC_VER >= 1400
+static size_t pioinfo_extra = 0; /* workaround for VC++8 SP1 */
+
+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
+
+#define _set_osfhnd(fh, osfh) (void)(_osfhnd(fh) = osfh)
+#define _set_osflags(fh, flags) (_osfile(fh) = (flags))
+
+#define FOPEN 0x01 /* file handle open */
+#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
+rb_w32_open_osfhandle(long 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((long)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 */
+}
+
+static void
+init_stdhandle(void)
+{
+ if (fileno(stdin) < 0) {
+ stdin->_file = 0;
+ }
+ if (fileno(stdout) < 0) {
+ stdout->_file = 1;
+ }
+ if (fileno(stderr) < 0) {
+ stderr->_file = 2;
+ }
+ setvbuf(stderr, NULL, _IONBF, 0);
+}
+#else
+
+#define _set_osfhnd(fh, osfh) (void)((fh), (osfh))
+#define _set_osflags(fh, flags) (void)((fh), (flags))
+
+static void
+init_stdhandle(void)
+{
+}
+#endif
+
+#ifdef __BORLANDC__
+static int
+rb_w32_open_osfhandle(long 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
+
+static int
+is_socket(SOCKET fd)
+{
+ char sockbuf[80];
+ int optlen;
+ int retval;
+ int result = TRUE;
+
+ optlen = sizeof(sockbuf);
+ RUBY_CRITICAL({
+ retval = getsockopt(fd, SOL_SOCKET, SO_TYPE, sockbuf, &optlen);
+ if (retval == SOCKET_ERROR) {
+ int iRet;
+ iRet = WSAGetLastError();
+ if (iRet == WSAENOTSOCK || iRet == WSANOTINITIALISED)
+ result = FALSE;
+ }
+ });
+
+ //
+ // If we get here, then fd is actually a socket.
+ //
+
+ return result;
+}
+
+//
+// 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
+
+char *
+rb_w32_strerror(int e)
+{
+ static char buffer[512];
+#if !defined __MINGW32__
+ extern int sys_nerr;
+#endif
+ 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 (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM |
+ FORMAT_MESSAGE_IGNORE_INSERTS, &source, e, 0,
+ buffer, sizeof(buffer), NULL) == 0) {
+ strcpy(buffer, "Unknown Error");
+ }
+ }
+ else {
+ strncpy(buffer, strerror(e), sizeof(buffer));
+ buffer[sizeof(buffer) - 1] = 0;
+ }
+
+ 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
+
+rb_uid_t
+getuid(void)
+{
+ return ROOT_UID;
+}
+
+rb_uid_t
+geteuid(void)
+{
+ return ROOT_UID;
+}
+
+rb_gid_t
+getgid(void)
+{
+ return ROOT_GID;
+}
+
+rb_gid_t
+getegid(void)
+{
+ return ROOT_GID;
+}
+
+int
+setuid(rb_uid_t uid)
+{
+ return (uid == ROOT_UID ? 0 : -1);
+}
+
+int
+setgid(rb_gid_t gid)
+{
+ return (gid == ROOT_GID ? 0 : -1);
+}
+
+//
+// File system stuff
+//
+
+int
+/* ioctl(int i, unsigned int u, char *data) */
+#ifdef __BORLANDC__
+ ioctl(int i, int u, ...)
+#else
+ ioctl(int i, unsigned int u, long data)
+#endif
+{
+ errno = EINVAL;
+ return -1;
+}
+
+#undef FD_SET
+
+void
+rb_w32_fdset(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) {
+ return;
+ }
+ }
+ if (i == set->fd_count) {
+ if (set->fd_count < FD_SETSIZE) {
+ set->fd_array[i] = s;
+ set->fd_count++;
+ }
+ }
+}
+
+#undef FD_CLR
+
+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) {
+ while (i < set->fd_count - 1) {
+ set->fd_array[i] = set->fd_array[i + 1];
+ i++;
+ }
+ set->fd_count--;
+ break;
+ }
+ }
+}
+
+#undef FD_ISSET
+
+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;
+}
+
+//
+// Networking trampolines
+// These are used to avoid socket startup/shutdown overhead in case
+// the socket routines aren't used.
+//
+
+#undef select
+
+static int NtSocketsInitialized = 0;
+
+static int
+extract_file_fd(fd_set *set, fd_set *fileset)
+{
+ int idx;
+
+ fileset->fd_count = 0;
+ if (!set)
+ return 0;
+ for (idx = 0; idx < set->fd_count; idx++) {
+ SOCKET fd = set->fd_array[idx];
+
+ if (!is_socket(fd)) {
+ int i;
+
+ for (i = 0; i < fileset->fd_count; i++) {
+ if (fileset->fd_array[i] == fd) {
+ break;
+ }
+ }
+ if (i == fileset->fd_count) {
+ if (fileset->fd_count < FD_SETSIZE) {
+ fileset->fd_array[i] = fd;
+ fileset->fd_count++;
+ }
+ }
+ }
+ }
+ return fileset->fd_count;
+}
+
+long
+rb_w32_select (int nfds, fd_set *rd, fd_set *wr, fd_set *ex,
+ struct timeval *timeout)
+{
+ long r;
+ fd_set file_rd;
+ fd_set file_wr;
+#ifdef USE_INTERRUPT_WINSOCK
+ fd_set trap;
+#endif /* USE_INTERRUPT_WINSOCK */
+ int file_nfds;
+
+ if (!NtSocketsInitialized) {
+ StartSockets();
+ }
+ r = 0;
+ if (rd && rd->fd_count > r) r = rd->fd_count;
+ if (wr && wr->fd_count > r) r = wr->fd_count;
+ if (ex && ex->fd_count > r) r = ex->fd_count;
+ if (nfds > r) nfds = r;
+ if (nfds == 0 && timeout) {
+ Sleep(timeout->tv_sec * 1000 + timeout->tv_usec / 1000);
+ return 0;
+ }
+ file_nfds = extract_file_fd(rd, &file_rd);
+ file_nfds += extract_file_fd(wr, &file_wr);
+ if (file_nfds)
+ {
+ // assume normal files are always readable/writable
+ // fake read/write fd_set and return value
+ if (rd) *rd = file_rd;
+ if (wr) *wr = file_wr;
+ return file_nfds;
+ }
+
+#if USE_INTERRUPT_WINSOCK
+ if (ex)
+ trap = *ex;
+ else
+ trap.fd_count = 0;
+ if (trap.fd_count < FD_SETSIZE)
+ trap.fd_array[trap.fd_count++] = (SOCKET)interrupted_event;
+ // else unable to catch interrupt.
+ ex = &trap;
+#endif /* USE_INTERRUPT_WINSOCK */
+
+ RUBY_CRITICAL({
+ r = select(nfds, rd, wr, ex, timeout);
+ if (r == SOCKET_ERROR) {
+ errno = map_errno(WSAGetLastError());
+ }
+ });
+ return r;
+}
+
+static void
+StartSockets ()
+{
+ WORD version;
+ WSADATA retdata;
+ int ret;
+#ifndef USE_WINSOCK2
+ int iSockOpt;
+#endif
+
+ //
+ // initalize the winsock interface and insure that it's
+ // cleaned up at exit.
+ //
+#ifdef USE_WINSOCK2
+ 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");
+#else
+ version = MAKEWORD(1, 1);
+ if (ret = WSAStartup(version, &retdata))
+ rb_fatal ("Unable to locate winsock library!\n");
+ if (LOBYTE(retdata.wVersion) != 1)
+ rb_fatal("could not find version 1 of winsock dll\n");
+
+ if (HIBYTE(retdata.wVersion) != 1)
+ rb_fatal("could not find version 1 of winsock dll\n");
+#endif /* USE_WINSOCK2 */
+
+ fWinsock = TRUE;
+
+#ifndef USE_WINSOCK2
+# ifndef SO_SYNCHRONOUS_NONALERT
+# define SO_SYNCHRONOUS_NONALERT 0x20
+# endif
+
+ iSockOpt = SO_SYNCHRONOUS_NONALERT;
+ /*
+ * Enable the use of sockets as filehandles
+ */
+# ifndef SO_OPENTYPE
+# define SO_OPENTYPE 0x7008
+# endif
+
+ setsockopt(INVALID_SOCKET, SOL_SOCKET, SO_OPENTYPE,
+ (char *)&iSockOpt, sizeof(iSockOpt));
+#endif /* USE_WINSOCK2 */
+
+ main_thread.handle = GetCurrentThreadHandle();
+ main_thread.id = GetCurrentThreadId();
+
+ interrupted_event = CreateSignal();
+ if (!interrupted_event)
+ rb_fatal("Unable to create interrupt event!\n");
+ NtSocketsInitialized = 1;
+}
+
+#undef accept
+
+int
+rb_w32_accept(int s, struct sockaddr *addr, int *addrlen)
+{
+ SOCKET r;
+
+ if (!NtSocketsInitialized) {
+ StartSockets();
+ }
+ RUBY_CRITICAL({
+ r = accept(TO_SOCKET(s), addr, addrlen);
+ if (r == INVALID_SOCKET) {
+ errno = map_errno(WSAGetLastError());
+ s = -1;
+ }
+ else {
+ s = rb_w32_open_osfhandle(r, O_RDWR|O_BINARY);
+ }
+ });
+ return s;
+}
+
+#undef bind
+
+int
+rb_w32_bind(int s, 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
+
+int
+rb_w32_connect(int s, struct sockaddr *addr, int addrlen)
+{
+ int r;
+ if (!NtSocketsInitialized) {
+ StartSockets();
+ }
+ RUBY_CRITICAL({
+ r = connect(TO_SOCKET(s), addr, addrlen);
+ if (r == SOCKET_ERROR) {
+ r = WSAGetLastError();
+ if (r != WSAEWOULDBLOCK) {
+ errno = map_errno(r);
+ }
+ else {
+ errno = EINPROGRESS;
+ r = -1;
+ }
+ }
+ });
+ return r;
+}
+
+
+#undef getpeername
+
+int
+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
+
+int
+rb_w32_getsockname(int s, struct sockaddr *addr, int *addrlen)
+{
+ int r;
+ if (!NtSocketsInitialized) {
+ StartSockets();
+ }
+ RUBY_CRITICAL({
+ r = getsockname(TO_SOCKET(s), addr, addrlen);
+ if (r == SOCKET_ERROR)
+ errno = map_errno(WSAGetLastError());
+ });
+ return r;
+}
+
+int
+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
+
+int
+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
+
+int
+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
+
+int
+rb_w32_recv(int s, char *buf, int len, int flags)
+{
+ int r;
+ if (!NtSocketsInitialized) {
+ StartSockets();
+ }
+ RUBY_CRITICAL({
+ r = recv(TO_SOCKET(s), buf, len, flags);
+ if (r == SOCKET_ERROR)
+ errno = map_errno(WSAGetLastError());
+ });
+ return r;
+}
+
+#undef recvfrom
+
+int
+rb_w32_recvfrom(int s, char *buf, int len, int flags,
+ struct sockaddr *from, int *fromlen)
+{
+ int r;
+ if (!NtSocketsInitialized) {
+ StartSockets();
+ }
+ RUBY_CRITICAL({
+ r = recvfrom(TO_SOCKET(s), buf, len, flags, from, fromlen);
+ if (r == SOCKET_ERROR)
+ errno = map_errno(WSAGetLastError());
+ });
+ return r;
+}
+
+#undef send
+
+int
+rb_w32_send(int s, const char *buf, int len, int flags)
+{
+ int r;
+ if (!NtSocketsInitialized) {
+ StartSockets();
+ }
+ RUBY_CRITICAL({
+ r = send(TO_SOCKET(s), buf, len, flags);
+ if (r == SOCKET_ERROR)
+ errno = map_errno(WSAGetLastError());
+ });
+ return r;
+}
+
+#undef sendto
+
+int
+rb_w32_sendto(int s, const char *buf, int len, int flags,
+ struct sockaddr *to, int tolen)
+{
+ int r;
+ if (!NtSocketsInitialized) {
+ StartSockets();
+ }
+ RUBY_CRITICAL({
+ r = sendto(TO_SOCKET(s), buf, len, flags, to, tolen);
+ if (r == SOCKET_ERROR)
+ errno = map_errno(WSAGetLastError());
+ });
+ return r;
+}
+
+#undef setsockopt
+
+int
+rb_w32_setsockopt(int s, int level, int optname, 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
+
+int
+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;
+}
+
+#ifdef USE_WINSOCK2
+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, 0);
+ break;
+ }
+ }
+
+ free(proto_buffers);
+ }
+ }
+
+ return out;
+}
+#endif /* USE_WINSOCK2 */
+
+#undef socket
+#ifdef USE_WINSOCK2
+#define open_socket(a, t, p) open_ifs_socket(a, t, p)
+#else
+#define open_socket(a, t, p) socket(a, t, p)
+#endif
+
+int
+rb_w32_socket(int af, int type, int protocol)
+{
+ SOCKET s;
+ int fd;
+
+ if (!NtSocketsInitialized) {
+ StartSockets();
+ }
+ RUBY_CRITICAL({
+ s = open_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);
+ }
+ });
+ return fd;
+}
+
+#undef gethostbyaddr
+
+struct hostent *
+rb_w32_gethostbyaddr (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
+
+struct hostent *
+rb_w32_gethostbyname (char *name)
+{
+ struct hostent *r;
+ if (!NtSocketsInitialized) {
+ StartSockets();
+ }
+ RUBY_CRITICAL({
+ r = gethostbyname(name);
+ if (r == NULL)
+ errno = map_errno(WSAGetLastError());
+ });
+ return r;
+}
+
+#undef gethostname
+
+int
+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
+
+struct protoent *
+rb_w32_getprotobyname (char *name)
+{
+ struct protoent *r;
+ if (!NtSocketsInitialized) {
+ StartSockets();
+ }
+ RUBY_CRITICAL({
+ r = getprotobyname(name);
+ if (r == NULL)
+ errno = map_errno(WSAGetLastError());
+ });
+ return r;
+}
+
+#undef getprotobynumber
+
+struct protoent *
+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
+
+struct servent *
+rb_w32_getservbyname (char *name, 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
+
+struct servent *
+rb_w32_getservbyport (int port, char *proto)
+{
+ struct servent *r;
+ if (!NtSocketsInitialized) {
+ StartSockets();
+ }
+ RUBY_CRITICAL({
+ r = getservbyport(port, proto);
+ if (r == NULL)
+ errno = map_errno(WSAGetLastError());
+ });
+ return r;
+}
+
+//
+// Networking stubs
+//
+
+void endhostent() {}
+void endnetent() {}
+void endprotoent() {}
+void endservent() {}
+
+struct netent *getnetent (void) {return (struct netent *) NULL;}
+
+struct netent *getnetbyaddr(long net, int type) {return (struct netent *)NULL;}
+
+struct netent *getnetbyname(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) {}
+
+int
+fcntl(int fd, int cmd, ...)
+{
+ SOCKET sock = TO_SOCKET(fd);
+ va_list va;
+ int arg;
+ int ret;
+ u_long ioctlArg;
+
+ if (!is_socket(sock)) {
+ errno = EBADF;
+ return -1;
+ }
+ if (cmd != F_SETFL) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ va_start(va, cmd);
+ arg = va_arg(va, int);
+ va_end(va);
+ if (arg & O_NONBLOCK) {
+ ioctlArg = 1;
+ }
+ else {
+ ioctlArg = 0;
+ }
+ RUBY_CRITICAL({
+ ret = ioctlsocket(sock, FIONBIO, &ioctlArg);
+ if (ret == -1) {
+ errno = map_errno(WSAGetLastError());
+ }
+ });
+
+ return ret;
+}
+
+#ifndef WNOHANG
+#define WNOHANG -1
+#endif
+
+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 occured, return immediatly. */
+ err = GetLastError();
+ if (err == ERROR_INVALID_PARAMETER)
+ errno = ECHILD;
+ else
+ errno = map_errno(GetLastError());
+ CloseChildHandle(child);
+ return -1;
+ }
+ if (exitcode != STILL_ACTIVE) {
+ /* If already died, return immediatly. */
+ rb_pid_t pid = child->pid;
+ CloseChildHandle(child);
+ if (stat_loc) *stat_loc = exitcode << 8;
+ return pid;
+ }
+ return 0;
+}
+
+rb_pid_t
+waitpid(rb_pid_t pid, int *stat_loc, int options)
+{
+ DWORD timeout;
+
+ if (options == WNOHANG) {
+ timeout = 0;
+ } else {
+ timeout = INFINITE;
+ }
+
+ if (pid == -1) {
+ int count = 0;
+ DWORD ret;
+ HANDLE events[MAXCHILDNUM + 1];
+
+ 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;
+ }
+ events[count] = interrupted_event;
+
+ ret = WaitForMultipleEvents(count + 1, events, FALSE, timeout, TRUE);
+ if (ret == WAIT_TIMEOUT) return 0;
+ if ((ret -= WAIT_OBJECT_0) == count) {
+ ResetSignal(interrupted_event);
+ errno = EINTR;
+ return -1;
+ }
+ if (ret > count) {
+ errno = map_errno(GetLastError());
+ return -1;
+ }
+
+ return poll_child_status(ChildRecord + ret, stat_loc);
+ }
+ else {
+ struct ChildRecord* child = FindChildSlot(pid);
+ if (!child) {
+ errno = ECHILD;
+ return -1;
+ }
+
+ while (!(pid = poll_child_status(child, stat_loc))) {
+ /* wait... */
+ if (wait_events(child->hProcess, timeout) != WAIT_OBJECT_0) {
+ /* still active */
+ pid = 0;
+ break;
+ }
+ }
+ }
+
+ return pid;
+}
+
+#include <sys/timeb.h>
+
+int _cdecl
+gettimeofday(struct timeval *tv, struct timezone *tz)
+{
+ SYSTEMTIME st;
+ time_t t;
+ struct tm tm;
+
+ GetLocalTime(&st);
+ tm.tm_sec = st.wSecond;
+ tm.tm_min = st.wMinute;
+ tm.tm_hour = st.wHour;
+ tm.tm_mday = st.wDay;
+ tm.tm_mon = st.wMonth - 1;
+ tm.tm_year = st.wYear - 1900;
+ tm.tm_isdst = -1;
+ t = mktime(&tm);
+ tv->tv_sec = t;
+ tv->tv_usec = st.wMilliseconds * 1000;
+
+ return 0;
+}
+
+char *
+rb_w32_getcwd(char *buffer, int size)
+{
+ char *p = buffer;
+ char *bp;
+ 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;
+ }
+
+ for (bp = p; *bp != '\0'; bp = CharNext(bp)) {
+ if (*bp == '\\') {
+ *bp = '/';
+ }
+ }
+
+ return p;
+}
+
+int
+chown(const char *path, int owner, int group)
+{
+ return 0;
+}
+
+int
+kill(int pid, int sig)
+{
+ int ret = 0;
+ DWORD err;
+
+ if (pid <= 0) {
+ errno = EINVAL;
+ return -1;
+ }
+
+ if (IsWin95()) pid = -pid;
+ 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({
+ if (!GenerateConsoleCtrlEvent(CTRL_C_EVENT, (DWORD)pid)) {
+ if ((err = GetLastError()) == 0)
+ errno = EPERM;
+ else
+ errno = map_errno(GetLastError());
+ ret = -1;
+ }
+ });
+ break;
+
+ case SIGKILL:
+ RUBY_CRITICAL({
+ HANDLE hProc = OpenProcess(PROCESS_TERMINATE, FALSE, (DWORD)pid);
+ if (hProc == NULL || hProc == INVALID_HANDLE_VALUE) {
+ if (GetLastError() == ERROR_INVALID_PARAMETER) {
+ errno = ESRCH;
+ }
+ else {
+ errno = EPERM;
+ }
+ ret = -1;
+ }
+ else {
+ if (!TerminateProcess(hProc, 0)) {
+ errno = EPERM;
+ ret = -1;
+ }
+ CloseHandle(hProc);
+ }
+ });
+ break;
+
+ default:
+ errno = EINVAL;
+ ret = -1;
+ break;
+ }
+
+ return ret;
+}
+
+int
+link(char *from, char *to)
+{
+ static BOOL (WINAPI *pCreateHardLink)(LPCTSTR, LPCTSTR, LPSECURITY_ATTRIBUTES) = NULL;
+ static int myerrno = 0;
+
+ if (!pCreateHardLink && !myerrno) {
+ HANDLE hKernel;
+
+ hKernel = GetModuleHandle("kernel32.dll");
+ if (hKernel) {
+ pCreateHardLink = (BOOL (WINAPI *)(LPCTSTR, LPCTSTR, LPSECURITY_ATTRIBUTES))GetProcAddress(hKernel, "CreateHardLinkA");
+ if (!pCreateHardLink) {
+ myerrno = map_errno(GetLastError());
+ }
+ CloseHandle(hKernel);
+ }
+ else {
+ myerrno = map_errno(GetLastError());
+ }
+ }
+ if (!pCreateHardLink) {
+ errno = myerrno;
+ return -1;
+ }
+
+ if (!pCreateHardLink(to, from, NULL)) {
+ errno = map_errno(GetLastError());
+ return -1;
+ }
+
+ return 0;
+}
+
+int
+wait()
+{
+ return 0;
+}
+
+char *
+rb_w32_getenv(const char *name)
+{
+ int len = strlen(name);
+ char *env;
+
+ if (envarea)
+ FreeEnvironmentStrings(envarea);
+ envarea = GetEnvironmentStrings();
+ if (!envarea) {
+ map_errno(GetLastError());
+ return NULL;
+ }
+
+ for (env = envarea; *env; env += strlen(env) + 1)
+ if (strncasecmp(env, name, len) == 0 && *(env + len) == '=')
+ return env + len + 1;
+
+ return NULL;
+}
+
+int
+rb_w32_rename(const char *oldpath, const char *newpath)
+{
+ int res = 0;
+ int oldatts;
+ int newatts;
+
+ oldatts = GetFileAttributes(oldpath);
+ newatts = GetFileAttributes(newpath);
+
+ if (oldatts == -1) {
+ errno = map_errno(GetLastError());
+ return -1;
+ }
+
+ RUBY_CRITICAL({
+ if (newatts != -1 && newatts & FILE_ATTRIBUTE_READONLY)
+ SetFileAttributesA(newpath, newatts & ~ FILE_ATTRIBUTE_READONLY);
+
+ if (!MoveFile(oldpath, newpath))
+ res = -1;
+
+ if (res) {
+ switch (GetLastError()) {
+ case ERROR_ALREADY_EXISTS:
+ case ERROR_FILE_EXISTS:
+ if (IsWinNT()) {
+ if (MoveFileEx(oldpath, newpath, MOVEFILE_REPLACE_EXISTING))
+ res = 0;
+ } else {
+ for (;;) {
+ if (!DeleteFile(newpath) && GetLastError() != ERROR_FILE_NOT_FOUND)
+ break;
+ else if (MoveFile(oldpath, newpath)) {
+ res = 0;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ if (res)
+ errno = map_errno(GetLastError());
+ else
+ SetFileAttributes(newpath, oldatts);
+ });
+
+ return res;
+}
+
+static int
+isUNCRoot(const char *path)
+{
+ if (path[0] == '\\' && path[1] == '\\') {
+ const char *p;
+ for (p = path + 2; *p; p = CharNext(p)) {
+ if (*p == '\\')
+ break;
+ }
+ if (p[0] && p[1]) {
+ for (p++; *p; p = CharNext(p)) {
+ if (*p == '\\')
+ break;
+ }
+ if (!p[0] || !p[1] || (p[1] == '.' && !p[2]))
+ return 1;
+ }
+ }
+ return 0;
+}
+
+static time_t
+filetime_to_unixtime(const FILETIME *ft)
+{
+ FILETIME loc;
+ SYSTEMTIME st;
+ struct tm tm;
+ time_t t;
+
+ if (!FileTimeToLocalFileTime(ft, &loc)) {
+ return 0;
+ }
+ if (!FileTimeToSystemTime(&loc, &st)) {
+ return 0;
+ }
+ memset(&tm, 0, sizeof(tm));
+ tm.tm_year = st.wYear - 1900;
+ tm.tm_mon = st.wMonth - 1;
+ tm.tm_mday = st.wDay;
+ tm.tm_hour = st.wHour;
+ tm.tm_min = st.wMinute;
+ tm.tm_sec = st.wSecond;
+ tm.tm_isdst = -1;
+ t = mktime(&tm);
+ return t == -1 ? 0 : t;
+}
+
+static unsigned
+fileattr_to_unixmode(DWORD attr, const char *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 char *end = path + strlen(path);
+ while (path < end) {
+ end = CharPrev(path, end);
+ if (*end == '.') {
+ if ((strcmpi(end, ".bat") == 0) ||
+ (strcmpi(end, ".cmd") == 0) ||
+ (strcmpi(end, ".com") == 0) ||
+ (strcmpi(end, ".exe") == 0)) {
+ mode |= S_IEXEC;
+ }
+ break;
+ }
+ }
+ }
+
+ mode |= (mode & 0700) >> 3;
+ mode |= (mode & 0700) >> 6;
+
+ return mode;
+}
+
+static int
+winnt_stat(const char *path, struct stat *st)
+{
+ HANDLE h;
+ WIN32_FIND_DATA wfd;
+
+ memset(st, 0, sizeof(struct stat));
+ st->st_nlink = 1;
+
+ if (_mbspbrk(path, "?*")) {
+ errno = ENOENT;
+ return -1;
+ }
+ h = FindFirstFile(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 = wfd.nFileSizeLow; /* TODO: 64bit support */
+ }
+ else {
+ // If runtime stat(2) is called for network shares, it fails on WinNT.
+ // Because GetDriveType returns 1 for network shares. (Win98 returns 4)
+ DWORD attr = GetFileAttributes(path);
+ if (attr == -1) {
+ errno = map_errno(GetLastError());
+ return -1;
+ }
+ st->st_mode = fileattr_to_unixmode(attr, path);
+ }
+
+ st->st_dev = st->st_rdev = (isalpha(path[0]) && path[1] == ':') ?
+ toupper(path[0]) - 'A' : _getdrive() - 1;
+
+ return 0;
+}
+
+int
+rb_w32_stat(const char *path, struct stat *st)
+{
+ const char *p;
+ char *buf1, *s, *end;
+ int len;
+ int ret;
+
+ if (!path || !st) {
+ errno = EFAULT;
+ return -1;
+ }
+ buf1 = ALLOCA_N(char, strlen(path) + 2);
+ for (p = path, s = buf1; *p; p++, s++) {
+ if (*p == '/')
+ *s = '\\';
+ else
+ *s = *p;
+ }
+ *s = '\0';
+ len = s - buf1;
+ if (!len || '\"' == *(--s)) {
+ errno = ENOENT;
+ return -1;
+ }
+ end = CharPrev(buf1, buf1 + len);
+
+ if (isUNCRoot(buf1)) {
+ if (*end == '.')
+ *end = '\0';
+ else if (*end != '\\')
+ strcat(buf1, "\\");
+ } else if (*end == '\\' || (buf1 + 1 == end && *end == ':'))
+ strcat(buf1, ".");
+
+ ret = IsWinNT() ? winnt_stat(buf1, st) : stat(buf1, st);
+ if (ret == 0) {
+ st->st_mode &= ~(S_IWGRP | S_IWOTH);
+ }
+ return ret;
+}
+
+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;
+}
+
+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;
+}
+
+#undef Sleep
+#define yield_once() Sleep(0)
+#define yield_until(condition) do yield_once(); while (!(condition))
+
+static DWORD
+wait_events(HANDLE event, DWORD timeout)
+{
+ HANDLE events[2];
+ int count = 0;
+ DWORD ret;
+
+ if (event) {
+ events[count++] = event;
+ }
+ events[count++] = interrupted_event;
+
+ ret = WaitForMultipleEvents(count, events, FALSE, timeout, TRUE);
+
+ if (ret == WAIT_OBJECT_0 + count - 1) {
+ ResetSignal(interrupted_event);
+ errno = EINTR;
+ }
+
+ return ret;
+}
+
+static CRITICAL_SECTION *
+system_state(void)
+{
+ static int initialized = 0;
+ static CRITICAL_SECTION syssect;
+
+ if (!initialized) {
+ InitializeCriticalSection(&syssect);
+ initialized = 1;
+ }
+ return &syssect;
+}
+
+static LONG flag_interrupt = -1;
+static volatile DWORD tlsi_interrupt = TLS_OUT_OF_INDEXES;
+
+void
+rb_w32_enter_critical(void)
+{
+ if (IsWinNT()) {
+ EnterCriticalSection(system_state());
+ return;
+ }
+
+ if (tlsi_interrupt == TLS_OUT_OF_INDEXES) {
+ tlsi_interrupt = TlsAlloc();
+ }
+
+ {
+ DWORD ti = (DWORD)TlsGetValue(tlsi_interrupt);
+ while (InterlockedIncrement(&flag_interrupt) > 0 && !ti) {
+ InterlockedDecrement(&flag_interrupt);
+ Sleep(1);
+ }
+ TlsSetValue(tlsi_interrupt, (PVOID)++ti);
+ }
+}
+
+void
+rb_w32_leave_critical(void)
+{
+ if (IsWinNT()) {
+ LeaveCriticalSection(system_state());
+ return;
+ }
+
+ InterlockedDecrement(&flag_interrupt);
+ TlsSetValue(tlsi_interrupt, (PVOID)((DWORD)TlsGetValue(tlsi_interrupt) - 1));
+}
+
+struct handler_arg_t {
+ void (*handler)(int);
+ int arg;
+ int status;
+ int finished;
+ HANDLE handshake;
+};
+
+static void
+rb_w32_call_handler(struct handler_arg_t* h)
+{
+ int status;
+ RUBY_CRITICAL(rb_protect((VALUE (*)(VALUE))h->handler, (VALUE)h->arg, &h->status);
+ status = h->status;
+ SetEvent(h->handshake));
+ if (status) {
+ rb_jump_tag(status);
+ }
+ h->finished = 1;
+ yield_until(0);
+}
+
+static struct handler_arg_t *
+setup_handler(struct handler_arg_t *harg, int arg, void (*handler)(int),
+ HANDLE handshake)
+{
+ harg->handler = handler;
+ harg->arg = arg;
+ harg->status = 0;
+ harg->finished = 0;
+ harg->handshake = handshake;
+ return harg;
+}
+
+static void
+setup_call(CONTEXT* ctx, struct handler_arg_t *harg)
+{
+#ifdef _M_IX86
+ DWORD *esp = (DWORD *)ctx->Esp;
+ *--esp = (DWORD)harg;
+ *--esp = ctx->Eip;
+ ctx->Esp = (DWORD)esp;
+ ctx->Eip = (DWORD)rb_w32_call_handler;
+#else
+#ifndef _WIN32_WCE
+#error unsupported processor
+#endif
+#endif
+}
+
+void
+rb_w32_interrupted(void)
+{
+ SetSignal(interrupted_event);
+}
+
+int
+rb_w32_main_context(int arg, void (*handler)(int))
+{
+ static HANDLE interrupt_done = NULL;
+ struct handler_arg_t harg;
+ CONTEXT ctx_orig;
+ HANDLE current_thread = GetCurrentThread();
+ int old_priority = GetThreadPriority(current_thread);
+
+ if (GetCurrentThreadId() == main_thread.id) return FALSE;
+
+ rb_w32_interrupted();
+
+ RUBY_CRITICAL({ /* the main thread must be in user state */
+ CONTEXT ctx;
+
+ SuspendThread(main_thread.handle);
+ SetThreadPriority(current_thread, GetThreadPriority(main_thread.handle));
+
+ ZeroMemory(&ctx, sizeof(CONTEXT));
+ ctx.ContextFlags = CONTEXT_FULL | CONTEXT_FLOATING_POINT;
+ GetThreadContext(main_thread.handle, &ctx);
+ ctx_orig = ctx;
+
+ /* handler context setup */
+ if (!interrupt_done) {
+ interrupt_done = CreateEvent(NULL, FALSE, FALSE, NULL);
+ /* anonymous one-shot event */
+ }
+ else {
+ ResetEvent(interrupt_done);
+ }
+ setup_call(&ctx, setup_handler(&harg, arg, handler, interrupt_done));
+
+ ctx.ContextFlags = CONTEXT_CONTROL;
+ SetThreadContext(main_thread.handle, &ctx);
+ ResumeThread(main_thread.handle);
+ });
+
+ /* give a chance to the main thread */
+ yield_once();
+ WaitForSingleObject(interrupt_done, INFINITE); /* handshaking */
+
+ if (!harg.status) {
+ /* no exceptions raised, restore old context. */
+ RUBY_CRITICAL({
+ /* ensure the main thread is in user state. */
+ yield_until(harg.finished);
+
+ SuspendThread(main_thread.handle);
+ ctx_orig.ContextFlags = CONTEXT_FULL | CONTEXT_FLOATING_POINT;
+ SetThreadContext(main_thread.handle, &ctx_orig);
+ ResumeThread(main_thread.handle);
+ });
+ }
+ /* otherwise leave the main thread raised */
+
+ SetThreadPriority(current_thread, old_priority);
+
+ return TRUE;
+}
+
+int
+rb_w32_sleep(unsigned long msec)
+{
+ DWORD ret;
+ RUBY_CRITICAL(ret = wait_events(NULL, msec));
+ yield_once();
+ CHECK_INTS;
+ return ret != WAIT_TIMEOUT;
+}
+
+static void
+catch_interrupt(void)
+{
+ yield_once();
+ RUBY_CRITICAL(wait_events(NULL, 0));
+ CHECK_INTS;
+}
+
+#undef fgetc
+int
+rb_w32_getc(FILE* stream)
+{
+ int c, trap_immediate = rb_trap_immediate;
+#ifndef _WIN32_WCE
+ if (enough_to_get(stream->FILE_COUNT)) {
+ c = (unsigned char)*stream->FILE_READPTR++;
+ rb_trap_immediate = trap_immediate;
+ }
+ else
+#endif
+ {
+ c = _filbuf(stream);
+#if defined __BORLANDC__ || defined _WIN32_WCE
+ if ((c == EOF) && (errno == EPIPE)) {
+ clearerr(stream);
+ }
+#endif
+ rb_trap_immediate = trap_immediate;
+ catch_interrupt();
+ }
+ return c;
+}
+
+#undef fputc
+int
+rb_w32_putc(int c, FILE* stream)
+{
+ int trap_immediate = rb_trap_immediate;
+#ifndef _WIN32_WCE
+ if (enough_to_put(stream->FILE_COUNT)) {
+ c = (unsigned char)(*stream->FILE_READPTR++ = (char)c);
+ rb_trap_immediate = trap_immediate;
+ }
+ else
+#endif
+ {
+ c = _flsbuf(c, stream);
+ rb_trap_immediate = trap_immediate;
+ catch_interrupt();
+ }
+ return c;
+}
+
+struct asynchronous_arg_t {
+ /* output field */
+ void* stackaddr;
+ int errnum;
+
+ /* input field */
+ VALUE (*func)(VALUE self, int argc, VALUE* argv);
+ VALUE self;
+ int argc;
+ VALUE* argv;
+};
+
+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;
+}
+
+VALUE
+rb_w32_asynchronize(asynchronous_func_t func, VALUE self,
+ int argc, VALUE* argv, VALUE 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 (wait_events(thr, 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:%d", GetLastError());
+ }
+
+ if (interrupted) {
+ CHECK_INTS;
+ }
+
+ return val;
+}
+
+char **
+rb_w32_get_environ(void)
+{
+ char *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.
+ * (U.N. 2001-11-15)
+ */
+ envtop = GetEnvironmentStrings();
+ for (env = envtop, num = 0; *env; env += strlen(env) + 1)
+ if (*env != '=') num++;
+
+ myenvtop = (char **)malloc(sizeof(char *) * (num + 1));
+ for (env = envtop, myenv = myenvtop; *env; env += strlen(env) + 1) {
+ if (*env != '=') {
+ if (!(*myenv = (char *)malloc(strlen(env) + 1))) {
+ break;
+ }
+ strcpy(*myenv, env);
+ myenv++;
+ }
+ }
+ *myenv = NULL;
+ FreeEnvironmentStrings(envtop);
+
+ return myenvtop;
+}
+
+void
+rb_w32_free_environ(char **env)
+{
+ char **t = env;
+
+ while (*t) free(*t++);
+ free(env);
+}
+
+#undef getpid
+rb_pid_t
+rb_w32_getpid(void)
+{
+ rb_pid_t pid;
+
+ pid = getpid();
+
+ if (IsWin95()) pid = -pid;
+
+ return pid;
+}
+
+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;
+}
+
+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);
+ return _close(fd);
+ }
+ _set_osfhnd(fd, (SOCKET)INVALID_HANDLE_VALUE);
+ _close(fd);
+ errno = save_errno;
+ if (closesocket(sock) == SOCKET_ERROR) {
+ errno = map_errno(WSAGetLastError());
+ return -1;
+ }
+ return 0;
+}
+
+#undef read
+size_t
+rb_w32_read(int fd, void *buf, size_t size)
+{
+ SOCKET sock = TO_SOCKET(fd);
+
+ if (!is_socket(sock))
+ return read(fd, buf, size);
+ else
+ return rb_w32_recv(fd, buf, size, 0);
+}
+
+#undef write
+size_t
+rb_w32_write(int fd, const void *buf, size_t size)
+{
+ SOCKET sock = TO_SOCKET(fd);
+
+ if (!is_socket(sock))
+ return write(fd, buf, size);
+ else
+ return rb_w32_send(fd, buf, size, 0);
+}
+
+static int
+unixtime_to_filetime(time_t time, FILETIME *ft)
+{
+ struct tm *tm;
+ SYSTEMTIME st;
+ FILETIME lt;
+
+ tm = localtime(&time);
+ st.wYear = tm->tm_year + 1900;
+ st.wMonth = tm->tm_mon + 1;
+ st.wDayOfWeek = tm->tm_wday;
+ st.wDay = tm->tm_mday;
+ st.wHour = tm->tm_hour;
+ st.wMinute = tm->tm_min;
+ st.wSecond = tm->tm_sec;
+ st.wMilliseconds = 0;
+ if (!SystemTimeToFileTime(&st, &lt) ||
+ !LocalFileTimeToFileTime(&lt, ft)) {
+ errno = map_errno(GetLastError());
+ return -1;
+ }
+ return 0;
+}
+
+int
+rb_w32_utime(const char *path, struct utimbuf *times)
+{
+ HANDLE hFile;
+ SYSTEMTIME st;
+ FILETIME atime, mtime;
+ struct tm *tm;
+ struct stat stat;
+ int ret = 0;
+
+ if (rb_w32_stat(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 = GetFileAttributes(path);
+ if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY))
+ SetFileAttributes(path, attr & ~FILE_ATTRIBUTE_READONLY);
+ hFile = CreateFile(path, GENERIC_WRITE, 0, 0, OPEN_EXISTING,
+ IsWin95() ? 0 : 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))
+ SetFileAttributes(path, attr);
+ });
+
+ return ret;
+}
+
+int
+rb_w32_vsnprintf(char *buf, size_t size, const char *format, va_list va)
+{
+ int ret = _vsnprintf(buf, size, format, va);
+ if (size > 0) buf[size - 1] = 0;
+ return ret;
+}
+
+int
+rb_w32_snprintf(char *buf, size_t size, const char *format, ...)
+{
+ int ret;
+ va_list va;
+
+ va_start(va, format);
+ ret = vsnprintf(buf, size, format, va);
+ va_end(va);
+ return ret;
+}
+
+int
+rb_w32_mkdir(const char *path, int mode)
+{
+ int ret = -1;
+ RUBY_CRITICAL(do {
+ if (CreateDirectory(path, NULL) == FALSE) {
+ errno = map_errno(GetLastError());
+ break;
+ }
+ if (chmod(path, mode) == -1) {
+ RemoveDirectory(path);
+ break;
+ }
+ ret = 0;
+ } while (0));
+ return ret;
+}
+
+int
+rb_w32_rmdir(const char *path)
+{
+ int ret = 0;
+ RUBY_CRITICAL({
+ const DWORD attr = GetFileAttributes(path);
+ if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) {
+ SetFileAttributes(path, attr & ~FILE_ATTRIBUTE_READONLY);
+ }
+ if (RemoveDirectory(path) == FALSE) {
+ errno = map_errno(GetLastError());
+ ret = -1;
+ if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) {
+ SetFileAttributes(path, attr);
+ }
+ }
+ });
+ return ret;
+}
+
+int
+rb_w32_unlink(const char *path)
+{
+ int ret = 0;
+ RUBY_CRITICAL({
+ const DWORD attr = GetFileAttributes(path);
+ if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) {
+ SetFileAttributes(path, attr & ~FILE_ATTRIBUTE_READONLY);
+ }
+ if (DeleteFile(path) == FALSE) {
+ errno = map_errno(GetLastError());
+ ret = -1;
+ if (attr != (DWORD)-1 && (attr & FILE_ATTRIBUTE_READONLY)) {
+ SetFileAttributes(path, attr);
+ }
+ }
+ });
+ return ret;
+}
+
+#if !defined(__BORLANDC__) && !defined(_WIN32_WCE)
+int
+rb_w32_isatty(int fd)
+{
+ if (!(_osfile(fd) & FOPEN)) {
+ errno = EBADF;
+ return 0;
+ }
+ if (!(_osfile(fd) & FDEV)) {
+ errno = ENOTTY;
+ return 0;
+ }
+ return 1;
+}
+#endif
+
+//
+// Fix bcc32's stdio bug
+//
+
+#ifdef __BORLANDC__
+static int
+too_many_files()
+{
+ FILE *f;
+ for (f = _streams; f < _streams + _nfile; f++) {
+ if (f->fd < 0) return 0;
+ }
+ return 1;
+}
+
+#undef fopen
+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;
+}
+
+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;
+}
+
+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
diff --git a/ruby_1_8_6/win32/win32.h b/ruby_1_8_6/win32/win32.h
new file mode 100644
index 0000000000..d3cd0ee21c
--- /dev/null
+++ b/ruby_1_8_6/win32/win32.h
@@ -0,0 +1,560 @@
+#ifndef RUBY_WIN32_H
+#define RUBY_WIN32_H
+
+/*
+ * 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.
+ *
+ */
+
+//
+// Definitions for NT port of Perl
+//
+
+
+//
+// Ok now we can include the normal include files.
+//
+
+// #include <stdarg.h> conflict with varargs.h?
+// There is function-name conflitct, so we rename it
+#if !defined(IN) && !defined(FLOAT)
+#define OpenFile WINAPI_OpenFile
+#ifdef __BORLANDC__
+#define USE_WINSOCK2
+#endif
+#ifdef USE_WINSOCK2
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+#else
+#include <windows.h>
+#include <winsock.h>
+#endif
+#undef OpenFile
+#endif
+
+#define NT 1 /* deprecated */
+
+#ifdef _WIN32_WCE
+#undef CharNext
+#define CharNext CharNextA
+#endif
+
+//
+// We're not using Microsoft's "extensions" to C for
+// Structured Exception Handling (SEH) so we can nuke these
+//
+#undef try
+#undef except
+#undef finally
+#undef leave
+
+#if defined(__cplusplus)
+extern "C++" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <direct.h>
+#include <process.h>
+#include <time.h>
+#include <math.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#if !defined(__BORLANDC__)
+# include <sys/utime.h>
+#else
+# include <utime.h>
+#endif
+#include <io.h>
+#include <malloc.h>
+
+#if defined(__cplusplus)
+}
+#endif
+
+#ifdef _M_IX86
+# define WIN95 1
+#else
+# undef WIN95
+#endif
+
+#ifdef WIN95
+extern DWORD rb_w32_osid(void);
+#define rb_w32_iswinnt() (rb_w32_osid() == VER_PLATFORM_WIN32_NT)
+#define rb_w32_iswin95() (rb_w32_osid() == VER_PLATFORM_WIN32_WINDOWS)
+#else
+#define rb_w32_iswinnt() TRUE
+#define rb_w32_iswin95() FALSE
+#endif
+
+#define WNOHANG -1
+
+#undef getc
+#undef putc
+#undef fgetc
+#undef fputc
+#undef getchar
+#undef putchar
+#undef fgetchar
+#undef fputchar
+#undef utime
+#define getc(_stream) rb_w32_getc(_stream)
+#define putc(_c, _stream) rb_w32_putc(_c, _stream)
+#define fgetc(_stream) getc(_stream)
+#define fputc(_c, _stream) putc(_c, _stream)
+#define getchar() rb_w32_getc(stdin)
+#define putchar(_c) rb_w32_putc(_c, stdout)
+#define fgetchar() getchar()
+#define fputchar(_c) putchar(_c)
+#define utime(_p, _t) rb_w32_utime(_p, _t)
+
+#define strcasecmp(s1, s2) stricmp(s1, s2)
+#define strncasecmp(s1, s2, n) strnicmp(s1, s2, n)
+
+#define close(h) rb_w32_close(h)
+#define fclose(f) rb_w32_fclose(f)
+#define read(f, b, s) rb_w32_read(f, b, s)
+#define write(f, b, s) rb_w32_write(f, b, s)
+#define getpid() rb_w32_getpid()
+#define sleep(x) rb_w32_sleep((x)*1000)
+#ifdef __BORLANDC__
+#define creat(p, m) _creat(p, m)
+#define eof() _eof()
+#define filelength(h) _filelength(h)
+#define mktemp(t) _mktemp(t)
+#define tell(h) _tell(h)
+#define unlink(p) _unlink(p)
+#define _open _sopen
+#define sopen _sopen
+#undef fopen
+#define fopen(p, m) rb_w32_fopen(p, m)
+#undef fdopen
+#define fdopen(h, m) rb_w32_fdopen(h, m)
+#undef fsopen
+#define fsopen(p, m, sh) rb_w32_fsopen(p, m, sh)
+#endif
+#define fsync(h) _commit(h)
+#undef stat
+#define stat(path,st) rb_w32_stat(path,st)
+#undef execv
+#define execv(path,argv) do_aspawn(P_OVERLAY,path,argv)
+#if !defined(__BORLANDC__) && !defined(_WIN32_WCE)
+#undef isatty
+#define isatty(h) rb_w32_isatty(h)
+#endif
+#undef mkdir
+#define mkdir(p, m) rb_w32_mkdir(p, m)
+#undef rmdir
+#define rmdir(p) rb_w32_rmdir(p)
+#undef unlink
+#define unlink(p) rb_w32_unlink(p)
+
+#ifdef __MINGW32__
+struct timezone {
+ int tz_minuteswest;
+ int tz_dsttime;
+};
+#undef isascii
+#define isascii __isascii
+#endif
+extern void NtInitialize(int *, char ***);
+extern int rb_w32_cmdvector(const char *, char ***);
+extern rb_pid_t pipe_exec(char *, int, FILE **, FILE **);
+extern int flock(int fd, int oper);
+extern int rb_w32_accept(int, struct sockaddr *, int *);
+extern int rb_w32_bind(int, struct sockaddr *, int);
+extern int rb_w32_connect(int, struct sockaddr *, int);
+extern void rb_w32_fdset(int, fd_set*);
+extern void rb_w32_fdclr(int, fd_set*);
+extern int rb_w32_fdisset(int, fd_set*);
+extern long rb_w32_select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
+extern int rb_w32_getpeername(int, struct sockaddr *, int *);
+extern int rb_w32_getsockname(int, struct sockaddr *, int *);
+extern int rb_w32_getsockopt(int, int, int, char *, int *);
+extern int rb_w32_ioctlsocket(int, long, u_long *);
+extern int rb_w32_listen(int, int);
+extern int rb_w32_recv(int, char *, int, int);
+extern int rb_w32_recvfrom(int, char *, int, int, struct sockaddr *, int *);
+extern int rb_w32_send(int, const char *, int, int);
+extern int rb_w32_sendto(int, const char *, int, int, struct sockaddr *, int);
+extern int rb_w32_setsockopt(int, int, int, char *, int);
+extern int rb_w32_shutdown(int, int);
+extern int rb_w32_socket(int, int, int);
+extern SOCKET rb_w32_get_osfhandle(int);
+extern struct hostent * rb_w32_gethostbyaddr(char *, int, int);
+extern struct hostent * rb_w32_gethostbyname(char *);
+extern int rb_w32_gethostname(char *, int);
+extern struct protoent * rb_w32_getprotobyname(char *);
+extern struct protoent * rb_w32_getprotobynumber(int);
+extern struct servent * rb_w32_getservbyname(char *, char *);
+extern struct servent * rb_w32_getservbyport(int, char *);
+extern char * rb_w32_getcwd(char *, int);
+extern char * rb_w32_getenv(const char *);
+extern int rb_w32_rename(const char *, const char *);
+extern int rb_w32_stat(const char *, struct stat *);
+extern char **rb_w32_get_environ(void);
+extern void rb_w32_free_environ(char **);
+
+#define vsnprintf(s,n,f,l) rb_w32_vsnprintf(s,n,f,l)
+#define snprintf rb_w32_snprintf
+extern int rb_w32_vsnprintf(char *, size_t, const char *, va_list);
+extern int rb_w32_snprintf(char *, size_t, const char *, ...);
+
+extern int chown(const char *, int, int);
+extern int link(char *, char *);
+extern int gettimeofday(struct timeval *, struct timezone *);
+extern rb_pid_t waitpid (rb_pid_t, int *, int);
+extern int do_spawn(int, char *);
+extern int do_aspawn(int, char *, char **);
+extern int kill(int, int);
+extern int fcntl(int, int, ...);
+extern rb_pid_t rb_w32_getpid(void);
+
+#if !defined(__BORLANDC__) && !defined(_WIN32_WCE)
+extern int rb_w32_isatty(int);
+#endif
+extern int rb_w32_mkdir(const char *, int);
+extern int rb_w32_rmdir(const char *);
+extern int rb_w32_unlink(const char*);
+
+#ifdef __BORLANDC__
+extern FILE *rb_w32_fopen(const char *, const char *);
+extern FILE *rb_w32_fdopen(int, const char *);
+extern FILE *rb_w32_fsopen(const char *, const char *, int);
+#endif
+
+#include <float.h>
+#if !defined __MINGW32__ || defined __NO_ISOCEXT
+#ifndef isnan
+#define isnan(x) _isnan(x)
+#endif
+#ifndef finite
+#define finite(x) _finite(x)
+#endif
+#ifndef copysign
+#define copysign(a, b) _copysign(a, b)
+#endif
+#ifndef scalb
+#define scalb(a, b) _scalb(a, b)
+#endif
+#endif
+
+#if !defined S_IFIFO && defined _S_IFIFO
+#define S_IFIFO _S_IFIFO
+#endif
+
+#ifdef __BORLANDC__
+#undef S_ISDIR
+#undef S_ISFIFO
+#undef S_ISBLK
+#undef S_ISCHR
+#undef S_ISREG
+#define S_ISDIR(m) (((unsigned short)(m) & S_IFMT) == S_IFDIR)
+#define S_ISFIFO(m) (((unsigned short)(m) & S_IFMT) == S_IFIFO)
+#define S_ISBLK(m) (((unsigned short)(m) & S_IFMT) == S_IFBLK)
+#define S_ISCHR(m) (((unsigned short)(m) & S_IFMT) == S_IFCHR)
+#define S_ISREG(m) (((unsigned short)(m) & S_IFMT) == S_IFREG)
+#endif
+
+#if !defined S_IRUSR && !defined __MINGW32__
+#define S_IRUSR 0400
+#endif
+#ifndef S_IRGRP
+#define S_IRGRP 0040
+#endif
+#ifndef S_IROTH
+#define S_IROTH 0004
+#endif
+
+#if !defined S_IWUSR && !defined __MINGW32__
+#define S_IWUSR 0200
+#endif
+#ifndef S_IWGRP
+#define S_IWGRP 0020
+#endif
+#ifndef S_IWOTH
+#define S_IWOTH 0002
+#endif
+
+#if !defined S_IXUSR && !defined __MINGW32__
+#define S_IXUSR 0100
+#endif
+#ifndef S_IXGRP
+#define S_IXGRP 0010
+#endif
+#ifndef S_IXOTH
+#define S_IXOTH 0001
+#endif
+
+//
+// define this so we can do inplace editing
+//
+
+#define SUFFIX
+
+//
+// stubs
+//
+#if !defined(__BORLANDC__)
+extern int ioctl (int, unsigned int, long);
+#endif
+extern rb_uid_t getuid (void);
+extern rb_uid_t geteuid (void);
+extern rb_gid_t getgid (void);
+extern rb_gid_t getegid (void);
+extern int setuid (rb_uid_t);
+extern int setgid (rb_gid_t);
+
+extern char *rb_w32_strerror(int);
+
+#define strerror(e) rb_w32_strerror(e)
+
+#define PIPE_BUF 1024
+
+#define LOCK_SH 1
+#define LOCK_EX 2
+#define LOCK_NB 4
+#define LOCK_UN 8
+
+
+#ifndef SIGINT
+#define SIGINT 2
+#endif
+#ifndef SIGKILL
+#define SIGKILL 9
+#endif
+
+
+/* #undef va_start */
+/* #undef va_end */
+
+/* winsock error map */
+#define EWOULDBLOCK WSAEWOULDBLOCK
+#define EINPROGRESS WSAEINPROGRESS
+#define EALREADY WSAEALREADY
+#define ENOTSOCK WSAENOTSOCK
+#define EDESTADDRREQ WSAEDESTADDRREQ
+#define EMSGSIZE WSAEMSGSIZE
+#define EPROTOTYPE WSAEPROTOTYPE
+#define ENOPROTOOPT WSAENOPROTOOPT
+#define EPROTONOSUPPORT WSAEPROTONOSUPPORT
+#define ESOCKTNOSUPPORT WSAESOCKTNOSUPPORT
+#define EOPNOTSUPP WSAEOPNOTSUPP
+#define EPFNOSUPPORT WSAEPFNOSUPPORT
+#define EAFNOSUPPORT WSAEAFNOSUPPORT
+#define EADDRINUSE WSAEADDRINUSE
+#define EADDRNOTAVAIL WSAEADDRNOTAVAIL
+#define ENETDOWN WSAENETDOWN
+#define ENETUNREACH WSAENETUNREACH
+#define ENETRESET WSAENETRESET
+#define ECONNABORTED WSAECONNABORTED
+#define ECONNRESET WSAECONNRESET
+#define ENOBUFS WSAENOBUFS
+#define EISCONN WSAEISCONN
+#define ENOTCONN WSAENOTCONN
+#define ESHUTDOWN WSAESHUTDOWN
+#define ETOOMANYREFS WSAETOOMANYREFS
+#define ETIMEDOUT WSAETIMEDOUT
+#define ECONNREFUSED WSAECONNREFUSED
+#define ELOOP WSAELOOP
+/*#define ENAMETOOLONG WSAENAMETOOLONG*/
+#define EHOSTDOWN WSAEHOSTDOWN
+#define EHOSTUNREACH WSAEHOSTUNREACH
+/*#define ENOTEMPTY WSAENOTEMPTY*/
+#define EPROCLIM WSAEPROCLIM
+#define EUSERS WSAEUSERS
+#define EDQUOT WSAEDQUOT
+#define ESTALE WSAESTALE
+#define EREMOTE WSAEREMOTE
+
+#define F_SETFL 1
+#define O_NONBLOCK 1
+
+#ifdef accept
+#undef accept
+#endif
+#define accept(s, a, l) rb_w32_accept(s, a, l)
+
+#ifdef bind
+#undef bind
+#endif
+#define bind(s, a, l) rb_w32_bind(s, a, l)
+
+#ifdef connect
+#undef connect
+#endif
+#define connect(s, a, l) rb_w32_connect(s, a, l)
+
+#undef FD_SET
+#define FD_SET(f, s) rb_w32_fdset(f, s)
+
+#undef FD_CLR
+#define FD_CLR(f, s) rb_w32_fdclr(f, s)
+
+#undef FD_ISSET
+#define FD_ISSET(f, s) rb_w32_fdisset(f, s)
+
+#undef select
+#define select(n, r, w, e, t) rb_w32_select(n, r, w, e, t)
+
+#ifdef getpeername
+#undef getpeername
+#endif
+#define getpeername(s, a, l) rb_w32_getpeername(s, a, l)
+
+#ifdef getsockname
+#undef getsockname
+#endif
+#define getsockname(s, a, l) rb_w32_getsockname(s, a, l)
+
+#ifdef getsockopt
+#undef getsockopt
+#endif
+#define getsockopt(s, v, n, o, l) rb_w32_getsockopt(s, v, n, o, l)
+
+#ifdef ioctlsocket
+#undef ioctlsocket
+#endif
+#define ioctlsocket(s, c, a) rb_w32_ioctlsocket(s, c, a)
+
+#ifdef listen
+#undef listen
+#endif
+#define listen(s, b) rb_w32_listen(s, b)
+
+#ifdef recv
+#undef recv
+#endif
+#define recv(s, b, l, f) rb_w32_recv(s, b, l, f)
+
+#ifdef recvfrom
+#undef recvfrom
+#endif
+#define recvfrom(s, b, l, f, fr, frl) rb_w32_recvfrom(s, b, l, f, fr, frl)
+
+#ifdef send
+#undef send
+#endif
+#define send(s, b, l, f) rb_w32_send(s, b, l, f)
+
+#ifdef sendto
+#undef sendto
+#endif
+#define sendto(s, b, l, f, t, tl) rb_w32_sendto(s, b, l, f, t, tl)
+
+#ifdef setsockopt
+#undef setsockopt
+#endif
+#define setsockopt(s, v, n, o, l) rb_w32_setsockopt(s, v, n, o, l)
+
+#ifdef shutdown
+#undef shutdown
+#endif
+#define shutdown(s, h) rb_w32_shutdown(s, h)
+
+#ifdef socket
+#undef socket
+#endif
+#define socket(s, t, p) rb_w32_socket(s, t, p)
+
+#ifdef gethostbyaddr
+#undef gethostbyaddr
+#endif
+#define gethostbyaddr(a, l, t) rb_w32_gethostbyaddr(a, l, t)
+
+#ifdef gethostbyname
+#undef gethostbyname
+#endif
+#define gethostbyname(n) rb_w32_gethostbyname(n)
+
+#ifdef gethostname
+#undef gethostname
+#endif
+#define gethostname(n, l) rb_w32_gethostname(n, l)
+
+#ifdef getprotobyname
+#undef getprotobyname
+#endif
+#define getprotobyname(n) rb_w32_getprotobyname(n)
+
+#ifdef getprotobynumber
+#undef getprotobynumber
+#endif
+#define getprotobynumber(n) rb_w32_getprotobynumber(n)
+
+#ifdef getservbyname
+#undef getservbyname
+#endif
+#define getservbyname(n, p) rb_w32_getservbyname(n, p)
+
+#ifdef getservbyport
+#undef getservbyport
+#endif
+#define getservbyport(p, pr) rb_w32_getservbyport(p, pr)
+
+#ifdef get_osfhandle
+#undef get_osfhandle
+#endif
+#define get_osfhandle(h) rb_w32_get_osfhandle(h)
+
+#ifdef getcwd
+#undef getcwd
+#endif
+#define getcwd(b, s) rb_w32_getcwd(b, s)
+
+#ifdef getenv
+#undef getenv
+#endif
+#define getenv(n) rb_w32_getenv(n)
+
+#ifdef rename
+#undef rename
+#endif
+#define rename(o, n) rb_w32_rename(o, n)
+
+struct tms {
+ long tms_utime;
+ long tms_stime;
+ long tms_cutime;
+ long tms_cstime;
+};
+
+#ifdef times
+#undef times
+#endif
+#define times(t) rb_w32_times(t)
+int rb_w32_times(struct tms *);
+
+/* thread stuff */
+HANDLE GetCurrentThreadHandle(void);
+void rb_w32_interrupted(void);
+int rb_w32_main_context(int arg, void (*handler)(int));
+int rb_w32_sleep(unsigned long msec);
+void rb_w32_enter_critical(void);
+void rb_w32_leave_critical(void);
+int rb_w32_putc(int, FILE*);
+int rb_w32_getc(FILE*);
+int rb_w32_close(int);
+int rb_w32_fclose(FILE*);
+size_t rb_w32_read(int, void *, size_t);
+size_t rb_w32_write(int, const void *, size_t);
+int rb_w32_utime(const char *, struct utimbuf *);
+#define Sleep(msec) (void)rb_w32_sleep(msec)
+
+/*
+== ***CAUTION***
+Since this function is very dangerous, ((*NEVER*))
+* lock any HANDLEs(i.e. Mutex, Semaphore, CriticalSection and so on) or,
+* use anything like TRAP_BEG...TRAP_END block structure,
+in asynchronous_func_t.
+*/
+typedef DWORD (*asynchronous_func_t)(DWORD self, int argc, DWORD* argv);
+DWORD rb_w32_asynchronize(asynchronous_func_t func, DWORD self, int argc, DWORD* argv, DWORD intrval);
+
+#endif
diff --git a/ruby_1_8_6/win32/winmain.c b/ruby_1_8_6/win32/winmain.c
new file mode 100644
index 0000000000..4902d1daaf
--- /dev/null
+++ b/ruby_1_8_6/win32/winmain.c
@@ -0,0 +1,10 @@
+#include <windows.h>
+#include <stdio.h>
+
+extern int main(int, char**, char**);
+
+int WINAPI
+WinMain(HINSTANCE current, HINSTANCE prev, LPSTR cmdline, int showcmd)
+{
+ return main(0, NULL, NULL);
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 18:11:00 +0000