Initial revisionv1_0_r2

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@2 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

19 files changed, 4791 insertions, 0 deletions

diff --git a/missing/alloca.c b/missing/alloca.c
new file mode 100644
index 0000000000..6879618c8a
--- /dev/null
+++ b/missing/alloca.c
@@ -0,0 +1,189 @@
+/* alloca -- (mostly) portable public-domain implementation -- D A Gwyn
+
+   last edit:	86/05/30	rms
+   include config.h, since on VMS it renames some symbols.
+   Use xmalloc instead of malloc.
+
+   This implementation of the PWB library alloca() function,
+   which is used to allocate space off the run-time stack so
+   that it is automatically reclaimed upon procedure exit, 
+   was inspired by discussions with J. Q. Johnson of Cornell.
+
+   It should work under any C implementation that uses an
+   actual procedure stack (as opposed to a linked list of
+   frames).  There are some preprocessor constants that can
+   be defined when compiling for your specific system, for
+   improved efficiency; however, the defaults should be okay.
+
+   The general concept of this implementation is to keep
+   track of all alloca()-allocated blocks, and reclaim any
+   that are found to be deeper in the stack than the current
+   invocation.  This heuristic does not reclaim storage as
+   soon as it becomes invalid, but it will do so eventually.
+
+   As a special case, alloca(0) reclaims storage without
+   allocating any.  It is a good idea to use alloca(0) in
+   your main control loop, etc. to force garbage collection.
+*/
+#ifndef lint
+static char	SCCSid[] = "@(#)alloca.c	1.1";	/* for the "what" utility */
+#endif
+
+#include "config.h"
+#ifdef emacs
+#ifdef static
+/* actually, only want this if static is defined as ""
+   -- this is for usg, in which emacs must undefine static
+   in order to make unexec workable
+   */
+#ifndef STACK_DIRECTION
+you
+lose
+-- must know STACK_DIRECTION at compile-time
+#endif /* STACK_DIRECTION undefined */
+#endif /* static */
+#endif /* emacs */
+
+#ifdef X3J11
+typedef void	*pointer;		/* generic pointer type */
+#else
+typedef char	*pointer;		/* generic pointer type */
+#endif /* X3J11 */
+
+#define	NULL	0			/* null pointer constant */
+
+extern void	free();
+extern pointer	xmalloc();
+
+/*
+	Define STACK_DIRECTION if you know the direction of stack
+	growth for your system; otherwise it will be automatically
+	deduced at run-time.
+
+	STACK_DIRECTION > 0 => grows toward higher addresses
+	STACK_DIRECTION < 0 => grows toward lower addresses
+	STACK_DIRECTION = 0 => direction of growth unknown
+*/
+
+#ifndef STACK_DIRECTION
+#define	STACK_DIRECTION	0		/* direction unknown */
+#endif
+
+#if STACK_DIRECTION != 0
+
+#define	STACK_DIR	STACK_DIRECTION	/* known at compile-time */
+
+#else	/* STACK_DIRECTION == 0; need run-time code */
+
+static int	stack_dir;		/* 1 or -1 once known */
+#define	STACK_DIR	stack_dir
+
+static void
+find_stack_direction (/* void */)
+{
+  static char	*addr = NULL;	/* address of first
+				   `dummy', once known */
+  auto char	dummy;		/* to get stack address */
+
+  if (addr == NULL)
+    {				/* initial entry */
+      addr = &dummy;
+
+      find_stack_direction ();	/* recurse once */
+    }
+  else				/* second entry */
+    if (&dummy > addr)
+      stack_dir = 1;		/* stack grew upward */
+    else
+      stack_dir = -1;		/* stack grew downward */
+}
+
+#endif	/* STACK_DIRECTION == 0 */
+
+/*
+	An "alloca header" is used to:
+	(a) chain together all alloca()ed blocks;
+	(b) keep track of stack depth.
+
+	It is very important that sizeof(header) agree with malloc()
+	alignment chunk size.  The following default should work okay.
+*/
+
+#ifndef	ALIGN_SIZE
+#define	ALIGN_SIZE	sizeof(double)
+#endif
+
+typedef union hdr
+{
+  char	align[ALIGN_SIZE];	/* to force sizeof(header) */
+  struct
+    {
+      union hdr *next;		/* for chaining headers */
+      char *deep;		/* for stack depth measure */
+    } h;
+} header;
+
+/*
+	alloca( size ) returns a pointer to at least `size' bytes of
+	storage which will be automatically reclaimed upon exit from
+	the procedure that called alloca().  Originally, this space
+	was supposed to be taken from the current stack frame of the
+	caller, but that method cannot be made to work for some
+	implementations of C, for example under Gould's UTX/32.
+*/
+
+static header *last_alloca_header = NULL; /* -> last alloca header */
+
+pointer
+alloca (size)			/* returns pointer to storage */
+     unsigned	size;		/* # bytes to allocate */
+{
+  auto char	probe;		/* probes stack depth: */
+  register char	*depth = &probe;
+
+#if STACK_DIRECTION == 0
+  if (STACK_DIR == 0)		/* unknown growth direction */
+    find_stack_direction ();
+#endif
+
+  /* Reclaim garbage, defined as all alloca()ed storage that
+     was allocated from deeper in the stack than currently. */
+  {
+    register header	*hp;	/* traverses linked list */
+
+    for (hp = last_alloca_header; hp != NULL;)
+      if (STACK_DIR > 0 && hp->h.deep > depth
+	  || STACK_DIR < 0 && hp->h.deep < depth)
+	{
+	  register header	*np = hp->h.next;
+
+	  free ((pointer) hp);	/* collect garbage */
+
+	  hp = np;		/* -> next header */
+	}
+      else
+	break;			/* rest are not deeper */
+
+    last_alloca_header = hp;	/* -> last valid storage */
+  }
+
+  if (size == 0)
+    return NULL;		/* no allocation required */
+
+  /* Allocate combined header + user data storage. */
+
+  {
+    register pointer	new = xmalloc (sizeof (header) + size);
+    /* address of header */
+
+    ((header *)new)->h.next = last_alloca_header;
+    ((header *)new)->h.deep = depth;
+
+    last_alloca_header = (header *)new;
+
+    /* User storage begins just after header. */
+
+    return (pointer)((char *)new + sizeof(header));
+  }
+}
+
diff --git a/missing/crypt.c b/missing/crypt.c
new file mode 100644
index 0000000000..9f9b562c36
--- /dev/null
+++ b/missing/crypt.c
@@ -0,0 +1,276 @@
+/*      From Andy Tanenbaum's book "Computer Networks",
+        rewritten in C
+*/
+
+struct block {
+        unsigned char b_data[64];
+};
+
+struct ordering {
+        unsigned char o_data[64];
+};
+
+static struct block key;
+
+static struct ordering InitialTr = {
+        58,50,42,34,26,18,10, 2,60,52,44,36,28,20,12, 4,
+        62,54,46,38,30,22,14, 6,64,56,48,40,32,24,16, 8,
+        57,49,41,33,25,17, 9, 1,59,51,43,35,27,19,11, 3,
+        61,53,45,37,29,21,13, 5,63,55,47,39,31,23,15, 7,
+};
+
+static struct ordering FinalTr = {
+        40, 8,48,16,56,24,64,32,39, 7,47,15,55,23,63,31,
+        38, 6,46,14,54,22,62,30,37, 5,45,13,53,21,61,29,
+        36, 4,44,12,52,20,60,28,35, 3,43,11,51,19,59,27,
+        34, 2,42,10,50,18,58,26,33, 1,41, 9,49,17,57,25,
+};
+
+static struct ordering swap = {
+        33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,
+        49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,
+         1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,
+        17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,
+};
+
+static struct ordering KeyTr1 = {
+        57,49,41,33,25,17, 9, 1,58,50,42,34,26,18,
+        10, 2,59,51,43,35,27,19,11, 3,60,52,44,36,
+        63,55,47,39,31,23,15, 7,62,54,46,38,30,22,
+        14, 6,61,53,45,37,29,21,13, 5,28,20,12, 4,
+};
+
+static struct ordering KeyTr2 = {
+        14,17,11,24, 1, 5, 3,28,15, 6,21,10,
+        23,19,12, 4,26, 8,16, 7,27,20,13, 2,
+        41,52,31,37,47,55,30,40,51,45,33,48,
+        44,49,39,56,34,53,46,42,50,36,29,32,
+};
+
+static struct ordering etr = {
+        32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9,
+         8, 9,10,11,12,13,12,13,14,15,16,17,
+        16,17,18,19,20,21,20,21,22,23,24,25,
+        24,25,26,27,28,29,28,29,30,31,32, 1,
+};
+
+static struct ordering ptr = {
+        16, 7,20,21,29,12,28,17, 1,15,23,26, 5,18,31,10,
+         2, 8,24,14,32,27, 3, 9,19,13,30, 6,22,11, 4,25,
+};
+
+static unsigned char s_boxes[8][64] = {
+{       14, 4,13, 1, 2,15,11, 8, 3,10, 6,12, 5, 9, 0, 7,
+         0,15, 7, 4,14, 2,13, 1,10, 6,12,11, 9, 5, 3, 8,
+         4, 1,14, 8,13, 6, 2,11,15,12, 9, 7, 3,10, 5, 0,
+        15,12, 8, 2, 4, 9, 1, 7, 5,11, 3,14,10, 0, 6,13,
+},
+
+{       15, 1, 8,14, 6,11, 3, 4, 9, 7, 2,13,12, 0, 5,10,
+         3,13, 4, 7,15, 2, 8,14,12, 0, 1,10, 6, 9,11, 5,
+         0,14, 7,11,10, 4,13, 1, 5, 8,12, 6, 9, 3, 2,15,
+        13, 8,10, 1, 3,15, 4, 2,11, 6, 7,12, 0, 5,14, 9,
+},
+
+{       10, 0, 9,14, 6, 3,15, 5, 1,13,12, 7,11, 4, 2, 8,
+        13, 7, 0, 9, 3, 4, 6,10, 2, 8, 5,14,12,11,15, 1,
+        13, 6, 4, 9, 8,15, 3, 0,11, 1, 2,12, 5,10,14, 7,
+         1,10,13, 0, 6, 9, 8, 7, 4,15,14, 3,11, 5, 2,12,
+},
+
+{        7,13,14, 3, 0, 6, 9,10, 1, 2, 8, 5,11,12, 4,15,
+        13, 8,11, 5, 6,15, 0, 3, 4, 7, 2,12, 1,10,14, 9,
+        10, 6, 9, 0,12,11, 7,13,15, 1, 3,14, 5, 2, 8, 4,
+         3,15, 0, 6,10, 1,13, 8, 9, 4, 5,11,12, 7, 2,14,
+},
+
+{        2,12, 4, 1, 7,10,11, 6, 8, 5, 3,15,13, 0,14, 9,
+        14,11, 2,12, 4, 7,13, 1, 5, 0,15,10, 3, 9, 8, 6,
+         4, 2, 1,11,10,13, 7, 8,15, 9,12, 5, 6, 3, 0,14,
+        11, 8,12, 7, 1,14, 2,13, 6,15, 0, 9,10, 4, 5, 3,
+},
+
+{       12, 1,10,15, 9, 2, 6, 8, 0,13, 3, 4,14, 7, 5,11,
+        10,15, 4, 2, 7,12, 9, 5, 6, 1,13,14, 0,11, 3, 8,
+         9,14,15, 5, 2, 8,12, 3, 7, 0, 4,10, 1,13,11, 6,
+         4, 3, 2,12, 9, 5,15,10,11,14, 1, 7, 6, 0, 8,13,
+},
+
+{        4,11, 2,14,15, 0, 8,13, 3,12, 9, 7, 5,10, 6, 1,
+        13, 0,11, 7, 4, 9, 1,10,14, 3, 5,12, 2,15, 8, 6,
+         1, 4,11,13,12, 3, 7,14,10,15, 6, 8, 0, 5, 9, 2,
+         6,11,13, 8, 1, 4,10, 7, 9, 5, 0,15,14, 2, 3,12,
+},
+
+{       13, 2, 8, 4, 6,15,11, 1,10, 9, 3,14, 5, 0,12, 7,
+         1,15,13, 8,10, 3, 7, 4,12, 5, 6,11, 0,14, 9, 2,
+         7,11, 4, 1, 9,12,14, 2, 0, 6,10,13,15, 3, 5, 8,
+         2, 1,14, 7, 4,10, 8,13,15,12, 9, 0, 3, 5, 6,11,
+},
+};
+
+static int rots[] = {
+        1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1,
+};
+
+static void transpose(struct block *data, struct ordering *t, int n)
+{
+        struct block x;
+
+        x = *data;
+
+        while (n-- > 0) {
+                data->b_data[n] = x.b_data[t->o_data[n] - 1];
+        }
+}
+
+static void rotate(struct block *key)
+{
+        register unsigned char *p = key->b_data;
+        register unsigned char *ep = &(key->b_data[55]);
+        int data0 = key->b_data[0], data28 = key->b_data[28];
+
+        while (p++ < ep) *(p-1) = *p;
+        key->b_data[27] = (char) data0;
+        key->b_data[55] = (char) data28;
+}
+
+static struct ordering *EP = &etr;
+
+static void f(int i, struct block *key, struct block *a, struct block *x)
+{
+        struct block e, ikey, y;
+        int k;
+        register unsigned char *p, *q, *r;
+
+        e = *a;
+        transpose(&e, EP, 48);
+        for (k = rots[i]; k; k--) rotate(key);
+        ikey = *key;
+        transpose(&ikey, &KeyTr2, 48);
+        p = &(y.b_data[48]);
+        q = &(e.b_data[48]);
+        r = &(ikey.b_data[48]);
+        while (p > y.b_data) {
+                *--p = *--q ^ *--r;
+        }
+        q = x->b_data;
+        for (k = 0; k < 8; k++) {
+                register int xb, r;
+
+                r = *p++ << 5;
+                r += *p++ << 3;
+                r += *p++ << 2;
+                r += *p++ << 1;
+                r += *p++;
+                r += *p++ << 4;
+
+                xb = s_boxes[k][r];
+
+                *q++ = (char) (xb >> 3) & 1;
+                *q++ = (char) (xb>>2) & 1;
+                *q++ = (char) (xb>>1) & 1;
+                *q++ = (char) (xb & 1);
+        }
+        transpose(x, &ptr, 32);
+}
+
+void definekey(char *k)
+{
+
+        key = *((struct block *) k);
+        transpose(&key, &KeyTr1, 56);
+}
+
+void encrypt(char *blck, int edflag)
+{
+        register struct block *p = (struct block *) blck;
+        register int i;
+
+        transpose(p, &InitialTr, 64);
+        for (i = 15; i>= 0; i--) {
+                int j = edflag ? i : 15 - i;
+                register int k;
+                struct block b, x;
+
+                b = *p;
+                for (k = 31; k >= 0; k--) {
+                        p->b_data[k] = b.b_data[k + 32];
+                }
+                f(j, &key, p, &x);
+                for (k = 31; k >= 0; k--) {
+                        p->b_data[k+32] = b.b_data[k] ^ x.b_data[k];
+                }
+        }
+        transpose(p, &swap, 64);
+        transpose(p, &FinalTr, 64);
+}
+
+char *crypt(char *pw, char *salt)
+{
+
+        char pwb[66];
+        static char result[16];
+        register char *p = pwb;
+        struct ordering new_etr;
+        register int i;
+
+        while (*pw && p < &pwb[64]) {
+                register int j = 7;
+
+                while (j--) {
+                        *p++ = (*pw >> j) & 01;
+                }
+                pw++;
+                *p++ = 0;
+        }
+        while (p < &pwb[64]) *p++ = 0;
+
+        definekey(p = pwb);
+
+        while (p < &pwb[66]) *p++ = 0;
+
+        new_etr = etr;
+        EP = &new_etr;
+        for (i = 0; i < 2; i++) {
+                register char c = *salt++;
+                register int j;
+
+                result[i] = c;
+                if ( c > 'Z') c -= 6 + 7 + '.'; /* c was a lower case letter */
+                else if ( c > '9') c -= 7 + '.';/* c was upper case letter */
+                else c -= '.';                  /* c was digit, '.' or '/'. */
+                                                /* now, 0 <= c <= 63 */
+                for (j = 0; j < 6; j++) {
+                        if ((c >> j) & 01) {
+                                int t = 6*i + j;
+                                int temp = new_etr.o_data[t];
+                                new_etr.o_data[t] = new_etr.o_data[t+24];
+                                new_etr.o_data[t+24] = (char) temp;
+                        }
+                }
+        }
+
+        if (result[1] == 0) result[1] = result[0];
+
+        for (i = 0; i < 25; i++) encrypt(pwb,0);
+        EP = &etr;
+
+        p = pwb;
+        pw = result+2;
+        while (p < &pwb[66]) {
+                register int c = 0;
+                register int j = 6;
+
+                while (j--) {
+                        c <<= 1;
+                        c |= *p++;
+                }
+                c += '.';               /* becomes >= '.' */
+                if (c > '9') c += 7;    /* not in [./0-9], becomes upper */
+                if (c > 'Z') c += 6;    /* not in [A-Z], becomes lower */
+                *pw++ = (char) c;
+        }
+        *pw = 0;
+        return result;
+}
diff --git a/missing/dir.h b/missing/dir.h
new file mode 100644
index 0000000000..5c6281fdc2
--- /dev/null
+++ b/missing/dir.h
@@ -0,0 +1,248 @@
+/* $RCSfile: dir.h,v $$Revision: 4.0.1.1 $$Date: 91/06/07 11:22:10 $
+ *
+ *    (C) Copyright 1987, 1990 Diomidis Spinellis.
+ *
+ *    You may distribute under the terms of either the GNU General Public
+ *    License or the Artistic License, as specified in the README file.
+ *
+ * $Log:	dir.h,v $
+ * Revision 4.0.1.1  91/06/07  11:22:10  lwall
+ * patch4: new copyright notice
+ * 
+ * Revision 4.0  91/03/20  01:34:20  lwall
+ * 4.0 baseline.
+ * 
+ * Revision 3.0.1.1  90/03/27  16:07:08  lwall
+ * patch16: MSDOS support
+ * 
+ * Revision 1.1  90/03/18  20:32:29  dds
+ * Initial revision
+ *
+ *
+ */
+
+/*
+ * defines the type returned by the directory(3) functions
+ */
+
+#ifndef __DIR_INCLUDED
+#define __DIR_INCLUDED
+
+/*Directory entry size */
+#ifdef DIRSIZ
+#undef DIRSIZ
+#endif
+#define DIRSIZ(rp)	(sizeof(struct direct))
+
+/*
+ * Structure of a directory entry
+ */
+struct direct	{
+	ino_t	d_ino;			/* inode number (not used by MS-DOS) */
+	int	d_namlen;		/* Name length */
+	char	d_name[256];		/* file name */
+};
+
+struct _dir_struc {			/* Structure used by dir operations */
+	char *start;			/* Starting position */
+	char *curr;			/* Current position */
+	long size;                      /* Size of string table */
+	long nfiles;                    /* number if filenames in table */
+	struct direct dirstr;		/* Directory structure to return */
+};
+
+typedef struct _dir_struc DIR;		/* Type returned by dir operations */
+
+DIR *cdecl opendir(char *filename);
+struct direct *readdir(DIR *dirp);
+long telldir(DIR *dirp);
+void seekdir(DIR *dirp,long loc);
+void rewinddir(DIR *dirp);
+void closedir(DIR *dirp);
+
+#endif /* __DIR_INCLUDED */
+/* $RCSfile: dir.h,v $$Revision: 4.0.1.1 $$Date: 91/06/07 11:22:10 $
+ *
+ *    (C) Copyright 1987, 1990 Diomidis Spinellis.
+ *
+ *    You may distribute under the terms of either the GNU General Public
+ *    License or the Artistic License, as specified in the README file.
+ *
+ * $Log:	dir.h,v $
+ * Revision 4.0.1.1  91/06/07  11:22:10  lwall
+ * patch4: new copyright notice
+ * 
+ * Revision 4.0  91/03/20  01:34:20  lwall
+ * 4.0 baseline.
+ * 
+ * Revision 3.0.1.1  90/03/27  16:07:08  lwall
+ * patch16: MSDOS support
+ * 
+ * Revision 1.1  90/03/18  20:32:29  dds
+ * Initial revision
+ *
+ *
+ */
+
+/*
+ * defines the type returned by the directory(3) functions
+ */
+
+#ifndef __DIR_INCLUDED
+#define __DIR_INCLUDED
+
+/*Directory entry size */
+#ifdef DIRSIZ
+#undef DIRSIZ
+#endif
+#define DIRSIZ(rp)	(sizeof(struct direct))
+
+/*
+ * Structure of a directory entry
+ */
+struct direct	{
+	ino_t	d_ino;			/* inode number (not used by MS-DOS) */
+	int	d_namlen;		/* Name length */
+	char	d_name[256];		/* file name */
+};
+
+struct _dir_struc {			/* Structure used by dir operations */
+	char *start;			/* Starting position */
+	char *curr;			/* Current position */
+	struct direct dirstr;		/* Directory structure to return */
+};
+
+typedef struct _dir_struc DIR;		/* Type returned by dir operations */
+
+DIR *cdecl opendir(char *filename);
+struct direct *readdir(DIR *dirp);
+long telldir(DIR *dirp);
+void seekdir(DIR *dirp,long loc);
+void rewinddir(DIR *dirp);
+void closedir(DIR *dirp);
+
+#endif /* __DIR_INCLUDED */
+/* $RCSfile: dir.h,v $$Revision: 4.0.1.1 $$Date: 91/06/07 11:22:10 $
+ *
+ *    (C) Copyright 1987, 1990 Diomidis Spinellis.
+ *
+ *    You may distribute under the terms of either the GNU General Public
+ *    License or the Artistic License, as specified in the README file.
+ *
+ * $Log:	dir.h,v $
+ * Revision 4.0.1.1  91/06/07  11:22:10  lwall
+ * patch4: new copyright notice
+ * 
+ * Revision 4.0  91/03/20  01:34:20  lwall
+ * 4.0 baseline.
+ * 
+ * Revision 3.0.1.1  90/03/27  16:07:08  lwall
+ * patch16: MSDOS support
+ * 
+ * Revision 1.1  90/03/18  20:32:29  dds
+ * Initial revision
+ *
+ *
+ */
+
+/*
+ * defines the type returned by the directory(3) functions
+ */
+
+#ifndef __DIR_INCLUDED
+#define __DIR_INCLUDED
+
+/*Directory entry size */
+#ifdef DIRSIZ
+#undef DIRSIZ
+#endif
+#define DIRSIZ(rp)	(sizeof(struct direct))
+
+/*
+ * Structure of a directory entry
+ */
+struct direct	{
+	ino_t	d_ino;			/* inode number (not used by MS-DOS) */
+	int	d_namlen;		/* Name length */
+	char	d_name[256];		/* file name */
+};
+
+struct _dir_struc {			/* Structure used by dir operations */
+	char *start;			/* Starting position */
+	char *curr;			/* Current position */
+	struct direct dirstr;		/* Directory structure to return */
+};
+
+typedef struct _dir_struc DIR;		/* Type returned by dir operations */
+
+DIR *cdecl opendir(char *filename);
+struct direct *readdir(DIR *dirp);
+long telldir(DIR *dirp);
+void seekdir(DIR *dirp,long loc);
+void rewinddir(DIR *dirp);
+void closedir(DIR *dirp);
+
+#endif /* __DIR_INCLUDED */
+/* $RCSfile: dir.h,v $$Revision: 4.0.1.1 $$Date: 91/06/07 11:22:10 $
+ *
+ *    (C) Copyright 1987, 1990 Diomidis Spinellis.
+ *
+ *    You may distribute under the terms of either the GNU General Public
+ *    License or the Artistic License, as specified in the README file.
+ *
+ * $Log:	dir.h,v $
+ * Revision 4.0.1.1  91/06/07  11:22:10  lwall
+ * patch4: new copyright notice
+ * 
+ * Revision 4.0  91/03/20  01:34:20  lwall
+ * 4.0 baseline.
+ * 
+ * Revision 3.0.1.1  90/03/27  16:07:08  lwall
+ * patch16: MSDOS support
+ * 
+ * Revision 1.1  90/03/18  20:32:29  dds
+ * Initial revision
+ *
+ *
+ */
+
+/*
+ * defines the type returned by the directory(3) functions
+ */
+
+#ifndef __DIR_INCLUDED
+#define __DIR_INCLUDED
+
+/*Directory entry size */
+#ifdef DIRSIZ
+#undef DIRSIZ
+#endif
+#define DIRSIZ(rp)	(sizeof(struct direct))
+
+/*
+ * Structure of a directory entry
+ */
+struct direct	{
+	ino_t	d_ino;			/* inode number (not used by MS-DOS) */
+	int	d_namlen;		/* Name length */
+	char	d_name[256];		/* file name */
+};
+
+struct _dir_struc {			/* Structure used by dir operations */
+	char *start;			/* Starting position */
+	char *curr;			/* Current position */
+	long size;                      /* Size of string table */
+	long nfiles;                    /* number if filenames in table */
+	struct direct dirstr;		/* Directory structure to return */
+};
+
+typedef struct _dir_struc DIR;		/* Type returned by dir operations */
+
+DIR *cdecl opendir(char *filename);
+struct direct *readdir(DIR *dirp);
+long telldir(DIR *dirp);
+void seekdir(DIR *dirp,long loc);
+void rewinddir(DIR *dirp);
+void closedir(DIR *dirp);
+
+#endif /* __DIR_INCLUDED */
diff --git a/missing/dup2.c b/missing/dup2.c
new file mode 100644
index 0000000000..c541149d4b
--- /dev/null
+++ b/missing/dup2.c
@@ -0,0 +1,36 @@
+/* 
+ *    Copyright (c) 1991, Larry Wall
+ *
+ *    You may distribute under the terms of either the GNU General Public
+ *    License or the Artistic License, as specified in the README file.
+ */
+
+#include "defines.h"
+
+#if defined(HAVE_FCNTL) && defined(F_DUPFD)
+# include <fcntl.h>
+#endif
+
+int
+dup2(oldfd,newfd)
+int oldfd;
+int newfd;
+{
+#if defined(HAVE_FCNTL) && defined(F_DUPFD)
+    close(newfd);
+    return fcntl(oldfd, F_DUPFD, newfd);
+#else
+    int fdtmp[256];
+    int fdx = 0;
+    int fd;
+
+    if (oldfd == newfd)
+	return 0;
+    close(newfd);
+    while ((fd = dup(oldfd)) != newfd)	/* good enough for low fd's */
+	fdtmp[fdx++] = fd;
+    while (fdx > 0)
+	close(fdtmp[--fdx]);
+    return 0;
+#endif
+}
diff --git a/missing/file.h b/missing/file.h
new file mode 100644
index 0000000000..0207dddb3a
--- /dev/null
+++ b/missing/file.h
@@ -0,0 +1,32 @@
+/* This is file FILE.H */
+/*
+** Copyright (C) 1991 DJ Delorie, 24 Kirsten Ave, Rochester NH 03867-2954
+**
+** This file is distributed under the terms listed in the document
+** "copying.dj", available from DJ Delorie at the address above.
+** A copy of "copying.dj" should accompany this file; if not, a copy
+** should be available from where this file was obtained.  This file
+** may not be distributed without a verbatim copy of "copying.dj".
+**
+** This file is distributed WITHOUT ANY WARRANTY; without even the implied
+** warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+*/
+
+#ifndef _FILE_H_
+#define _FILE_H_
+
+#include <fcntl.h>
+
+#define L_SET  0
+#define L_CURR 1
+#define L_INCR 1
+#define L_XTND 2
+
+
+#define	F_OK		0	/* does file exist */
+
+#define	X_OK		1	/* is it executable by caller */
+#define	W_OK		2	/* is it writable by caller */
+#define	R_OK		4	/* is it readable by caller */
+
+#endif
diff --git a/missing/flock.c b/missing/flock.c
new file mode 100644
index 0000000000..a4a9544b56
--- /dev/null
+++ b/missing/flock.c
@@ -0,0 +1,90 @@
+#include "config.h"
+
+#if defined(HAVE_LOCKF)
+
+#include <unistd.h>
+#include <errno.h>
+
+/*  Emulate flock() with lockf() or fcntl().  This is just to increase
+    portability of scripts.  The calls might not be completely
+    interchangeable.  What's really needed is a good file
+    locking module.
+*/
+
+# ifndef F_ULOCK
+#  define F_ULOCK	0	/* Unlock a previously locked region */
+# endif
+# ifndef F_LOCK
+#  define F_LOCK	1	/* Lock a region for exclusive use */
+# endif
+# ifndef F_TLOCK
+#  define F_TLOCK	2	/* Test and lock a region for exclusive use */
+# endif
+# ifndef F_TEST
+#  define F_TEST	3	/* Test a region for other processes locks */
+# endif
+
+/* These are the flock() constants.  Since this sytems doesn't have
+   flock(), the values of the constants are probably not available.
+*/
+# ifndef LOCK_SH
+#  define LOCK_SH 1
+# endif
+# ifndef LOCK_EX
+#  define LOCK_EX 2
+# endif
+# ifndef LOCK_NB
+#  define LOCK_NB 4
+# endif
+# ifndef LOCK_UN
+#  define LOCK_UN 8
+# endif
+
+int
+flock(fd, operation)
+    int fd;
+    int operation;
+{
+    int i;
+    switch (operation) {
+
+	/* LOCK_SH - get a shared lock */
+      case LOCK_SH:
+	/* LOCK_EX - get an exclusive lock */
+      case LOCK_EX:
+	i = lockf (fd, F_LOCK, 0);
+	break;
+
+	/* LOCK_SH|LOCK_NB - get a non-blocking shared lock */
+      case LOCK_SH|LOCK_NB:
+	/* LOCK_EX|LOCK_NB - get a non-blocking exclusive lock */
+      case LOCK_EX|LOCK_NB:
+	i = lockf (fd, F_TLOCK, 0);
+	if (i == -1)
+	    if ((errno == EAGAIN) || (errno == EACCES))
+		errno = EWOULDBLOCK;
+	break;
+
+	/* LOCK_UN - unlock */
+      case LOCK_UN:
+	i = lockf (fd, F_ULOCK, 0);
+	break;
+
+	/* Default - can't decipher operation */
+      default:
+	i = -1;
+	errno = EINVAL;
+	break;
+    }
+    return i;
+}
+#else
+int
+flock(fd, operation)
+    int fd;
+    int operation;
+{
+    rb_notimplement();
+    return -1;
+}
+#endif
diff --git a/missing/memmove.c b/missing/memmove.c
new file mode 100644
index 0000000000..09e64702b6
--- /dev/null
+++ b/missing/memmove.c
@@ -0,0 +1,24 @@
+/*
+ * memmove --- move memories.
+ *
+ * We supply this routine for those systems that aren't standard yet.
+ */
+
+char *
+memmove (dst, src, n)
+     char *dst, *src;
+     int n;
+{
+  char *ret = dst;
+
+  if (src < dst) {
+    src += n;
+    dst += n;
+    while (n--)
+      *--dst = *--src;
+  }
+  else if (dst < src)
+    while (n--)
+      *dst++ = *src++;
+  return ret;
+}
diff --git a/missing/mkdir.c b/missing/mkdir.c
new file mode 100644
index 0000000000..ed1476db9a
--- /dev/null
+++ b/missing/mkdir.c
@@ -0,0 +1,104 @@
+/*
+ * Written by Robert Rother, Mariah Corporation, August 1985.
+ *
+ * If you want it, it's yours.  All I ask in return is that if you
+ * figure out how to do this in a Bourne Shell script you send me
+ * a copy.
+ *					sdcsvax!rmr or rmr@uscd
+ *
+ * Severely hacked over by John Gilmore to make a 4.2BSD compatible
+ * subroutine.	11Mar86; hoptoad!gnu
+ *
+ * Modified by rmtodd@uokmax 6-28-87 -- when making an already existing dir,
+ * subroutine didn't return EEXIST.  It does now.
+ */
+
+#include <sys/stat.h>
+#include <errno.h>
+/*
+ * Make a directory.
+ */
+int
+mkdir (dpath, dmode)
+     char *dpath;
+     int dmode;
+{
+  int cpid, status;
+  struct stat statbuf;
+
+  if (stat (dpath, &statbuf) == 0)
+    {
+      errno = EEXIST;		/* Stat worked, so it already exists */
+      return -1;
+    }
+
+  /* If stat fails for a reason other than non-existence, return error */
+  if (errno != ENOENT)
+    return -1;
+
+  switch (cpid = fork ())
+    {
+
+    case -1:			/* Error in fork() */
+      return (-1);		/* Errno is set already */
+
+    case 0:			/* Child process */
+      /*
+		 * Cheap hack to set mode of new directory.  Since this
+		 * child process is going away anyway, we zap its umask.
+		 * FIXME, this won't suffice to set SUID, SGID, etc. on this
+		 * directory.  Does anybody care?
+		 */
+      status = umask (0);	/* Get current umask */
+      status = umask (status | (0777 & ~dmode));	/* Set for mkdir */
+      execl ("/bin/mkdir", "mkdir", dpath, (char *) 0);
+      _exit (-1);		/* Can't exec /bin/mkdir */
+
+    default:			/* Parent process */
+      while (cpid != wait (&status));	/* Wait for kid to finish */
+    }
+
+  if (WIFSIGNALED (status) || WEXITSTATUS (status) != 0)
+    {
+      errno = EIO;		/* We don't know why, but */
+      return -1;		/* /bin/mkdir failed */
+    }
+
+  return 0;
+}
+
+int
+rmdir (dpath)
+     char *dpath;
+{
+  int cpid, status;
+  struct stat statbuf;
+
+  if (stat (dpath, &statbuf) != 0)
+    {
+      /* Stat just set errno.  We don't have to */
+      return -1;
+    }
+
+  switch (cpid = fork ())
+    {
+
+    case -1:			/* Error in fork() */
+      return (-1);		/* Errno is set already */
+
+    case 0:			/* Child process */
+      execl ("/bin/rmdir", "rmdir", dpath, (char *) 0);
+      _exit (-1);		/* Can't exec /bin/mkdir */
+
+    default:			/* Parent process */
+      while (cpid != wait (&status));	/* Wait for kid to finish */
+    }
+
+  if (WIFSIGNALED (status) || WEXITSTATUS (status) != 0)
+    {
+      errno = EIO;		/* We don't know why, but */
+      return -1;		/* /bin/rmdir failed */
+    }
+
+  return 0;
+}
diff --git a/missing/nt.c b/missing/nt.c
new file mode 100644
index 0000000000..1cd81fd28c
--- /dev/null
+++ b/missing/nt.c
@@ -0,0 +1,2191 @@
+/*
+ *  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 <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 "nt.h"
+#include "dir.h"
+#ifndef index
+#define index(x, y) strchr((x), (y))
+#endif
+
+#ifndef bool
+#define bool int
+#endif
+
+bool NtSyncProcess = TRUE;
+#if 0  // declared in header file
+extern char **environ;
+#define environ _environ
+#endif
+
+static bool NtHasRedirection (char *);
+static int valid_filename(char *s);
+static void StartSockets ();
+static char *str_grow(struct RString *str, size_t new_size);
+
+char *NTLoginName;
+
+DWORD Win32System = (DWORD)-1;
+
+static DWORD
+IdOS(void)
+{
+    static OSVERSIONINFO osver;
+
+    if (osver.dwPlatformId != Win32System) {
+	memset(&osver, 0, sizeof(OSVERSIONINFO));
+	osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+	GetVersionEx(&osver);
+	Win32System = osver.dwPlatformId;
+    }
+    return (Win32System);
+}
+
+static int 
+IsWin95(void) {
+    return (IdOS() == VER_PLATFORM_WIN32_WINDOWS);
+}
+
+static int
+IsWinNT(void) {
+    return (IdOS() == VER_PLATFORM_WIN32_NT);
+}
+
+
+/* simulate flock by locking a range on the file */
+
+
+#define LK_ERR(f,i) ((f) ? (i = 0) : (errno = GetLastError()))
+#define LK_LEN      0xffff0000
+
+int
+flock(int fd, int oper)
+{
+    OVERLAPPED o;
+    int i = -1;
+    HANDLE fh;
+
+    fh = (HANDLE)_get_osfhandle(fd);
+    memset(&o, 0, sizeof(o));
+
+    if(IsWinNT()) {
+        switch(oper) {
+        case LOCK_SH:       /* shared lock */
+            LK_ERR(LockFileEx(fh, 0, 0, LK_LEN, 0, &o),i);
+            break;
+        case LOCK_EX:       /* exclusive lock */
+            LK_ERR(LockFileEx(fh, LOCKFILE_EXCLUSIVE_LOCK, 0, LK_LEN, 0, &o),i);
+            break;
+        case LOCK_SH|LOCK_NB:   /* non-blocking shared lock */
+            LK_ERR(LockFileEx(fh, LOCKFILE_FAIL_IMMEDIATELY, 0, LK_LEN, 0, &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, 0, &o),i);
+	    if(errno == EDOM) errno = EWOULDBLOCK;
+            break;
+        case LOCK_UN:       /* unlock lock */
+	    if (UnlockFileEx(fh, 0, LK_LEN, 0, &o)) {
+		i = 0;
+	    }
+	    else {
+		/* GetLastError() must returns `ERROR_NOT_LOCKED' */
+		errno = EWOULDBLOCK;
+	    }
+	    if(errno == EDOM) errno = EWOULDBLOCK;
+            break;
+        default:            /* unknown */
+            errno = EINVAL;
+            break;
+        }
+    }
+    else if(IsWin95()) {
+        switch(oper) {
+        case LOCK_EX:
+	    while(i == -1) {
+	        LK_ERR(LockFile(fh, 0, 0, LK_LEN, 0), i);
+		if(errno != EDOM && i == -1) break;
+	    }
+	    break;
+	case LOCK_EX | LOCK_NB:
+	    LK_ERR(LockFile(fh, 0, 0, LK_LEN, 0), i);
+	    if(errno == EDOM) errno = EWOULDBLOCK;
+            break;
+        case LOCK_UN:
+            LK_ERR(UnlockFile(fh, 0, 0, LK_LEN, 0), i);
+	    if(errno == EDOM) errno = EWOULDBLOCK;
+            break;
+        default:
+            errno = EINVAL;
+            break;
+        }
+    }
+    return i;
+}
+
+#undef LK_ERR
+#undef LK_LEN
+
+
+#undef const
+FILE *fdopen(int, const char *);
+
+#if 0
+void
+sleep(unsigned int len)
+{
+	time_t end;
+
+	end = time((time_t *)0) + len;
+	while (time((time_t *)0) < end)
+		;
+}
+#endif
+
+//
+// Initialization stuff
+//
+void
+NtInitialize(int *argc, char ***argv) {
+
+    WORD version;
+    int ret;
+
+    //
+    // subvert cmd.exe\'s feeble attempt at command line parsing
+    //
+    *argc = NtMakeCmdVector((char *)GetCommandLine(), argv, TRUE);
+
+    //
+    // Now set up the correct time stuff
+    //
+
+    tzset();
+
+	// Initialize Winsock
+	// StartSockets();
+}
+
+
+char *getlogin()
+{
+    char buffer[200];
+    int len = 200;
+    extern char *NTLoginName;
+
+    if (NTLoginName == NULL) {
+	if (GetUserName(buffer, &len)) {
+	    NTLoginName = ALLOC_N(char, len+1);
+	    strncpy(NTLoginName, buffer, len);
+	    NTLoginName[len] = '\0';
+	}
+	else {
+	    NTLoginName = "<Unknown>";
+	}
+    }
+    return NTLoginName;
+}
+
+
+
+#if 1
+// popen stuff
+
+//
+// use these so I can remember which index is which
+//
+
+#define NtPipeRead  0	   // index of pipe read descriptor
+#define NtPipeWrite 1	   // index of pipe write descriptor
+
+#define NtPipeSize  1024   // size of pipe buffer
+
+#define MYPOPENSIZE 256	   // size of book keeping structure
+
+struct {
+    int inuse;
+    int pid;
+    HANDLE oshandle;
+    FILE *pipe;
+} MyPopenRecord[MYPOPENSIZE];
+
+int SafeFree(char **vec, int vecc)
+{
+    //   vec
+    //   |
+    //   V       ^---------------------V
+    //   +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+    //   |   |       | ....  |  NULL |   | ..... |\0 |   | ..... |\0 |...
+    //   +---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+
+    //   |-  elements+1             -| ^ 1st element   ^ 2nd element
+
+	char *p;
+
+	p = (char *)(vec - (vecc * sizeof (char *) + 1));
+	free(p);
+
+	return 0;
+}
+
+
+static char *szInternalCmds[] = {
+  "cd",
+  "chdir",
+  "cls",
+  "copy",
+  "date",
+  "del",
+  "dir",
+  "echo",
+  "erase",
+  "label",
+  "md",
+  "mkdir",
+  "path",
+  "rd",
+  "rem",
+  "ren",
+  "rename",
+  "rmdir",
+  "set",
+  "start",
+  "time",
+  "type",
+  "ver",
+  "vol",
+};
+
+int
+isInternalCmd(char *cmd)
+{
+	int fRet;
+	char **vec;
+	int vecc = NtMakeCmdVector(cmd, &vec, FALSE);
+
+	SafeFree (vec, vecc);
+
+	return 0;
+}
+
+
+FILE *
+mypopen (char *cmd, char *mode) 
+{
+    FILE *fp;
+    int saved, reading;
+    int pipemode;
+    int pipes[2];
+    int pid;
+    int slot;
+    static initialized = 0;
+
+    //
+    // if first time through, intialize our book keeping structure
+    //
+
+    if (!initialized++) {
+	for (slot = 0; slot < MYPOPENSIZE; slot++)
+	    MyPopenRecord[slot].inuse = FALSE;
+    }
+
+    //printf("mypopen %s\n", cmd);
+    
+    //
+    // find a free popen slot
+    //
+
+    for (slot = 0; slot < MYPOPENSIZE && MyPopenRecord[slot].inuse; slot++)
+	;
+
+    if (slot > MYPOPENSIZE) {
+	return NULL;
+    }
+
+    //
+    // Figure out what we\'re doing...
+    //
+
+    reading = (*mode == 'r') ? TRUE : FALSE;
+    pipemode = (*(mode+1) == 'b') ? O_BINARY : O_TEXT;
+
+    //
+    // Now get a pipe
+    //
+
+#if 0    
+    if (_pipe(pipes, NtPipeSize, pipemode) == -1) {
+	return NULL;
+    }
+
+    if (reading) {
+
+	//
+	// we\'re reading from the pipe, so we must hook up the
+	// write end of the pipe to the new processes stdout.
+	// To do this we must save our file handle from stdout
+	// by _dup\'ing it, then setting our stdout to be the pipe\'s 
+	// write descriptor. We must also make the write handle 
+	// inheritable so the new process can use it.
+
+	if ((saved = _dup(fileno(stdout))) == -1) {
+	    _close(pipes[NtPipeRead]);
+	    _close(pipes[NtPipeWrite]);
+	    return NULL;
+	}
+	if (_dup2 (pipes[NtPipeWrite], fileno(stdout)) == -1) {
+	    _close(pipes[NtPipeRead]);
+	    _close(pipes[NtPipeWrite]);
+	    return NULL;
+	}
+    }
+    else {
+	//
+	// must be writing to the new process. Do the opposite of
+	// the above, i.e. hook up the processes stdin to the read
+	// end of the pipe.
+	//
+
+	if ((saved = _dup(fileno(stdin))) == -1) {
+	    _close(pipes[NtPipeRead]);
+	    _close(pipes[NtPipeWrite]);
+	    return NULL;
+	}
+	if (_dup2(pipes[NtPipeRead], fileno(stdin)) == -1) {
+	    _close(pipes[NtPipeRead]);
+	    _close(pipes[NtPipeWrite]);
+	    return NULL;
+	}
+    }
+
+    //
+    // Start the new process. Must set _fileinfo to non-zero value
+    // for file descriptors to be inherited. Reset after the process
+    // is started.
+    //
+
+    if (NtHasRedirection(cmd)) {
+      docmd:
+	pid = spawnlpe(_P_NOWAIT, "cmd.exe", "/c", cmd, 0, environ);
+	if (pid == -1) {
+	    _close(pipes[NtPipeRead]);
+	    _close(pipes[NtPipeWrite]);
+	    return NULL;
+	}
+    }
+    else {
+	char **vec;
+	int vecc = NtMakeCmdVector(cmd, &vec, FALSE);
+
+	//pid = spawnvpe (_P_NOWAIT, vec[0], vec, environ);
+	pid = spawnvpe (_P_WAIT, vec[0], vec, environ);
+	if (pid == -1) {
+	    goto docmd;
+	}
+		Safefree (vec, vecc);
+    }
+
+    if (reading) {
+
+	//
+	// We need to close our instance of the inherited pipe write
+	// handle now that it's been inherited so that it will actually close
+	// when the child process ends.
+	//
+
+	if (_close(pipes[NtPipeWrite]) == -1) {
+	    _close(pipes[NtPipeRead]);
+	    return NULL;
+	}
+	if (_dup2 (saved, fileno(stdout)) == -1) {
+	    _close(pipes[NtPipeRead]);
+	    return NULL;
+	}
+	_close(saved);
+
+	// 
+	// Now get a stream pointer to return to the calling program.
+	//
+
+	if ((fp = (FILE *) fdopen(pipes[NtPipeRead], mode)) == NULL) {
+	    return NULL;
+	}
+    }
+    else {
+
+	//
+	// need to close our read end of the pipe so that it will go 
+	// away when the write end is closed.
+	//
+
+	if (_close(pipes[NtPipeRead]) == -1) {
+	    _close(pipes[NtPipeWrite]);
+	    return NULL;
+	}
+	if (_dup2 (saved, fileno(stdin)) == -1) {
+	    _close(pipes[NtPipeWrite]);
+	    return NULL;
+	}
+	_close(saved);
+
+	// 
+	// Now get a stream pointer to return to the calling program.
+	//
+
+	if ((fp = (FILE *) fdopen(pipes[NtPipeWrite], mode)) == NULL) {
+	    _close(pipes[NtPipeWrite]);
+	    return NULL;
+	}
+    }
+
+    //
+    // do the book keeping
+    //
+
+    MyPopenRecord[slot].inuse = TRUE;
+    MyPopenRecord[slot].pipe = fp;
+    MyPopenRecord[slot].pid = pid;
+
+    return fp;
+#else
+    {
+		int p[2];
+
+		BOOL fRet;
+		HANDLE hInFile, hOutFile, hStdin, hStdout;
+		LPCSTR lpApplicationName = NULL;
+		LPTSTR lpCommandLine;
+		LPTSTR lpCmd2 = NULL;
+		DWORD  dwCreationFlags;
+		STARTUPINFO aStartupInfo;
+		PROCESS_INFORMATION     aProcessInformation;
+		SECURITY_ATTRIBUTES sa;
+		int fd;
+
+		sa.nLength              = sizeof (SECURITY_ATTRIBUTES);
+		sa.lpSecurityDescriptor = NULL;
+		sa.bInheritHandle       = TRUE;
+
+		if (!reading) {
+        	FILE *fp;
+
+			fp = (_popen)(cmd, mode);
+
+			MyPopenRecord[slot].inuse = TRUE;
+			MyPopenRecord[slot].pipe = fp;
+			MyPopenRecord[slot].pid = -1;
+
+			if (!fp)
+			Fatal("cannot open pipe \"%s\" (%s)", cmd, strerror(errno));
+				return fp;
+		}
+
+
+		fRet = CreatePipe(&hInFile, &hOutFile, &sa, 2048L);
+		if (!fRet)
+			Fatal("cannot open pipe \"%s\" (%s)", cmd, strerror(errno));
+
+		memset(&aStartupInfo, 0, sizeof (STARTUPINFO));
+		memset(&aProcessInformation, 0, sizeof (PROCESS_INFORMATION));
+		aStartupInfo.cb = sizeof (STARTUPINFO);
+		aStartupInfo.dwFlags    = STARTF_USESTDHANDLES;
+
+		if (reading) {
+			aStartupInfo.hStdInput  = GetStdHandle(STD_OUTPUT_HANDLE);//hStdin;
+			aStartupInfo.hStdError  = INVALID_HANDLE_VALUE;
+			//for save
+			DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_OUTPUT_HANDLE),
+			  GetCurrentProcess(), &hStdout,
+			  0, FALSE, DUPLICATE_SAME_ACCESS
+			);
+			//for redirect
+			DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_INPUT_HANDLE),
+			  GetCurrentProcess(), &hStdin,
+			  0, TRUE, DUPLICATE_SAME_ACCESS
+			);
+			aStartupInfo.hStdOutput = hOutFile;
+		}
+		else {
+			aStartupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE); //hStdout;
+			aStartupInfo.hStdError  = INVALID_HANDLE_VALUE;
+			// for save
+			DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_INPUT_HANDLE),
+			  GetCurrentProcess(), &hStdin,
+			  0, FALSE, DUPLICATE_SAME_ACCESS
+			);
+			//for redirect
+			DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_OUTPUT_HANDLE),
+			  GetCurrentProcess(), &hStdout,
+			  0, TRUE, DUPLICATE_SAME_ACCESS
+			);
+			aStartupInfo.hStdInput = hInFile;
+		}
+
+		dwCreationFlags = (NORMAL_PRIORITY_CLASS);
+
+		lpCommandLine = cmd;
+		if (NtHasRedirection(cmd) || isInternalCmd(cmd)) {
+		  lpApplicationName = getenv("COMSPEC");
+		  lpCmd2 = malloc(strlen(lpApplicationName) + 1 + strlen(cmd) + sizeof (" /c "));
+		  if (lpCmd2 == NULL)
+		     Fatal("Mypopen: malloc failed");
+		  sprintf(lpCmd2, "%s %s%s", lpApplicationName, " /c ", cmd);
+		  lpCommandLine = lpCmd2;
+		}
+
+		fRet = CreateProcess(lpApplicationName, lpCommandLine, &sa, &sa,
+			sa.bInheritHandle, dwCreationFlags, NULL, NULL, &aStartupInfo, &aProcessInformation);
+
+		if (!fRet) {
+			CloseHandle(hInFile);
+			CloseHandle(hOutFile);
+			Fatal("cannot fork for \"%s\" (%s)", cmd, strerror(errno));
+		}
+
+		CloseHandle(aProcessInformation.hThread);
+
+		if (reading) {
+			HANDLE hDummy;
+
+			fd = _open_osfhandle((long)hInFile,  (_O_RDONLY | pipemode));
+			CloseHandle(hOutFile);
+			DuplicateHandle(GetCurrentProcess(), hStdout,
+			  GetCurrentProcess(), &hDummy,
+			  0, TRUE, (DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE)
+			);
+		}
+		else {
+			HANDLE hDummy;
+
+		    fd = _open_osfhandle((long)hOutFile, (_O_WRONLY | pipemode));
+			CloseHandle(hInFile);
+			DuplicateHandle(GetCurrentProcess(), hStdin,
+			  GetCurrentProcess(), &hDummy,
+			  0, TRUE, (DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE)
+			);
+		}
+
+		if (fd == -1) 
+		  Fatal("cannot open pipe \"%s\" (%s)", cmd, strerror(errno));
+
+
+		if ((fp = (FILE *) fdopen(fd, mode)) == NULL)
+			return NULL;
+
+		if (lpCmd2)
+			free(lpCmd2);
+
+		MyPopenRecord[slot].inuse = TRUE;
+		MyPopenRecord[slot].pipe  = fp;
+		MyPopenRecord[slot].oshandle = (reading ? hInFile : hOutFile);
+		MyPopenRecord[slot].pid   = (int)aProcessInformation.hProcess;
+		return fp;
+    }
+#endif
+}
+
+int
+mypclose(FILE *fp)
+{
+    int i;
+    int exitcode;
+
+    Sleep(100);
+    for (i = 0; i < MYPOPENSIZE; i++) {
+	if (MyPopenRecord[i].inuse && MyPopenRecord[i].pipe == fp)
+	    break;
+    }
+    if (i >= MYPOPENSIZE) {
+		Fatal("Invalid file pointer passed to mypclose!\n");
+    }
+
+    //
+    // get the return status of the process
+    //
+
+#if 0
+    if (_cwait(&exitcode, MyPopenRecord[i].pid, WAIT_CHILD) == -1) {
+	if (errno == ECHILD) {
+	    fprintf(stderr, "mypclose: nosuch child as pid %x\n", 
+		    MyPopenRecord[i].pid);
+	}
+    }
+#else
+	for (;;) {
+		if (GetExitCodeProcess((HANDLE)MyPopenRecord[i].pid, &exitcode)) {
+			if (exitcode == STILL_ACTIVE) {
+				//printf("Process is Active.\n");
+				Sleep(100);
+				TerminateProcess((HANDLE)MyPopenRecord[i].pid, 0); // ugly...
+				continue;
+			}
+			else if (exitcode == 0) {
+				//printf("done.\n");
+				break;
+			}
+			else {
+				//printf("never.\n");
+				break;
+			}
+		}
+	}
+#endif
+
+
+    //
+    // close the pipe
+    //
+    CloseHandle(MyPopenRecord[i].oshandle);
+    fflush(fp);
+    fclose(fp);
+
+    //
+    // free this slot
+    //
+
+    MyPopenRecord[i].inuse = FALSE;
+    MyPopenRecord[i].pipe  = NULL;
+    MyPopenRecord[i].pid   = 0;
+
+    return exitcode;
+}
+#endif
+
+#if 1
+
+
+typedef char* CHARP;
+/*
+ * The following code is based on the do_exec and do_aexec functions
+ * in file doio.c
+ */
+
+int
+do_spawn(cmd)
+char *cmd;
+{
+    register char **a;
+    register char *s;
+    char **argv;
+    int status;
+    char *shell, *cmd2;
+    int mode = NtSyncProcess ? P_WAIT : P_NOWAIT;
+
+    /* save an extra exec if possible */
+    if ((shell = getenv("RUBYSHELL")) != 0) {
+	if (NtHasRedirection(cmd)) {
+	    int  i;
+	    char *p;
+	    char *argv[4];
+	    char *cmdline = ALLOC_N(char, (strlen(cmd) * 2 + 1));
+
+	    p=cmdline;           
+	    *p++ = '"';
+	    for (s=cmd; *s;) {
+		if (*s == '"') 
+		    *p++ = '\\'; /* Escape d-quote */
+		*p++ = *s++;
+	    }
+	    *p++ = '"';
+	    *p   = '\0';
+
+	    /* fprintf(stderr, "do_spawn: %s %s\n", shell, cmdline); */
+	    argv[0] = shell;
+	    argv[1] = "-c";
+	    argv[2] = cmdline;
+	    argv[4] = NULL;
+	    status = spawnvpe(mode, argv[0], argv, environ);
+	    /* return spawnle(mode, shell, shell, "-c", cmd, (char*)0, environ); */
+	    free(cmdline);
+	    return status;
+	} 
+    }
+    else if ((shell = getenv("COMSPEC")) != 0) {
+	if (NtHasRedirection(cmd) /* || isInternalCmd(cmd) */) {
+	  do_comspec_shell:
+	    return spawnle(mode, shell, shell, "/c", cmd, (char*)0, environ);
+	}
+    }
+
+    argv = ALLOC_N(CHARP, (strlen(cmd) / 2 + 2));
+    cmd2 = ALLOC_N(char, (strlen(cmd) + 1));
+    strcpy(cmd2, cmd);
+    a = argv;
+    for (s = cmd2; *s;) {
+	while (*s && isspace(*s)) s++;
+	if (*s)
+	    *(a++) = s;
+	while (*s && !isspace(*s)) s++;
+	if (*s)
+	    *s++ = '\0';
+    }
+    *a = NULL;
+    if (argv[0]) {
+	if ((status = spawnvpe(mode, argv[0], argv, environ)) == -1) {
+	    free(argv);
+	    free(cmd2);
+	    return -1;
+	}
+    }
+    free(cmd2);
+    free(argv);
+    return status;
+}
+
+#endif
+
+typedef struct _NtCmdLineElement {
+    struct _NtCmdLineElement *next, *prev;
+    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
+
+NtCmdLineElement *NtCmdHead = NULL, *NtCmdTail = NULL;
+
+void
+NtFreeCmdLine(void)
+{
+    NtCmdLineElement *ptr;
+    
+    while(NtCmdHead) {
+	ptr = NtCmdHead;
+	NtCmdHead = NtCmdHead->next;
+	free(ptr);
+    }
+    NtCmdHead = NtCmdTail = NULL;
+}
+
+//
+// This function expands wild card characters that were spotted 
+// during the parse phase. The idea here is to call FindFirstFile and
+// FindNextFile with the wildcard pattern specified, and splice in the
+// resulting list of new names. If the wildcard pattern doesn\'t match 
+// any existing files, just leave it in the list.
+//
+
+void
+NtCmdGlob (NtCmdLineElement *patt)
+{
+    WIN32_FIND_DATA fd;
+    HANDLE fh;
+    char buffer[512];
+    NtCmdLineElement *tmphead, *tmptail, *tmpcurr;
+
+    strncpy(buffer, patt->str, patt->len);
+    buffer[patt->len] = '\0';
+    if ((fh = FindFirstFile (buffer, &fd)) == INVALID_HANDLE_VALUE) {
+	return;
+    }
+    tmphead = tmptail = NULL;
+    do {
+	tmpcurr = ALLOC(NtCmdLineElement);
+	if (tmpcurr == NULL) {
+	    fprintf(stderr, "Out of Memory in globbing!\n");
+	    while (tmphead) {
+		tmpcurr = tmphead;
+		tmphead = tmphead->next;
+		free(tmpcurr->str);
+		free(tmpcurr);
+	    }
+	    return;
+	}
+	memset (tmpcurr, 0, sizeof(*tmpcurr));
+	tmpcurr->len = strlen(fd.cFileName);
+	tmpcurr->str = ALLOC_N(char, tmpcurr->len+1);
+	if (tmpcurr->str == NULL) {
+	    fprintf(stderr, "Out of Memory in globbing!\n");
+	    while (tmphead) {
+		tmpcurr = tmphead;
+		tmphead = tmphead->next;
+		free(tmpcurr->str);
+		free(tmpcurr);
+	    }
+	    return;
+	}
+	strcpy(tmpcurr->str, fd.cFileName);
+	tmpcurr->flags |= NTMALLOC;
+	if (tmptail) {
+	    tmptail->next = tmpcurr;
+	    tmpcurr->prev = tmptail;
+	    tmptail = tmpcurr;
+	}
+	else {
+	    tmptail = tmphead = tmpcurr;
+	}
+    } while(FindNextFile(fh, &fd));
+
+    //
+    // ok, now we\'ve got a list of files that matched the wildcard
+    // specification. Put it in place of the pattern structure.
+    //
+    
+    tmphead->prev = patt->prev;
+    tmptail->next = patt->next;
+
+    if (tmphead->prev)
+	tmphead->prev->next = tmphead;
+
+    if (tmptail->next)
+	tmptail->next->prev = tmptail;
+
+    //
+    // Now get rid of the pattern structure
+    //
+
+    if (patt->flags & NTMALLOC)
+	free(patt->str);
+    // free(patt);  //TODO:  memory leak occures here. we have to fix it.
+}
+
+// 
+// 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
+NtHasRedirection (char *cmd)
+{
+    int inquote = 0;
+    char quote = '\0';
+    char *ptr ;
+    
+    //
+    // Scan the string, looking for redirection (< or >) or pipe 
+    // characters (|) that are not in a quoted string
+    //
+
+    for (ptr = cmd; *ptr; ptr++) {
+
+	switch (*ptr) {
+
+	  case '\'':
+	  case '\"':
+	    if (inquote) {
+		if (quote == *ptr) {
+		    inquote = 0;
+		    quote = '\0';
+		}
+	    }
+	    else {
+		quote = *ptr;
+		inquote++;
+	    }
+	    break;
+
+	  case '>':
+	  case '<':
+
+	    if (!inquote)
+		return TRUE;
+	}
+    }
+    return FALSE;
+}
+
+
+int 
+NtMakeCmdVector (char *cmdline, char ***vec, int InputCmd)
+{
+    int cmdlen = strlen(cmdline);
+    int done, instring, globbing, quoted, len;
+    int newline, need_free = 0, i;
+    int elements, strsz;
+    int slashes = 0;
+    char *ptr, *base, *buffer;
+    char **vptr;
+    char quote;
+    NtCmdLineElement *curr;
+
+    //
+    // just return if we don\'t have a command line
+    //
+
+    if (cmdlen == 0) {
+	*vec = NULL;
+	return 0;
+    }
+
+    //
+    // strip trailing white space
+    //
+
+    ptr = cmdline+(cmdlen - 1);
+    while(ptr >= cmdline && isspace(*ptr))
+        --ptr;
+    *++ptr = '\0';
+
+    //
+    // check for newlines and formfeeds. If we find any, make a new
+    // command string that replaces them with escaped sequences (\n or \f)
+    //
+
+    for (ptr = cmdline, newline = 0; *ptr; ptr++) {
+	if (*ptr == '\n' || *ptr == '\f')
+	    newline++;
+    }
+
+    if (newline) {
+	base = ALLOC_N(char, strlen(cmdline) + 1 + newline + slashes);
+	if (base == NULL) {
+	    fprintf(stderr, "malloc failed!\n");
+	    return 0;
+	}
+	for (i = 0, ptr = base; (unsigned) i < strlen(cmdline); i++) {
+	    switch (cmdline[i]) {
+	      case '\n':
+		*ptr++ = '\\';
+		*ptr++ = 'n';
+		break;
+	      default:
+		*ptr++ = cmdline[i];
+	    }
+	}
+	*ptr = '\0';
+	cmdline = base;
+	need_free++;
+    }
+
+    //
+    // 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.
+    //
+
+    for (done = 0, ptr = cmdline; *ptr;) {
+
+	//
+	// zap any leading whitespace
+	//
+
+	while(isspace(*ptr))
+	    ptr++;
+	base = ptr;
+
+	for (done = newline = globbing = instring = quoted = 0; 
+	     *ptr && !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 ' ':
+	      case '\t':
+#if 0
+	      case '/':  // have to do this for NT/DOS option strings
+
+		//
+		// check to see if we\'re parsing an option switch
+		//
+
+		if (*ptr == '/' && base == ptr)
+		    continue;
+#endif
+		//
+		// if we\'re not in a string, then we\'re finished with this
+		// element
+		//
+
+		if (!instring)
+		    done++;
+		break;
+
+	      case '*':
+	      case '?':
+
+		// 
+		// record the fact that this element has a wildcard character
+		// N.B. Don\'t glob if inside a single quoted string
+		//
+
+		if (!(instring && quote == '\''))
+		    globbing++;
+		break;
+
+	      case '\n':
+
+		//
+		// If this string contains a newline, mark it as such so
+		// we can replace it with the two character sequence "\n"
+		// (cmd.exe doesn\'t like raw newlines in strings...sigh).
+		//
+
+		newline++;
+		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 (instring) {
+		    if (quote == *ptr) {
+			instring = 0;
+			quote = '\0';
+		    }
+		}
+		else {
+		    instring++;
+		    quote = *ptr;
+		    quoted++;
+		}
+		break;
+	    }
+	}
+
+	//
+	// need to back up ptr by one due to last increment of for loop
+	// (if we got out by seeing white space)
+	//
+
+	if (*ptr)
+	    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.
+	//
+
+	curr = ALLOC(NtCmdLineElement);
+	if (curr == NULL) {
+	    NtFreeCmdLine();
+	    fprintf(stderr, "Out of memory!!\n");
+	    *vec = NULL;
+	    return 0;
+	}
+	memset (curr, 0, sizeof(*curr));
+
+	len = ptr - base;
+
+	//
+	// if it\'s an input vector element and it\'s enclosed by quotes, 
+	// we can remove them.
+	//
+
+	if (InputCmd &&
+	    ((base[0] == '\"' && base[len-1] == '\"') ||
+	     (base[0] == '\'' && base[len-1] == '\''))) {
+	    base++;
+	    len -= 2;
+	}
+
+	curr->str = base;
+	curr->len = len;
+	curr->flags |= (globbing ? NTGLOB : 0);
+
+	//
+	// Now put it in the list of elements
+	//
+	if (NtCmdTail) {
+	    NtCmdTail->next = curr;
+	    curr->prev = NtCmdTail;
+	    NtCmdTail = curr;
+	}
+	else {
+	    NtCmdHead = NtCmdTail = curr;
+	}
+    }
+
+    if (InputCmd) {
+
+	//
+	// When we get here we\'ve finished parsing the command line. Now 
+	// we need to run the list, expanding any globbing patterns.
+	//
+	
+	for(curr = NtCmdHead; curr; curr = curr->next) {
+	    if (curr->flags & NTGLOB) {
+		NtCmdGlob(curr);
+	    }
+	}
+    }
+
+    //
+    // 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 = NtCmdHead; curr; curr = curr->next) {
+	elements++;
+	strsz += (curr->len + 1);
+    }
+
+    len = (elements+1)*sizeof(char *) + strsz;
+    buffer = ALLOC_N(char, len);
+    if (buffer == NULL) {
+	fprintf(stderr, "Out of memory!!\n");
+	NtFreeCmdLine();
+	*vec = NULL;
+	return 0;
+    }
+    
+    memset (buffer, 0, len);
+
+    //
+    // 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 *);
+
+    for (curr =  NtCmdHead; curr;  curr = curr->next) {
+	strncpy (ptr, curr->str, curr->len);
+	ptr[curr->len] = '\0';
+	*vptr++ = ptr;
+	ptr += curr->len + 1;
+    }
+    NtFreeCmdLine();
+    *vec = (char **) buffer;
+    return elements;
+}
+
+
+#if 1
+//
+// UNIX compatible directory access functions for NT
+//
+
+//
+// File names are converted to lowercase if the
+// CONVERT_TO_LOWER_CASE variable is defined.
+//
+
+#define CONVERT_TO_LOWER_CASE
+#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. 
+//
+
+DIR *
+opendir(char *filename)
+{
+    DIR            *p;
+    long            len;
+    long            idx;
+    char            scannamespc[PATHLEN];
+    char	   *scanname = scannamespc;
+    struct stat	    sbuf;
+    WIN32_FIND_DATA FindData;
+    HANDLE          fh;
+    char            root[PATHLEN];
+    char            volname[PATHLEN];
+    DWORD           serial, maxname, flags;
+    BOOL            downcase;
+    char           *dummy;
+
+    //
+    // check to see if we\'ve got a directory
+    //
+
+    if (stat (filename, &sbuf) < 0 ||
+	sbuf.st_mode & _S_IFDIR == 0) {
+	return NULL;
+    }
+
+    //
+    // check out the file system characteristics
+    //
+    if (GetFullPathName(filename, PATHLEN, root, &dummy)) {
+	if (dummy = strchr(root, '\\'))
+	    *++dummy = '\0';
+	if (GetVolumeInformation(root, volname, PATHLEN, 
+				 &serial, &maxname, &flags, 0, 0)) {
+	    downcase = !(flags & FS_CASE_SENSITIVE);
+	}
+    }
+    else {
+	downcase = TRUE;
+    }
+
+    //
+    // Get us a DIR structure
+    //
+
+    p = xcalloc(sizeof(DIR), 1);
+    if (p == NULL)
+	return NULL;
+    
+    //
+    // Create the search pattern
+    //
+
+    strcpy(scanname, filename);
+
+    if (index("/\\", *(scanname + strlen(scanname) - 1)) == NULL)
+	strcat(scanname, "/*");
+    else
+	strcat(scanname, "*");
+
+    //
+    // do the FindFirstFile call
+    //
+
+    fh = FindFirstFile (scanname, &FindData);
+    if (fh == INVALID_HANDLE_VALUE) {
+	return NULL;
+    }
+
+    //
+    // now allocate the first part of the string table for the
+    // filenames that we find.
+    //
+
+    idx = strlen(FindData.cFileName)+1;
+    p->start = ALLOC_N(char, idx);
+    strcpy (p->start, FindData.cFileName);
+    if (downcase)
+	strlwr(p->start);
+    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, &FindData)) {
+	len = strlen (FindData.cFileName);
+
+	//
+	// bump the string table size by enough for the
+	// new name and it's null terminator 
+	//
+
+	#define Renew(x, y, z) (x = (z *)realloc(x, y))
+
+	Renew (p->start, idx+len+1, char);
+	if (p->start == NULL) {
+	    Fatal ("opendir: malloc failed!\n");
+	}
+	strcpy(&p->start[idx], FindData.cFileName);
+	if (downcase) 
+	    strlwr(&p->start[idx]);
+	p->nfiles++;
+	idx += len+1;
+    }
+    FindClose(fh);
+    p->size = idx;
+    p->curr = p->start;
+    return p;
+}
+
+
+//
+// Readdir just returns the current string pointer and bumps the
+// string pointer to the next entry.
+//
+
+struct direct  *
+readdir(DIR *dirp)
+{
+    int         len;
+    static int  dummy = 0;
+
+    if (dirp->curr) {
+
+	//
+	// first set up the structure to return
+	//
+
+	len = strlen(dirp->curr);
+	strcpy(dirp->dirstr.d_name, dirp->curr);
+	dirp->dirstr.d_namlen = len;
+
+	//
+	// Fake inode
+	//
+	dirp->dirstr.d_ino = dummy++;
+
+	//
+	// Now set up for the next call to readdir
+	//
+
+	dirp->curr += len + 1;
+	if (dirp->curr >= (dirp->start + dirp->size)) {
+	    dirp->curr = NULL;
+	}
+
+	return &(dirp->dirstr);
+
+    } else
+	return NULL;
+}
+
+//
+// Telldir returns the current string pointer position
+//
+
+long
+telldir(DIR *dirp)
+{
+	return (long) dirp->curr;	/* ouch! pointer to long cast */
+}
+
+//
+// Seekdir moves the string pointer to a previously saved position
+// (Saved by telldir).
+
+void
+seekdir(DIR *dirp, long loc)
+{
+	dirp->curr = (char *) loc;	/* ouch! long to pointer cast */
+}
+
+//
+// Rewinddir resets the string pointer to the start
+//
+
+void
+rewinddir(DIR *dirp)
+{
+	dirp->curr = dirp->start;
+}
+
+//
+// This just free\'s the memory allocated by opendir
+//
+
+void
+closedir(DIR *dirp)
+{
+	free(dirp->start);
+	free(dirp);
+}
+#endif
+
+
+//
+// 98.2% of this code was lifted from the OS2 port. (JCW)
+//
+
+#if 0
+// add_suffix is in util.c too.
+/*
+ * Suffix appending for in-place editing under MS-DOS and OS/2 (and now NT!).
+ *
+ * Here are the rules:
+ *
+ * Style 0:  Append the suffix exactly as standard perl would do it.
+ *           If the filesystem groks it, use it.  (HPFS will always
+ *           grok it.  So will NTFS. FAT will rarely accept it.)
+ *
+ * Style 1:  The suffix begins with a '.'.  The extension is replaced.
+ *           If the name matches the original name, use the fallback method.
+ *
+ * Style 2:  The suffix is a single character, not a '.'.  Try to add the 
+ *           suffix to the following places, using the first one that works.
+ *               [1] Append to extension.  
+ *               [2] Append to filename, 
+ *               [3] Replace end of extension, 
+ *               [4] Replace end of filename.
+ *           If the name matches the original name, use the fallback method.
+ *
+ * Style 3:  Any other case:  Ignore the suffix completely and use the
+ *           fallback method.
+ *
+ * Fallback method:  Change the extension to ".$$$".  If that matches the
+ *           original name, then change the extension to ".~~~".
+ *
+ * If filename is more than 1000 characters long, we die a horrible
+ * death.  Sorry.
+ *
+ * The filename restriction is a cheat so that we can use buf[] to store
+ * assorted temporary goo.
+ *
+ * Examples, assuming style 0 failed.
+ *
+ * suffix = ".bak" (style 1)
+ *                foo.bar => foo.bak
+ *                foo.bak => foo.$$$	(fallback)
+ *                foo.$$$ => foo.~~~	(fallback)
+ *                makefile => makefile.bak
+ *
+ * suffix = "~" (style 2)
+ *                foo.c => foo.c~
+ *                foo.c~ => foo.c~~
+ *                foo.c~~ => foo~.c~~
+ *                foo~.c~~ => foo~~.c~~
+ *                foo~~~~~.c~~ => foo~~~~~.$$$ (fallback)
+ *
+ *                foo.pas => foo~.pas
+ *                makefile => makefile.~
+ *                longname.fil => longname.fi~
+ *                longname.fi~ => longnam~.fi~
+ *                longnam~.fi~ => longnam~.$$$
+ *                
+ */
+
+
+static char suffix1[] = ".$$$";
+static char suffix2[] = ".~~~";
+
+#define ext (&buf[1000])
+
+#define strEQ(s1,s2) (strcmp(s1,s2) == 0)
+
+void
+add_suffix(struct RString *str, char *suffix)
+{
+    int baselen;
+    int extlen = strlen(suffix);
+    char *s, *t, *p;
+    int slen;
+    char buf[1024];
+
+    if (str->len > 1000)
+        Fatal("Cannot do inplace edit on long filename (%d characters)", str->len);
+
+    /* Style 0 */
+    slen = str->len;
+    str_cat(str, suffix, extlen);
+    if (valid_filename(str->ptr)) return;
+
+    /* Fooey, style 0 failed.  Fix str before continuing. */
+    str->ptr[str->len = slen] = '\0';
+
+    slen = extlen;
+    t = buf; baselen = 0; s = str->ptr;
+    while ( (*t = *s) && *s != '.') {
+	baselen++;
+	if (*s == '\\' || *s == '/') baselen = 0;
+ 	s++; t++;
+    }
+    p = t;
+
+    t = ext; extlen = 0;
+    while (*t++ = *s++) extlen++;
+    if (extlen == 0) { ext[0] = '.'; ext[1] = 0; extlen++; }
+
+    if (*suffix == '.') {        /* Style 1 */
+        if (strEQ(ext, suffix)) goto fallback;
+	strcpy(p, suffix);
+    } else if (suffix[1] == '\0') {  /* Style 2 */
+        if (extlen < 4) { 
+	    ext[extlen] = *suffix;
+	    ext[++extlen] = '\0';
+        } else if (baselen < 8) {
+   	    *p++ = *suffix;
+	} else if (ext[3] != *suffix) {
+	    ext[3] = *suffix;
+	} else if (buf[7] != *suffix) {
+	    buf[7] = *suffix;
+	} else goto fallback;
+	strcpy(p, ext);
+    } else { /* Style 3:  Panic */
+fallback:
+	(void)memcpy(p, strEQ(ext, suffix1) ? suffix2 : suffix1, 5);
+    }
+    str_grow(str, strlen(buf));
+    memcpy(str->ptr, buf, str->len);
+}
+#endif
+
+static int 
+valid_filename(char *s)
+{
+    int fd;
+
+    //
+    // if the file exists, then it\'s a valid filename!
+    //
+
+    if (_access(s, 0) == 0) {
+	return 1;
+    }
+
+    //
+    // It doesn\'t exist, so see if we can open it.
+    //
+    
+    if ((fd = _open(s, _O_CREAT, 0666)) >= 0) {
+	close(fd);
+	_unlink (s);	// don\'t leave it laying around
+	return 1;
+    }
+    return 0;
+}
+
+
+//
+// This is a clone of fdopen so that we can handle the 
+// brain damaged version of sockets that NT gets to use.
+//
+// The problem is that sockets are not real file handles and 
+// cannot be fdopen\'ed. This causes problems in the do_socket
+// routine in doio.c, since it tries to create two file pointers
+// for the socket just created. We\'ll fake out an fdopen and see
+// if we can prevent perl from trying to do stdio on sockets.
+//
+
+FILE *
+fdopen (int fd, const char *mode)
+{
+    FILE *fp;
+    char sockbuf[80];
+    int optlen;
+    int retval;
+    extern int errno;
+
+    retval = getsockopt((SOCKET)fd, SOL_SOCKET, SO_TYPE, sockbuf, &optlen);
+    if (retval == SOCKET_ERROR) {
+	int iRet;
+
+	iRet = WSAGetLastError();
+	if (iRet == WSAENOTSOCK || iRet == WSANOTINITIALISED)
+	return (_fdopen(fd, mode));
+    }
+
+    //
+    // If we get here, then fd is actually a socket.
+    //
+    fp = xcalloc(sizeof(FILE), 1);
+#if _MSC_VER < 800
+    fileno(fp) = fd;
+#else
+    fp->_file = fd;
+#endif
+    if (*mode == 'r')
+	fp->_flag = _IOREAD;
+    else
+	fp->_flag = _IOWRT;
+    return fp;
+}
+
+
+//
+// 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 * 
+mystrerror(int e) 
+{
+    static char buffer[512];
+    extern int sys_nerr;
+    DWORD source = 0;
+
+    if (e < 0 || e > sys_nerr) {
+	if (e < 0)
+	    e = GetLastError();
+	if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, &source, e, 0,
+			  buffer, 512, NULL) == 0) {
+	    strcpy (buffer, "Unknown Error");
+	}
+	return buffer;
+    }
+    return strerror(e);
+	
+}
+
+//
+// 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
+
+UIDTYPE
+getuid(void)
+{
+	return ROOT_UID;
+}
+
+UIDTYPE
+geteuid(void)
+{
+	return ROOT_UID;
+}
+
+GIDTYPE
+getgid(void)
+{
+	return ROOT_GID;
+}
+
+GIDTYPE
+getegid(void)
+{
+    return ROOT_GID;
+}
+
+int
+setuid(int uid)
+{ 
+    return (uid == ROOT_UID ? 0 : -1);
+}
+
+int
+setgid(int gid)
+{
+    return (gid == ROOT_GID ? 0 : -1);
+}
+
+//
+// File system stuff
+//
+
+int
+/* ioctl(int i, unsigned int u, char *data) */
+ioctl(int i, unsigned int u, long data)
+{
+    return -1;
+}
+
+
+//
+// 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;
+
+long 
+myselect (int nfds, fd_set *rd, fd_set *wr, fd_set *ex,
+	       struct timeval *timeout)
+{
+    long r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = select (nfds, rd, wr, ex, timeout)) == SOCKET_ERROR)
+	errno = WSAGetLastError();
+    return r;
+}
+
+static void
+StartSockets () {
+    WORD version;
+    WSADATA retdata;
+    int ret;
+    
+    //
+    // initalize the winsock interface and insure that it\'s
+    // cleaned up at exit.
+    //
+    version = MAKEWORD(1, 1);
+    if (ret = WSAStartup(version, &retdata))
+	Fatal ("Unable to locate winsock library!\n");
+    if (LOBYTE(retdata.wVersion) != 1)
+	Fatal("could not find version 1 of winsock dll\n");
+
+    if (HIBYTE(retdata.wVersion) != 1)
+	Fatal("could not find version 1 of winsock dll\n");
+
+    atexit((void (*)(void)) WSACleanup);
+}
+
+#undef accept
+
+SOCKET 
+myaccept (SOCKET s, struct sockaddr *addr, int *addrlen)
+{
+    SOCKET r;
+
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = accept (s, addr, addrlen)) == INVALID_SOCKET)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef bind
+
+int 
+mybind (SOCKET s, struct sockaddr *addr, int addrlen)
+{
+    int r;
+
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = bind (s, addr, addrlen)) == SOCKET_ERROR)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef connect
+
+int 
+myconnect (SOCKET s, struct sockaddr *addr, int addrlen)
+{
+    int r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = connect (s, addr, addrlen)) == SOCKET_ERROR)
+	errno = WSAGetLastError();
+    return r;
+}
+
+
+#undef getpeername
+
+int 
+mygetpeername (SOCKET s, struct sockaddr *addr, int *addrlen)
+{
+    int r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = getpeername (s, addr, addrlen)) == SOCKET_ERROR)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef getsockname
+
+int 
+mygetsockname (SOCKET s, struct sockaddr *addr, int *addrlen)
+{
+    int r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = getsockname (s, addr, addrlen)) == SOCKET_ERROR)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef getsockopt
+
+int 
+mygetsockopt (SOCKET s, int level, int optname, char *optval, int *optlen)
+{
+    int r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = getsockopt (s, level, optname, optval, optlen)) == SOCKET_ERROR)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef ioctlsocket
+
+int 
+myioctlsocket (SOCKET s, long cmd, u_long *argp)
+{
+    int r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = ioctlsocket (s, cmd, argp)) == SOCKET_ERROR)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef listen
+
+int 
+mylisten (SOCKET s, int backlog)
+{
+    int r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = listen (s, backlog)) == SOCKET_ERROR)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef recv
+
+int 
+myrecv (SOCKET s, char *buf, int len, int flags)
+{
+    int r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = recv (s, buf, len, flags)) == SOCKET_ERROR)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef recvfrom
+
+int 
+myrecvfrom (SOCKET s, char *buf, int len, int flags, 
+		struct sockaddr *from, int *fromlen)
+{
+    int r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = recvfrom (s, buf, len, flags, from, fromlen)) == SOCKET_ERROR)
+	errno =  WSAGetLastError();
+    return r;
+}
+
+#undef send
+
+int 
+mysend (SOCKET s, char *buf, int len, int flags)
+{
+    int r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = send (s, buf, len, flags)) == SOCKET_ERROR)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef sendto
+
+int 
+mysendto (SOCKET s, char *buf, int len, int flags, 
+		struct sockaddr *to, int tolen)
+{
+    int r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = sendto (s, buf, len, flags, to, tolen)) == SOCKET_ERROR)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef setsockopt
+
+int 
+mysetsockopt (SOCKET s, int level, int optname, char *optval, int optlen)
+{
+    int r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = setsockopt (s, level, optname, optval, optlen)) == SOCKET_ERROR)
+	errno = WSAGetLastError();
+    return r;
+}
+    
+#undef shutdown
+
+int 
+myshutdown (SOCKET s, int how)
+{
+    int r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = shutdown (s, how)) == SOCKET_ERROR)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef socket
+
+SOCKET 
+mysocket (int af, int type, int protocol)
+{
+    SOCKET s;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((s = socket (af, type, protocol)) == INVALID_SOCKET)
+	errno = WSAGetLastError();
+    return s;
+}
+
+#undef gethostbyaddr
+
+struct hostent *
+mygethostbyaddr (char *addr, int len, int type)
+{
+    struct hostent *r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = gethostbyaddr (addr, len, type)) == NULL)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef gethostbyname
+
+struct hostent *
+mygethostbyname (char *name)
+{
+    struct hostent *r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = gethostbyname (name)) == NULL)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef gethostname
+
+int
+mygethostname (char *name, int len)
+{
+    int r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = gethostname (name, len)) == SOCKET_ERROR)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef getprotobyname
+
+struct protoent *
+mygetprotobyname (char *name)
+{
+    struct protoent *r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = getprotobyname (name)) == NULL)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef getprotobynumber
+
+struct protoent *
+mygetprotobynumber (int num)
+{
+    struct protoent *r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = getprotobynumber (num)) == NULL)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef getservbyname
+
+struct servent *
+mygetservbyname (char *name, char *proto)
+{
+    struct servent *r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = getservbyname (name, proto)) == NULL)
+	errno = WSAGetLastError();
+    return r;
+}
+
+#undef getservbyport
+
+struct servent *
+mygetservbyport (int port, char *proto)
+{
+    struct servent *r;
+    if (!NtSocketsInitialized++) {
+	StartSockets();
+    }
+    if ((r = getservbyport (port, proto)) == NULL)
+	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(char *name) {return (struct netent *)NULL;}
+
+struct netent *getnetbyname(long net, int type) {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) {}
+
+
+#ifndef WNOHANG
+#define WNOHANG -1
+#endif
+
+pid_t
+waitpid (pid_t pid, int *stat_loc, int options)
+{
+    DWORD timeout;
+
+    if (options == WNOHANG) {
+	timeout = 0;
+    } else {
+	timeout = INFINITE;
+    }
+    if (WaitForSingleObject((HANDLE) pid, timeout) == WAIT_OBJECT_0) {
+	pid = _cwait(stat_loc, pid, 0);
+	return pid;
+    }
+    return 0;
+}
+
+#include <sys/timeb.h>
+
+void _cdecl
+gettimeofday(struct timeval *tv, struct timezone *tz)
+{                                
+    struct timeb tb;
+
+    ftime(&tb);
+    tv->tv_sec = tb.time;
+    tv->tv_usec = tb.millitm * 1000;
+}
+
+char *
+getcwd(buffer, size)
+    char *buffer;
+    int size;
+{
+    int length;
+    char *bp;
+
+    if (_getcwd(buffer, size) == NULL) {
+        return NULL;
+    }
+    length = strlen(buffer);
+    if (length >= size) {
+        return NULL;
+    }
+
+    for (bp = buffer; *bp != '\0'; bp++) {
+	if (*bp == '\\') {
+	    *bp = '/';
+	}
+    }
+    return buffer;
+}
+
+static char *
+str_grow(struct RString *str, size_t new_size)
+{
+	char *p;
+
+	p = realloc(str->ptr, new_size);
+	if (p == NULL)
+		Fatal("cannot grow string\n");
+
+	str->len = new_size;
+	str->ptr = p;
+
+	return p;
+}
+
+int
+chown(char *path, int owner, int group)
+{
+	return 0;
+}
+
+int
+kill(int pid, int sig)
+{
+#if 1
+	if (pid == GetCurrentProcessId())
+		return raise(sig);
+
+	if (sig == 2 && pid > 0)
+		if (GenerateConsoleCtrlEvent(CTRL_C_EVENT, (DWORD)pid))
+			return 0;
+
+	return -1;
+#else
+	return 0;
+#endif
+}
+
+int
+link(char *from, char *to)
+{
+	return -1;
+}
+
+int
+wait()
+{
+	return 0;
+}
+
diff --git a/missing/nt.h b/missing/nt.h
new file mode 100644
index 0000000000..5977a59a1d
--- /dev/null
+++ b/missing/nt.h
@@ -0,0 +1,225 @@
+#ifndef EXT_NT_H
+#define EXT_NT_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
+//
+
+//
+// GRRRR!!!!  Windows Nonsense.
+// Define the following so we don't get tons of extra stuff
+// when we include windows.h 
+//
+#if 0
+#define NOGDICAPMASKS     
+#define NOVIRTUALKEYCODES 
+#define NOWINMESSAGES     
+#define NOWINSTYLES       
+#define NOSYSMETRICS      
+#define NOMENUS           
+#define NOICONS           
+#define NOKEYSTATES       
+#define NOSYSCOMMANDS     
+#define NORASTEROPS       
+#define NOSHOWWINDOW      
+#define OEMRESOURCE       
+#define NOATOM            
+#define NOCLIPBOARD       
+#define NOCOLOR           
+#define NOCTLMGR          
+#define NODRAWTEXT        
+#define NOGDI             
+//#define NOKERNEL        
+//#define NOUSER          
+#define NONLS             
+#define NOMB              
+#define NOMEMMGR          
+#define NOMETAFILE        
+#define NOMINMAX          
+#define NOMSG             
+#define NOOPENFILE        
+#define NOSCROLL          
+#define NOSERVICE         
+#define NOSOUND           
+#define NOTEXTMETRIC      
+#define NOWH              
+#define NOWINOFFSETS      
+#define NOCOMM            
+#define NOKANJI           
+#define NOHELP            
+#define NOPROFILER        
+#define NODEFERWINDOWPOS  
+#endif
+
+//
+// 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
+#include <windows.h>
+#include <winsock.h>
+#undef OpenFile
+#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
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <direct.h>
+#include <process.h>
+#include <time.h>
+#include <math.h>
+#include <sys/types.h>
+#include <sys/utime.h>
+
+//
+// Grrr...
+//
+
+#define access	   _access
+#define chmod	   _chmod
+#define chsize	   _chsize
+#define close	   _close
+#define creat	   _creat
+#define dup	   _dup
+#define dup2	   _dup2
+#define eof	   _eof
+#define filelength _filelength
+#define isatty	   _isatty
+#define locking    _locking
+#define lseek	   _lseek
+#define mktemp	   _mktemp
+#define open	   _open
+#define read	   _read
+#define setmode    _setmode
+#define sopen	   _sopen
+#define tell	   _tell
+#define umask	   _umask
+#define unlink	   _unlink
+#define write	   _write
+#define execl	   _execl
+#define execle	   _execle
+#define execlp	   _execlp
+#define execlpe    _execlpe
+#define execv	   _execv
+#define execve	   _execve
+#define execvp	   _execvp
+#define execvpe    _execvpe
+#define getpid	   _getpid
+#define spawnl	   _spawnl
+#define spawnle    _spawnle
+#define spawnlp    _spawnlp
+#define spawnlpe   _spawnlpe
+#define spawnv	   _spawnv
+#define spawnve    _spawnve
+#define spawnvp    _spawnvp
+#define spawnvpe   _spawnvpe
+#if _MSC_VER < 800
+#define fileno	   _fileno
+#endif
+#define utime      _utime
+//#define pipe       _pipe
+#define perror      _perror
+
+
+/* these are defined in nt.c */
+
+extern int NtMakeCmdVector(char *, char ***, int);
+/* extern void NtInitialize(int *, char ***); */
+extern char *NtGetLib(void);
+extern char *NtGetBin(void);
+extern FILE *mypopen(char *, char *);
+extern int  flock(int fd, int oper);
+
+//
+// define this so we can do inplace editing
+//
+
+#define SUFFIX
+
+//
+// stubs
+//
+// extern int       ioctl (int, unsigned int, char *);
+extern int       ioctl (int, unsigned int, long);
+#if 0
+extern void      sleep (unsigned int);
+#else
+#define sleep(x) Sleep(x*1000)
+#endif
+
+extern UIDTYPE   getuid (void);
+extern UIDTYPE   geteuid (void);
+extern GIDTYPE   getgid (void);
+extern GIDTYPE   getegid (void);
+extern int       setuid (int);
+extern int       setgid (int);
+
+
+#undef IN  /* confict in parse.c */
+
+#if 0
+extern int sys_nerr;
+extern char *sys_errlist[];
+#endif
+extern char *mystrerror(int);
+
+#define strerror(e) mystrerror(e)
+
+#define PIPE_BUF 1024
+
+#define HAVE_STDLIB_H 1
+#define HAVE_GETLOGIN 1
+#define HAVE_WAITPID 1
+#define HAVE_GETCWD 1
+
+#define LOCK_SH 1
+#define LOCK_EX 2
+#define LOCK_NB 4
+#define LOCK_UN 8
+#ifndef EWOULDBLOCK
+#define EWOULDBLOCK 10035 /* EBASEERR + 35 (winsock.h) */
+#endif
+
+#ifdef popen
+#undef popen
+#define popen    mypopen
+#endif
+#ifdef pclose
+#undef pclose
+#define pclose   mypclose
+#endif
+
+#undef va_start
+#undef va_end
+
+#ifdef popen
+#undef popen
+#define popen    mypopen
+#endif
+#ifdef pclose
+#undef pclose
+#define pclose   mypclose
+#endif
+
+#undef va_start
+#undef va_end
+
+#endif
diff --git a/missing/setenv.c b/missing/setenv.c
new file mode 100644
index 0000000000..b7b43a674b
--- /dev/null
+++ b/missing/setenv.c
@@ -0,0 +1,77 @@
+/* 
+ *    Copyright (c) 1991, Larry Wall
+ *
+ *    You may distribute under the terms of either the GNU General Public
+ *    License or the Artistic License, as specified in the README file.
+ */
+
+#include "ruby.h"
+
+#ifndef NT
+extern char **environ;
+#endif
+extern char **origenviron;
+
+#ifndef NT
+char *strdup();
+#endif
+
+static int
+envix(nam)
+char *nam;
+{
+    register int i, len = strlen(nam);
+
+    for (i = 0; environ[i]; i++) {
+	if (memcmp(environ[i],nam,len) == 0 && environ[i][len] == '=')
+	    break;			/* memcmp must come first to avoid */
+    }					/* potential SEGV's */
+    return i;
+}
+
+void
+setenv(nam,val)
+char *nam, *val;
+{
+    register int i=envix(nam);		/* where does it go? */
+
+    if (environ == origenviron) {	/* need we copy environment? */
+	int j;
+	int max;
+	char **tmpenv;
+
+	/*SUPPRESS 530*/
+	for (max = i; environ[max]; max++) ;
+	tmpenv = ALLOC_N(char*, max+2);
+	for (j=0; j<max; j++)		/* copy environment */
+	    tmpenv[j] = strdup(environ[j]);
+	tmpenv[max] = 0;
+	environ = tmpenv;		/* tell exec where it is now */
+    }
+    if (!val) {
+	while (environ[i]) {
+	    environ[i] = environ[i+1];
+	    i++;
+	}
+	return;
+    }
+    if (!environ[i]) {			/* does not exist yet */
+	REALLOC_N(environ, char*, i+2);	/* just expand it a bit */
+	environ[i+1] = 0;	/* make sure it's null terminated */
+    }
+    else {
+	free(environ[i]);
+    }
+    environ[i] = ALLOC_N(char, strlen(nam) + strlen(val) + 2);
+#ifndef MSDOS
+    (void)sprintf(environ[i],"%s=%s",nam,val);/* all that work just for this */
+#else
+    /* MS-DOS requires environment variable names to be in uppercase */
+    /* [Tom Dinger, 27 August 1990: Well, it doesn't _require_ it, but
+     * some utilities and applications may break because they only look
+     * for upper case strings. (Fixed strupr() bug here.)]
+     */
+    strcpy(environ[i],nam); strupr(environ[i]);
+    (void)sprintf(environ[i] + strlen(nam),"=%s",val);
+#endif /* MSDOS */
+}
diff --git a/missing/strcasecmp.c b/missing/strcasecmp.c
new file mode 100644
index 0000000000..83aa50d9c3
--- /dev/null
+++ b/missing/strcasecmp.c
@@ -0,0 +1,13 @@
+#include <ctype.h>
+
+#define min(a,b) (((a)>(b))?(b):(a))
+int
+strcasecmp(p1, p2)
+    char *p1, *p2;
+{
+    for ( ; *p1 && *p2; p1++, p2++) {
+	if (toupper(*p1) != toupper(*p2))
+	    return toupper(*p1) - toupper(*p2);
+    }
+    return strlen(p1) - strlen(p2);
+}
diff --git a/missing/strdup.c b/missing/strdup.c
new file mode 100644
index 0000000000..2e1fe90bbd
--- /dev/null
+++ b/missing/strdup.c
@@ -0,0 +1,25 @@
+/************************************************
+
+  strdup.c -
+
+  $Author$
+  $Date$
+  created at: Wed Dec  7 15:34:01 JST 1994
+
+************************************************/
+#include <stdio.h>
+
+char *
+strdup(str)
+    char *str;
+{
+    extern char *xmalloc();
+    char *tmp;
+    int len = strlen(str) + 1;
+
+    tmp = xmalloc(len);
+    if (tmp == NULL) return NULL;
+    memcpy(tmp, str, len);
+
+    return tmp;
+}
diff --git a/missing/strerror.c b/missing/strerror.c
new file mode 100644
index 0000000000..44013b3892
--- /dev/null
+++ b/missing/strerror.c
@@ -0,0 +1,19 @@
+/*
+ * strerror.c --- Map an integer error number into a printable string.
+ */
+
+extern int sys_nerr;
+extern char *sys_errlist[];
+
+static char msg[50];
+
+char *
+strerror(error)
+    int error;
+{
+    if ((error <= sys_nerr) && (error > 0)) {
+	return sys_errlist[error];
+    }
+    sprintf (msg, "Unknown error (%d)", error);
+    return msg;
+}
diff --git a/missing/strftime.c b/missing/strftime.c
new file mode 100644
index 0000000000..478471c37d
--- /dev/null
+++ b/missing/strftime.c
@@ -0,0 +1,889 @@
+/*
+ * strftime.c
+ *
+ * Public-domain implementation of ANSI C library routine.
+ *
+ * It's written in old-style C for maximal portability.
+ * However, since I'm used to prototypes, I've included them too.
+ *
+ * If you want stuff in the System V ascftime routine, add the SYSV_EXT define.
+ * For extensions from SunOS, add SUNOS_EXT.
+ * For stuff needed to implement the P1003.2 date command, add POSIX2_DATE.
+ * For VMS dates, add VMS_EXT.
+ * For a an RFC822 time format, add MAILHEADER_EXT.
+ * For ISO week years, add ISO_DATE_EXT.
+ * For complete POSIX semantics, add POSIX_SEMANTICS.
+ *
+ * The code for %c, %x, and %X now follows the 1003.2 specification for
+ * the POSIX locale.
+ * This version ignores LOCALE information.
+ * It also doesn't worry about multi-byte characters.
+ * So there.
+ *
+ * This file is also shipped with GAWK (GNU Awk), gawk specific bits of
+ * code are included if GAWK is defined.
+ *
+ * Arnold Robbins
+ * January, February, March, 1991
+ * Updated March, April 1992
+ * Updated April, 1993
+ * Updated February, 1994
+ * Updated May, 1994
+ * Updated January, 1995
+ * Updated September, 1995
+ * Updated January, 1996
+ *
+ * Fixes from ado@elsie.nci.nih.gov
+ * February 1991, May 1992
+ * Fixes from Tor Lillqvist tml@tik.vtt.fi
+ * May, 1993
+ * Further fixes from ado@elsie.nci.nih.gov
+ * February 1994
+ * %z code from chip@chinacat.unicom.com
+ * Applied September 1995
+ * %V code fixed (again) and %G, %g added,
+ * January 1996
+ */
+
+#ifndef GAWK
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+#include <time.h>
+#endif
+#if defined(TM_IN_SYS_TIME) || ! defined(GAWK)
+#include <sys/types.h>
+#include <sys/time.h>
+#endif
+
+/* defaults: season to taste */
+#define SYSV_EXT	1	/* stuff in System V ascftime routine */
+#define SUNOS_EXT	1	/* stuff in SunOS strftime routine */
+#define POSIX2_DATE	1	/* stuff in Posix 1003.2 date command */
+#define VMS_EXT		1	/* include %v for VMS date format */
+#define MAILHEADER_EXT	1	/* add %z for HHMM format */
+#define ISO_DATE_EXT	1	/* %G and %g for year of ISO week */
+#ifndef GAWK
+#define POSIX_SEMANTICS	1	/* call tzset() if TZ changes */
+#endif
+
+#if defined(ISO_DATE_EXT)
+#if ! defined(POSIX2_DATE)
+#define POSIX2_DATE	1
+#endif
+#endif
+
+#if defined(POSIX2_DATE)
+#if ! defined(SYSV_EXT)
+#define SYSV_EXT	1
+#endif
+#if ! defined(SUNOS_EXT)
+#define SUNOS_EXT	1
+#endif
+#endif
+
+#if defined(POSIX2_DATE)
+#define adddecl(stuff)	stuff
+#else
+#define adddecl(stuff)
+#endif
+
+#undef strchr	/* avoid AIX weirdness */
+
+#ifndef __STDC__
+#define const	/**/
+extern void *malloc();
+extern void *realloc();
+extern void tzset();
+extern char *strchr();
+extern char *getenv();
+static int weeknumber();
+adddecl(static int iso8601wknum();)
+#else
+extern void *malloc(unsigned count);
+extern void *realloc(void *ptr, unsigned count);
+extern void tzset(void);
+extern char *strchr(const char *str, int ch);
+extern char *getenv(const char *v);
+static int weeknumber(const struct tm *timeptr, int firstweekday);
+adddecl(static int iso8601wknum(const struct tm *timeptr);)
+#endif
+
+#ifdef __GNUC__
+#define inline	__inline__
+#else
+#define inline	/**/
+#endif
+
+#define range(low, item, hi)	max(low, min(item, hi))
+
+#if !defined(OS2) && !defined(MSDOS) && defined(HAVE_TZNAME)
+extern char *tzname[2];
+extern int daylight;
+#ifdef SOLARIS
+extern long timezone, altzone;
+#else
+extern int timezone, altzone;
+#endif
+#endif
+
+#undef min	/* just in case */
+
+/* min --- return minimum of two numbers */
+
+#ifndef __STDC__
+static inline int
+min(a, b)
+int a, b;
+#else
+static inline int
+min(int a, int b)
+#endif
+{
+	return (a < b ? a : b);
+}
+
+#undef max	/* also, just in case */
+
+/* max --- return maximum of two numbers */
+
+#ifndef __STDC__
+static inline int
+max(a, b)
+int a, b;
+#else
+static inline int
+max(int a, int b)
+#endif
+{
+	return (a > b ? a : b);
+}
+
+/* strftime --- produce formatted time */
+
+#ifndef __STDC__
+size_t
+strftime(s, maxsize, format, timeptr)
+char *s;
+size_t maxsize;
+const char *format;
+const struct tm *timeptr;
+#else
+size_t
+strftime(char *s, size_t maxsize, const char *format, const struct tm *timeptr)
+#endif
+{
+	char *endp = s + maxsize;
+	char *start = s;
+	auto char tbuf[100];
+	long off;
+	int i, w, y;
+	static short first = 1;
+#ifdef POSIX_SEMANTICS
+	static char *savetz = NULL;
+	static int savetzlen = 0;
+	char *tz;
+#endif /* POSIX_SEMANTICS */
+#ifndef HAVE_TM_ZONE
+#ifndef HAVE_TM_NAME
+#ifndef HAVE_TZNAME
+	extern char *timezone();
+	struct timeval tv;
+	struct timezone zone;
+#endif /* HAVE_TZNAME */
+#endif /* HAVE_TM_NAME */
+#endif /* HAVE_TM_ZONE */
+
+	/* various tables, useful in North America */
+	static const char *days_a[] = {
+		"Sun", "Mon", "Tue", "Wed",
+		"Thu", "Fri", "Sat",
+	};
+	static const char *days_l[] = {
+		"Sunday", "Monday", "Tuesday", "Wednesday",
+		"Thursday", "Friday", "Saturday",
+	};
+	static const char *months_a[] = {
+		"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+		"Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+	};
+	static const char *months_l[] = {
+		"January", "February", "March", "April",
+		"May", "June", "July", "August", "September",
+		"October", "November", "December",
+	};
+	static const char *ampm[] = { "AM", "PM", };
+
+	if (s == NULL || format == NULL || timeptr == NULL || maxsize == 0)
+		return 0;
+
+	/* quick check if we even need to bother */
+	if (strchr(format, '%') == NULL && strlen(format) + 1 >= maxsize)
+		return 0;
+
+#ifndef POSIX_SEMANTICS
+	if (first) {
+		tzset();
+		first = 0;
+	}
+#else	/* POSIX_SEMANTICS */
+	tz = getenv("TZ");
+	if (first) {
+		if (tz != NULL) {
+			int tzlen = strlen(tz);
+
+			savetz = (char *) malloc(tzlen + 1);
+			if (savetz != NULL) {
+				savetzlen = tzlen + 1;
+				strcpy(savetz, tz);
+			}
+		}
+		tzset();
+		first = 0;
+	}
+	/* if we have a saved TZ, and it is different, recapture and reset */
+	if (tz && savetz && (tz[0] != savetz[0] || strcmp(tz, savetz) != 0)) {
+		i = strlen(tz) + 1;
+		if (i > savetzlen) {
+			savetz = (char *) realloc(savetz, i);
+			if (savetz) {
+				savetzlen = i;
+				strcpy(savetz, tz);
+			}
+		} else
+			strcpy(savetz, tz);
+		tzset();
+	}
+#endif	/* POSIX_SEMANTICS */
+
+	for (; *format && s < endp - 1; format++) {
+		tbuf[0] = '\0';
+		if (*format != '%') {
+			*s++ = *format;
+			continue;
+		}
+	again:
+		switch (*++format) {
+		case '\0':
+			*s++ = '%';
+			goto out;
+
+		case '%':
+			*s++ = '%';
+			continue;
+
+		case 'a':	/* abbreviated weekday name */
+			if (timeptr->tm_wday < 0 || timeptr->tm_wday > 6)
+				strcpy(tbuf, "?");
+			else
+				strcpy(tbuf, days_a[timeptr->tm_wday]);
+			break;
+
+		case 'A':	/* full weekday name */
+			if (timeptr->tm_wday < 0 || timeptr->tm_wday > 6)
+				strcpy(tbuf, "?");
+			else
+				strcpy(tbuf, days_l[timeptr->tm_wday]);
+			break;
+
+#ifdef SYSV_EXT
+		case 'h':	/* abbreviated month name */
+#endif
+		case 'b':	/* abbreviated month name */
+			if (timeptr->tm_mon < 0 || timeptr->tm_mon > 11)
+				strcpy(tbuf, "?");
+			else
+				strcpy(tbuf, months_a[timeptr->tm_mon]);
+			break;
+
+		case 'B':	/* full month name */
+			if (timeptr->tm_mon < 0 || timeptr->tm_mon > 11)
+				strcpy(tbuf, "?");
+			else
+				strcpy(tbuf, months_l[timeptr->tm_mon]);
+			break;
+
+		case 'c':	/* appropriate date and time representation */
+			strftime(tbuf, sizeof tbuf, "%a %b %e %H:%M:%S %Y", timeptr);
+			break;
+
+		case 'd':	/* day of the month, 01 - 31 */
+			i = range(1, timeptr->tm_mday, 31);
+			sprintf(tbuf, "%02d", i);
+			break;
+
+		case 'H':	/* hour, 24-hour clock, 00 - 23 */
+			i = range(0, timeptr->tm_hour, 23);
+			sprintf(tbuf, "%02d", i);
+			break;
+
+		case 'I':	/* hour, 12-hour clock, 01 - 12 */
+			i = range(0, timeptr->tm_hour, 23);
+			if (i == 0)
+				i = 12;
+			else if (i > 12)
+				i -= 12;
+			sprintf(tbuf, "%02d", i);
+			break;
+
+		case 'j':	/* day of the year, 001 - 366 */
+			sprintf(tbuf, "%03d", timeptr->tm_yday + 1);
+			break;
+
+		case 'm':	/* month, 01 - 12 */
+			i = range(0, timeptr->tm_mon, 11);
+			sprintf(tbuf, "%02d", i + 1);
+			break;
+
+		case 'M':	/* minute, 00 - 59 */
+			i = range(0, timeptr->tm_min, 59);
+			sprintf(tbuf, "%02d", i);
+			break;
+
+		case 'p':	/* am or pm based on 12-hour clock */
+			i = range(0, timeptr->tm_hour, 23);
+			if (i < 12)
+				strcpy(tbuf, ampm[0]);
+			else
+				strcpy(tbuf, ampm[1]);
+			break;
+
+		case 'S':	/* second, 00 - 61 */
+			i = range(0, timeptr->tm_sec, 61);
+			sprintf(tbuf, "%02d", i);
+			break;
+
+		case 'U':	/* week of year, Sunday is first day of week */
+			sprintf(tbuf, "%02d", weeknumber(timeptr, 0));
+			break;
+
+		case 'w':	/* weekday, Sunday == 0, 0 - 6 */
+			i = range(0, timeptr->tm_wday, 6);
+			sprintf(tbuf, "%d", i);
+			break;
+
+		case 'W':	/* week of year, Monday is first day of week */
+			sprintf(tbuf, "%02d", weeknumber(timeptr, 1));
+			break;
+
+		case 'x':	/* appropriate date representation */
+			strftime(tbuf, sizeof tbuf, "%m/%d/%y", timeptr);
+			break;
+
+		case 'X':	/* appropriate time representation */
+			strftime(tbuf, sizeof tbuf, "%H:%M:%S", timeptr);
+			break;
+
+		case 'y':	/* year without a century, 00 - 99 */
+			i = timeptr->tm_year % 100;
+			sprintf(tbuf, "%02d", i);
+			break;
+
+		case 'Y':	/* year with century */
+			sprintf(tbuf, "%d", 1900 + timeptr->tm_year);
+			break;
+
+#ifdef MAILHEADER_EXT
+		/*
+		 * From: Chip Rosenthal <chip@chinacat.unicom.com>
+		 * Date: Sun, 19 Mar 1995 00:33:29 -0600 (CST)
+		 * 
+		 * Warning: the %z [code] is implemented by inspecting the
+		 * timezone name conditional compile settings, and
+		 * inferring a method to get timezone offsets. I've tried
+		 * this code on a couple of machines, but I don't doubt
+		 * there is some system out there that won't like it.
+		 * Maybe the easiest thing to do would be to bracket this
+		 * with an #ifdef that can turn it off. The %z feature
+		 * would be an admittedly obscure one that most folks can
+		 * live without, but it would be a great help to those of
+		 * us that muck around with various message processors.
+		 */
+ 		case 'z':	/* time zone offset east of GMT e.g. -0600 */
+#ifdef HAVE_TM_NAME
+			/*
+			 * Systems with tm_name probably have tm_tzadj as
+			 * secs west of GMT.  Convert to mins east of GMT.
+			 */
+			off = -timeptr->tm_tzadj / 60;
+#else /* !HAVE_TM_NAME */
+#ifdef HAVE_TM_ZONE
+			/*
+			 * Systems with tm_zone probably have tm_gmtoff as
+			 * secs east of GMT.  Convert to mins east of GMT.
+			 */
+			off = timeptr->tm_gmtoff / 60;
+#else /* !HAVE_TM_ZONE */
+#if HAVE_TZNAME
+			/*
+			 * Systems with tzname[] probably have timezone as
+			 * secs west of GMT.  Convert to mins east of GMT.
+			 */
+			off = -(daylight ? timezone : altzone) / 60;
+#else /* !HAVE_TZNAME */
+			off = -zone.tz_minuteswest;
+#endif /* !HAVE_TZNAME */
+#endif /* !HAVE_TM_ZONE */
+#endif /* !HAVE_TM_NAME */
+			if (off < 0) {
+				tbuf[0] = '-';
+				off = -off;
+			} else {
+				tbuf[0] = '+';
+			}
+			sprintf(tbuf+1, "%02d%02d", off/60, off%60);
+			break;
+#endif /* MAILHEADER_EXT */
+
+		case 'Z':	/* time zone name or abbrevation */
+#ifdef HAVE_TZNAME
+			i = (daylight && timeptr->tm_isdst > 0); /* 0 or 1 */
+			strcpy(tbuf, tzname[i]);
+#else
+#ifdef HAVE_TM_ZONE
+			strcpy(tbuf, timeptr->tm_zone);
+#else
+#ifdef HAVE_TM_NAME
+			strcpy(tbuf, timeptr->tm_name);
+#else
+			gettimeofday(& tv, & zone);
+			strcpy(tbuf, timezone(zone.tz_minuteswest,
+						timeptr->tm_isdst > 0));
+#endif /* HAVE_TM_NAME */
+#endif /* HAVE_TM_ZONE */
+#endif /* HAVE_TZNAME */
+			break;
+
+#ifdef SYSV_EXT
+		case 'n':	/* same as \n */
+			tbuf[0] = '\n';
+			tbuf[1] = '\0';
+			break;
+
+		case 't':	/* same as \t */
+			tbuf[0] = '\t';
+			tbuf[1] = '\0';
+			break;
+
+		case 'D':	/* date as %m/%d/%y */
+			strftime(tbuf, sizeof tbuf, "%m/%d/%y", timeptr);
+			break;
+
+		case 'e':	/* day of month, blank padded */
+			sprintf(tbuf, "%2d", range(1, timeptr->tm_mday, 31));
+			break;
+
+		case 'r':	/* time as %I:%M:%S %p */
+			strftime(tbuf, sizeof tbuf, "%I:%M:%S %p", timeptr);
+			break;
+
+		case 'R':	/* time as %H:%M */
+			strftime(tbuf, sizeof tbuf, "%H:%M", timeptr);
+			break;
+
+		case 'T':	/* time as %H:%M:%S */
+			strftime(tbuf, sizeof tbuf, "%H:%M:%S", timeptr);
+			break;
+#endif
+
+#ifdef SUNOS_EXT
+		case 'k':	/* hour, 24-hour clock, blank pad */
+			sprintf(tbuf, "%2d", range(0, timeptr->tm_hour, 23));
+			break;
+
+		case 'l':	/* hour, 12-hour clock, 1 - 12, blank pad */
+			i = range(0, timeptr->tm_hour, 23);
+			if (i == 0)
+				i = 12;
+			else if (i > 12)
+				i -= 12;
+			sprintf(tbuf, "%2d", i);
+			break;
+#endif
+
+
+#ifdef VMS_EXT
+		case 'v':	/* date as dd-bbb-YYYY */
+			sprintf(tbuf, "%02d-%3.3s-%4d",
+				range(1, timeptr->tm_mday, 31),
+				months_a[range(0, timeptr->tm_mon, 11)],
+				timeptr->tm_year + 1900);
+			for (i = 3; i < 6; i++)
+				if (islower(tbuf[i]))
+					tbuf[i] = toupper(tbuf[i]);
+			break;
+#endif
+
+
+#ifdef POSIX2_DATE
+		case 'C':
+			sprintf(tbuf, "%02d", (timeptr->tm_year + 1900) / 100);
+			break;
+
+
+		case 'E':
+		case 'O':
+			/* POSIX locale extensions, ignored for now */
+			goto again;
+
+		case 'V':	/* week of year according ISO 8601 */
+			sprintf(tbuf, "%02d", iso8601wknum(timeptr));
+			break;
+
+		case 'u':
+		/* ISO 8601: Weekday as a decimal number [1 (Monday) - 7] */
+			sprintf(tbuf, "%d", timeptr->tm_wday == 0 ? 7 :
+					timeptr->tm_wday);
+			break;
+#endif	/* POSIX2_DATE */
+
+#ifdef ISO_DATE_EXT
+		case 'G':
+		case 'g':
+			/*
+			 * Year of ISO week.
+			 *
+			 * If it's December but the ISO week number is one,
+			 * that week is in next year.
+			 * If it's January but the ISO week number is 52 or
+			 * 53, that week is in last year.
+			 * Otherwise, it's this year.
+			 */
+			w = iso8601wknum(timeptr);
+			if (timeptr->tm_mon == 11 && w == 1)
+				y = 1900 + timeptr->tm_year + 1;
+			else if (timeptr->tm_mon == 0 && w >= 52)
+				y = 1900 + timeptr->tm_year - 1;
+			else
+				y = 1900 + timeptr->tm_year;
+
+			if (*format == 'G')
+				sprintf(tbuf, "%d", y);
+			else
+				sprintf(tbuf, "%02d", y % 100);
+			break;
+#endif ISO_DATE_EXT
+		default:
+			tbuf[0] = '%';
+			tbuf[1] = *format;
+			tbuf[2] = '\0';
+			break;
+		}
+		i = strlen(tbuf);
+		if (i) {
+			if (s + i < endp - 1) {
+				strcpy(s, tbuf);
+				s += i;
+			} else
+				return 0;
+		}
+	}
+out:
+	if (s < endp && *format == '\0') {
+		*s = '\0';
+		return (s - start);
+	} else
+		return 0;
+}
+
+/* isleap --- is a year a leap year? */
+
+#ifndef __STDC__
+static int
+isleap(year)
+int year;
+#else
+static int
+isleap(int year)
+#endif
+{
+	return ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0);
+}
+
+
+#ifdef POSIX2_DATE
+/* iso8601wknum --- compute week number according to ISO 8601 */
+
+#ifndef __STDC__
+static int
+iso8601wknum(timeptr)
+const struct tm *timeptr;
+#else
+static int
+iso8601wknum(const struct tm *timeptr)
+#endif
+{
+	/*
+	 * From 1003.2:
+	 *	If the week (Monday to Sunday) containing January 1
+	 *	has four or more days in the new year, then it is week 1;
+	 *	otherwise it is the highest numbered week of the previous
+	 *	year (52 or 53), and the next week is week 1.
+	 *
+	 * ADR: This means if Jan 1 was Monday through Thursday,
+	 *	it was week 1, otherwise week 52 or 53.
+	 *
+	 * XPG4 erroneously included POSIX.2 rationale text in the
+	 * main body of the standard. Thus it requires week 53.
+	 */
+
+	int weeknum, jan1day, diff;
+
+	/* get week number, Monday as first day of the week */
+	weeknum = weeknumber(timeptr, 1);
+
+	/*
+	 * With thanks and tip of the hatlo to tml@tik.vtt.fi
+	 *
+	 * What day of the week does January 1 fall on?
+	 * We know that
+	 *	(timeptr->tm_yday - jan1.tm_yday) MOD 7 ==
+	 *		(timeptr->tm_wday - jan1.tm_wday) MOD 7
+	 * and that
+	 * 	jan1.tm_yday == 0
+	 * and that
+	 * 	timeptr->tm_wday MOD 7 == timeptr->tm_wday
+	 * from which it follows that. . .
+ 	 */
+	jan1day = timeptr->tm_wday - (timeptr->tm_yday % 7);
+	if (jan1day < 0)
+		jan1day += 7;
+
+	/*
+	 * If Jan 1 was a Monday through Thursday, it was in
+	 * week 1.  Otherwise it was last year's highest week, which is
+	 * this year's week 0.
+	 *
+	 * What does that mean?
+	 * If Jan 1 was Monday, the week number is exactly right, it can
+	 *	never be 0.
+	 * If it was Tuesday through Thursday, the weeknumber is one
+	 *	less than it should be, so we add one.
+	 * Otherwise, Friday, Saturday or Sunday, the week number is
+	 * OK, but if it is 0, it needs to be 52 or 53.
+	 */
+	switch (jan1day) {
+	case 1:		/* Monday */
+		break;
+	case 2:		/* Tuesday */
+	case 3:		/* Wednesday */
+	case 4:		/* Thursday */
+		weeknum++;
+		break;
+	case 5:		/* Friday */
+	case 6:		/* Saturday */
+	case 0:		/* Sunday */
+		if (weeknum == 0) {
+#ifdef USE_BROKEN_XPG4
+			/* XPG4 (as of March 1994) says 53 unconditionally */
+			weeknum = 53;
+#else
+			/* get week number of last week of last year */
+			struct tm dec31ly;	/* 12/31 last year */
+			dec31ly = *timeptr;
+			dec31ly.tm_year--;
+			dec31ly.tm_mon = 11;
+			dec31ly.tm_mday = 31;
+			dec31ly.tm_wday = (jan1day == 0) ? 6 : jan1day - 1;
+			dec31ly.tm_yday = 364 + isleap(dec31ly.tm_year + 1900);
+			weeknum = iso8601wknum(& dec31ly);
+#endif
+		}
+		break;
+	}
+
+	if (timeptr->tm_mon == 11) {
+		/*
+		 * The last week of the year
+		 * can be in week 1 of next year.
+		 * Sigh.
+		 *
+		 * This can only happen if
+		 *	M   T  W
+		 *	29  30 31
+		 *	30  31
+		 *	31
+		 */
+		int wday, mday;
+
+		wday = timeptr->tm_wday;
+		mday = timeptr->tm_mday;
+		if (   (wday == 1 && (mday >= 29 && mday <= 31))
+		    || (wday == 2 && (mday == 30 || mday == 31))
+		    || (wday == 3 &&  mday == 31))
+			weeknum = 1;
+	}
+
+	return weeknum;
+}
+#endif
+
+/* weeknumber --- figure how many weeks into the year */
+
+/* With thanks and tip of the hatlo to ado@elsie.nci.nih.gov */
+
+#ifndef __STDC__
+static int
+weeknumber(timeptr, firstweekday)
+const struct tm *timeptr;
+int firstweekday;
+#else
+static int
+weeknumber(const struct tm *timeptr, int firstweekday)
+#endif
+{
+	int wday = timeptr->tm_wday;
+	int ret;
+
+	if (firstweekday == 1) {
+		if (wday == 0)	/* sunday */
+			wday = 6;
+		else
+			wday--;
+	}
+	ret = ((timeptr->tm_yday + 7 - wday) / 7);
+	if (ret < 0)
+		ret = 0;
+	return ret;
+}
+
+#if 0
+/* ADR --- I'm loathe to mess with ado's code ... */
+
+Date:         Wed, 24 Apr 91 20:54:08 MDT
+From: Michal Jaegermann <audfax!emory!vm.ucs.UAlberta.CA!NTOMCZAK>
+To: arnold@audiofax.com
+
+Hi Arnold,
+in a process of fixing of strftime() in libraries on Atari ST I grabbed
+some pieces of code from your own strftime.  When doing that it came
+to mind that your weeknumber() function compiles a little bit nicer
+in the following form:
+/*
+ * firstweekday is 0 if starting in Sunday, non-zero if in Monday
+ */
+{
+    return (timeptr->tm_yday - timeptr->tm_wday +
+	    (firstweekday ? (timeptr->tm_wday ? 8 : 1) : 7)) / 7;
+}
+How nicer it depends on a compiler, of course, but always a tiny bit.
+
+   Cheers,
+   Michal
+   ntomczak@vm.ucs.ualberta.ca
+#endif
+
+#ifdef	TEST_STRFTIME
+
+/*
+ * NAME:
+ *	tst
+ *
+ * SYNOPSIS:
+ *	tst
+ *
+ * DESCRIPTION:
+ *	"tst" is a test driver for the function "strftime".
+ *
+ * OPTIONS:
+ *	None.
+ *
+ * AUTHOR:
+ *	Karl Vogel
+ *	Control Data Systems, Inc.
+ *	vogelke@c-17igp.wpafb.af.mil
+ *
+ * BUGS:
+ *	None noticed yet.
+ *
+ * COMPILE:
+ *	cc -o tst -DTEST_STRFTIME strftime.c
+ */
+
+/* ADR: I reformatted this to my liking, and deleted some unneeded code. */
+
+#ifndef NULL
+#include	<stdio.h>
+#endif
+#include	<sys/time.h>
+#include	<string.h>
+
+#define		MAXTIME		132
+
+/*
+ * Array of time formats.
+ */
+
+static char *array[] =
+{
+	"(%%A)      full weekday name, var length (Sunday..Saturday)  %A",
+	"(%%B)       full month name, var length (January..December)  %B",
+	"(%%C)                                               Century  %C",
+	"(%%D)                                       date (%%m/%%d/%%y)  %D",
+	"(%%E)                           Locale extensions (ignored)  %E",
+	"(%%H)                          hour (24-hour clock, 00..23)  %H",
+	"(%%I)                          hour (12-hour clock, 01..12)  %I",
+	"(%%M)                                       minute (00..59)  %M",
+	"(%%O)                           Locale extensions (ignored)  %O",
+	"(%%R)                                 time, 24-hour (%%H:%%M)  %R",
+	"(%%S)                                       second (00..61)  %S",
+	"(%%T)                              time, 24-hour (%%H:%%M:%%S)  %T",
+	"(%%U)    week of year, Sunday as first day of week (00..53)  %U",
+	"(%%V)                    week of year according to ISO 8601  %V",
+	"(%%W)    week of year, Monday as first day of week (00..53)  %W",
+	"(%%X)     appropriate locale time representation (%H:%M:%S)  %X",
+	"(%%Y)                           year with century (1970...)  %Y",
+	"(%%Z) timezone (EDT), or blank if timezone not determinable  %Z",
+	"(%%a)          locale's abbreviated weekday name (Sun..Sat)  %a",
+	"(%%b)            locale's abbreviated month name (Jan..Dec)  %b",
+	"(%%c)           full date (Sat Nov  4 12:02:33 1989)%n%t%t%t  %c",
+	"(%%d)                             day of the month (01..31)  %d",
+	"(%%e)               day of the month, blank-padded ( 1..31)  %e",
+	"(%%h)                                should be same as (%%b)  %h",
+	"(%%j)                            day of the year (001..366)  %j",
+	"(%%k)               hour, 24-hour clock, blank pad ( 0..23)  %k",
+	"(%%l)               hour, 12-hour clock, blank pad ( 0..12)  %l",
+	"(%%m)                                        month (01..12)  %m",
+	"(%%p)              locale's AM or PM based on 12-hour clock  %p",
+	"(%%r)                   time, 12-hour (same as %%I:%%M:%%S %%p)  %r",
+	"(%%u) ISO 8601: Weekday as decimal number [1 (Monday) - 7]   %u",
+	"(%%v)                                VMS date (dd-bbb-YYYY)  %v",
+	"(%%w)                       day of week (0..6, Sunday == 0)  %w",
+	"(%%x)                appropriate locale date representation  %x",
+	"(%%y)                      last two digits of year (00..99)  %y",
+	"(%%z)      timezone offset east of GMT as HHMM (e.g. -0500)  %z",
+	(char *) NULL
+};
+
+/* main routine. */
+
+int
+main(argc, argv)
+int argc;
+char **argv;
+{
+	long time();
+
+	char *next;
+	char string[MAXTIME];
+
+	int k;
+	int length;
+
+	struct tm *tm;
+
+	long clock;
+
+	/* Call the function. */
+
+	clock = time((long *) 0);
+	tm = localtime(&clock);
+
+	for (k = 0; next = array[k]; k++) {
+		length = strftime(string, MAXTIME, next, tm);
+		printf("%s\n", string);
+	}
+
+	exit(0);
+}
+#endif	/* TEST_STRFTIME */
diff --git a/missing/strstr.c b/missing/strstr.c
new file mode 100644
index 0000000000..c54349983e
--- /dev/null
+++ b/missing/strstr.c
@@ -0,0 +1,73 @@
+/* 
+ * strstr.c --
+ *
+ *	Source code for the "strstr" library routine.
+ *
+ * Copyright 1988-1991 Regents of the University of California
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appears in all copies.  The University of California
+ * makes no representations about the suitability of this
+ * software for any purpose.  It is provided "as is" without
+ * express or implied warranty.
+ */
+
+#ifndef lint
+static char rcsid[] = "$Header$ SPRITE (Berkeley)";
+#endif /* not lint */
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * strstr --
+ *
+ *	Locate the first instance of a substring in a string.
+ *
+ * Results:
+ *	If string contains substring, the return value is the
+ *	location of the first matching instance of substring
+ *	in string.  If string doesn't contain substring, the
+ *	return value is 0.  Matching is done on an exact
+ *	character-for-character basis with no wildcards or special
+ *	characters.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+char *
+strstr(string, substring)
+    register char *string;	/* String to search. */
+    char *substring;		/* Substring to try to find in string. */
+{
+    register char *a, *b;
+
+    /* First scan quickly through the two strings looking for a
+     * single-character match.  When it's found, then compare the
+     * rest of the substring.
+     */
+
+    b = substring;
+    if (*b == 0) {
+	return string;
+    }
+    for ( ; *string != 0; string += 1) {
+	if (*string != *b) {
+	    continue;
+	}
+	a = string;
+	while (1) {
+	    if (*b == 0) {
+		return string;
+	    }
+	    if (*a++ != *b++) {
+		break;
+	    }
+	}
+	b = substring;
+    }
+    return (char *) 0;
+}
diff --git a/missing/strtol.c b/missing/strtol.c
new file mode 100644
index 0000000000..4941f43b91
--- /dev/null
+++ b/missing/strtol.c
@@ -0,0 +1,84 @@
+/* 
+ * strtol.c --
+ *
+ *	Source code for the "strtol" library procedure.
+ *
+ * Copyright 1988 Regents of the University of California
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies.  The University of California
+ * makes no representations about the suitability of this
+ * software for any purpose.  It is provided "as is" without
+ * express or implied warranty.
+ */
+
+#include <ctype.h>
+
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * strtol --
+ *
+ *	Convert an ASCII string into an integer.
+ *
+ * Results:
+ *	The return value is the integer equivalent of string.  If endPtr
+ *	is non-NULL, then *endPtr is filled in with the character
+ *	after the last one that was part of the integer.  If string
+ *	doesn't contain a valid integer value, then zero is returned
+ *	and *endPtr is set to string.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+long int
+strtol(string, endPtr, base)
+    char *string;		/* String of ASCII digits, possibly
+				 * preceded by white space.  For bases
+				 * greater than 10, either lower- or
+				 * upper-case digits may be used.
+				 */
+    char **endPtr;		/* Where to store address of terminating
+				 * character, or NULL. */
+    int base;			/* Base for conversion.  Must be less
+				 * than 37.  If 0, then the base is chosen
+				 * from the leading characters of string:
+				 * "0x" means hex, "0" means octal, anything
+				 * else means decimal.
+				 */
+{
+    register char *p;
+    int result;
+
+    /*
+     * Skip any leading blanks.
+     */
+
+    p = string;
+    while (isspace(*p)) {
+	p += 1;
+    }
+
+    /*
+     * Check for a sign.
+     */
+
+    if (*p == '-') {
+	p += 1;
+	result = -(strtoul(p, endPtr, base));
+    } else {
+	if (*p == '+') {
+	    p += 1;
+	}
+	result = strtoul(p, endPtr, base);
+    }
+    if ((result == 0) && (endPtr != 0) && (*endPtr == p)) {
+	*endPtr = string;
+    }
+    return result;
+}
diff --git a/missing/strtoul.c b/missing/strtoul.c
new file mode 100644
index 0000000000..f16f2ad9cf
--- /dev/null
+++ b/missing/strtoul.c
@@ -0,0 +1,184 @@
+/* 
+ * strtoul.c --
+ *
+ *	Source code for the "strtoul" library procedure.
+ *
+ * Copyright 1988 Regents of the University of California
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies.  The University of California
+ * makes no representations about the suitability of this
+ * software for any purpose.  It is provided "as is" without
+ * express or implied warranty.
+ */
+
+#include <ctype.h>
+
+/*
+ * The table below is used to convert from ASCII digits to a
+ * numerical equivalent.  It maps from '0' through 'z' to integers
+ * (100 for non-digit characters).
+ */
+
+static char cvtIn[] = {
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9,		/* '0' - '9' */
+    100, 100, 100, 100, 100, 100, 100,		/* punctuation */
+    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,	/* 'A' - 'Z' */
+    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+    30, 31, 32, 33, 34, 35,
+    100, 100, 100, 100, 100, 100,		/* punctuation */
+    10, 11, 12, 13, 14, 15, 16, 17, 18, 19,	/* 'a' - 'z' */
+    20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+    30, 31, 32, 33, 34, 35};
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * strtoul --
+ *
+ *	Convert an ASCII string into an integer.
+ *
+ * Results:
+ *	The return value is the integer equivalent of string.  If endPtr
+ *	is non-NULL, then *endPtr is filled in with the character
+ *	after the last one that was part of the integer.  If string
+ *	doesn't contain a valid integer value, then zero is returned
+ *	and *endPtr is set to string.
+ *
+ * Side effects:
+ *	None.
+ *
+ *----------------------------------------------------------------------
+ */
+
+unsigned long int
+strtoul(string, endPtr, base)
+    char *string;		/* String of ASCII digits, possibly
+				 * preceded by white space.  For bases
+				 * greater than 10, either lower- or
+				 * upper-case digits may be used.
+				 */
+    char **endPtr;		/* Where to store address of terminating
+				 * character, or NULL. */
+    int base;			/* Base for conversion.  Must be less
+				 * than 37.  If 0, then the base is chosen
+				 * from the leading characters of string:
+				 * "0x" means hex, "0" means octal, anything
+				 * else means decimal.
+				 */
+{
+    register char *p;
+    register unsigned long int result = 0;
+    register unsigned digit;
+    int anyDigits = 0;
+
+    /*
+     * Skip any leading blanks.
+     */
+
+    p = string;
+    while (isspace(*p)) {
+	p += 1;
+    }
+
+    /*
+     * If no base was provided, pick one from the leading characters
+     * of the string.
+     */
+    
+    if (base == 0)
+    {
+	if (*p == '0') {
+	    p += 1;
+	    if (*p == 'x') {
+		p += 1;
+		base = 16;
+	    } else {
+
+		/*
+		 * Must set anyDigits here, otherwise "0" produces a
+		 * "no digits" error.
+		 */
+
+		anyDigits = 1;
+		base = 8;
+	    }
+	}
+	else base = 10;
+    } else if (base == 16) {
+
+	/*
+	 * Skip a leading "0x" from hex numbers.
+	 */
+
+	if ((p[0] == '0') && (p[1] == 'x')) {
+	    p += 2;
+	}
+    }
+
+    /*
+     * Sorry this code is so messy, but speed seems important.  Do
+     * different things for base 8, 10, 16, and other.
+     */
+
+    if (base == 8) {
+	for ( ; ; p += 1) {
+	    digit = *p - '0';
+	    if (digit > 7) {
+		break;
+	    }
+	    result = (result << 3) + digit;
+	    anyDigits = 1;
+	}
+    } else if (base == 10) {
+	for ( ; ; p += 1) {
+	    digit = *p - '0';
+	    if (digit > 9) {
+		break;
+	    }
+	    result = (10*result) + digit;
+	    anyDigits = 1;
+	}
+    } else if (base == 16) {
+	for ( ; ; p += 1) {
+	    digit = *p - '0';
+	    if (digit > ('z' - '0')) {
+		break;
+	    }
+	    digit = cvtIn[digit];
+	    if (digit > 15) {
+		break;
+	    }
+	    result = (result << 4) + digit;
+	    anyDigits = 1;
+	}
+    } else {
+	for ( ; ; p += 1) {
+	    digit = *p - '0';
+	    if (digit > ('z' - '0')) {
+		break;
+	    }
+	    digit = cvtIn[digit];
+	    if (digit >= base) {
+		break;
+	    }
+	    result = result*base + digit;
+	    anyDigits = 1;
+	}
+    }
+
+    /*
+     * See if there were any digits at all.
+     */
+
+    if (!anyDigits) {
+	p = string;
+    }
+
+    if (endPtr != 0) {
+	*endPtr = p;
+    }
+
+    return result;
+}
diff --git a/missing/x68.c b/missing/x68.c
new file mode 100644
index 0000000000..8fd9c3e879
--- /dev/null
+++ b/missing/x68.c
@@ -0,0 +1,12 @@
+#include "config.h"
+
+#if !HAVE_SELECT
+#include "x68/select.c"
+#endif
+#if MISSING__DTOS18
+#include "x68/_dtos18.c"
+#endif
+#if MISSING_FCONVERT
+#include "x68/_round.c"
+#include "x68/fconvert.c"
+#endif