48 files changed, 6717 insertions, 0 deletions

diff --git a/private/crt32/iostream/cerrinit.cxx b/private/crt32/iostream/cerrinit.cxx
new file mode 100644
index 000000000..5f5d75f5e
--- /dev/null
+++ b/private/crt32/iostream/cerrinit.cxx
@@ -0,0 +1,28 @@
+/***
+*cerrinit.cxx - definitions and initialization for predefined stream cerr.
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions and initialization of predefined stream cerr. 
+*
+*Revision History:
+*	11 18-91   KRS	Created.
+*
+*******************************************************************************/
+#include <cruntime.h>
+#include <internal.h>
+#include <iostream.h>
+#include <fstream.h>
+#pragma hdrstop
+
+// put contructors in special MS-specific XIFM segment
+#pragma warning(disable:4074)	// ignore init_seg warning
+#pragma init_seg(compiler)
+
+#if ((!defined(_WINDOWS)) || defined(_QWIN))
+ostream_withassign cerr(new filebuf(2));
+
+static Iostream_init  __InitCerr(cerr,1);
+
+#endif
diff --git a/private/crt32/iostream/cininit.cxx b/private/crt32/iostream/cininit.cxx
new file mode 100644
index 000000000..7a8c6762d
--- /dev/null
+++ b/private/crt32/iostream/cininit.cxx
@@ -0,0 +1,28 @@
+/***
+*cininit.cxx - definitions and initialization for predefined stream cin.
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions and initialization of predefined stream cin. 
+*
+*Revision History:
+*	11 18-91   KRS	Created.
+*
+*******************************************************************************/
+#include <cruntime.h>
+#include <internal.h>
+#include <iostream.h>
+#include <fstream.h>
+#pragma hdrstop
+
+// put contructors in special MS-specific XIFM segment
+#pragma warning(disable:4074)	// ignore init_seg warning
+#pragma init_seg(compiler)
+
+#if ((!defined(_WINDOWS)) || defined(_QWIN))
+istream_withassign cin(new filebuf(0));
+
+static Iostream_init  __InitCin(cin);
+
+#endif
diff --git a/private/crt32/iostream/cloginit.cxx b/private/crt32/iostream/cloginit.cxx
new file mode 100644
index 000000000..f1f0a064a
--- /dev/null
+++ b/private/crt32/iostream/cloginit.cxx
@@ -0,0 +1,28 @@
+/***
+*cloginit.cxx - definitions and initialization for predefined stream clog.
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions and initialization of predefined stream clog. 
+*
+*Revision History:
+*	11 18-91   KRS	Created.
+*
+*******************************************************************************/
+#include <cruntime.h>
+#include <internal.h>
+#include <iostream.h>
+#include <fstream.h>
+#pragma hdrstop
+
+// put contructors in special MS-specific XIFM segment
+#pragma warning(disable:4074)	// ignore init_seg warning
+#pragma init_seg(compiler)
+
+#if ((!defined(_WINDOWS)) || defined(_QWIN))
+ostream_withassign clog(new filebuf(2));
+
+static Iostream_init  __InitClog(clog);
+
+#endif
diff --git a/private/crt32/iostream/filebuf.cxx b/private/crt32/iostream/filebuf.cxx
new file mode 100644
index 000000000..35980c4bb
--- /dev/null
+++ b/private/crt32/iostream/filebuf.cxx
@@ -0,0 +1,460 @@
+/***
+*filebuf.cxx - core filebuf member functions
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the core member functions for filebuf class.
+*
+*Revision History:
+*	08-08-91   KRS  Created.
+*	08-20-91   KRS  Added virtual xsgetn()/xsputn() functions.
+*	08-21-91   KRS	Fix circular reference between sync() and seekoff().
+*			Close file in destructor only if we opened it!
+*	09-06-91   KRS	Fix ios::ate case in filebuf::open().
+*	09-09-91   KRS	Add support for ios::binary in filebuf::open().
+*	09-10-91   KRS	Remove virtual xsputn()/xsgetn().
+*	09-11-91   KRS	Fix filebuf::seekoff() for ios::cur and in_avail().
+*	09-12-91   KRS	Make sure close() always closes even if sync() fails.
+*			Fix seekoff call in filebuf::sync() and pbackfail().
+*	09-16-91   KRS	Make virtual filebuf::setbuf() more robust.
+*	09-19-91   KRS	Add calls to delbuf(1) in constructors.
+*	09-20-91   KRS	C700 #4453: Improve efficiency in overflow().
+*	09-29-91   KRS	Granularity split.  Move fstream into separate file.
+*	10-24-91   KRS	Avoid virtual calls from virtual functions.
+*	11-13-91   KRS	Use allocate() properly in overflow() and underflow().
+*			Fix constructor.
+*	01-03-92   KRS	Remove virtual keyword.  Add function headers and PCH.
+*	01-20-92   KRS	In text mode, account for CR/LF pairs in sync().
+*	02-03-92   KRS	Change for new compiler destructor behavior.
+*	08-19-92   KRS	Remove sh_compat for NT.
+*	08-27-92   KRS	Fix bug in close() introduced in MTHREAD work.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <string.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <sys\types.h>
+#include <io.h>
+#include <fstream.h>
+#pragma hdrstop
+
+#include <msdos.h>
+#include <sys\stat.h>
+
+const int filebuf::openprot	= 0644;	// CONSIDER: meaning?
+
+const int filebuf::sh_none	= 04000;	// deny rw
+const int filebuf::sh_read	= 05000;	// deny wr
+const int filebuf::sh_write	= 06000;	// deny rd
+
+const int filebuf::binary	= O_BINARY;
+const int filebuf::text		= O_TEXT;
+
+/***
+*filebuf::filebuf() - filebuf default constructor
+*
+*Purpose:
+*	Default constructor.
+*
+*Entry:
+*
+*******************************************************************************/
+	filebuf::filebuf()
+: streambuf()
+{
+    x_fOpened = 0;
+    x_fd = -1;
+}
+
+
+/***
+*filebuf::filebuf(filedesc fd) - filebuf constructor
+*
+*Purpose:
+*	Constructor.  Initialize filebuf and attach to file descriptor.
+*
+*Entry:
+*	fd = file descriptor to attach to filebuf
+*
+*******************************************************************************/
+	filebuf::filebuf(filedesc fd)
+: streambuf()
+{
+    x_fOpened = 0;
+    x_fd=fd;
+}
+
+
+/***
+*filebuf::filebuf(filedesc fd, char* p, int len) - filebuf constructor
+*
+*Purpose:
+*	Constructor.  Initialize filebuf and attach to file descriptor.
+*
+*Entry:
+*	fd  = file descriptor to attach to filebuf
+*	p   = user-supplied buffer
+*	len = length of buffer
+*
+*******************************************************************************/
+	filebuf::filebuf(filedesc fd, char* p, int len)
+:    streambuf()
+{
+    filebuf::setbuf(p,len);
+    x_fOpened = 0;
+    x_fd=fd;
+}
+
+
+/***
+*filebuf::~filebuf() - filebuf destructor
+*
+*Purpose:
+*	Destructor.  Close attached file only if we opened it.
+*
+*Entry:
+*	None.
+*
+*******************************************************************************/
+	filebuf::~filebuf()
+{
+	lock(); 	// no need to unlock...
+	if (x_fOpened)
+	    close();	// calls filebuf::sync()
+	else
+	    filebuf::sync();
+}
+
+
+/***
+*filebuf* filebuf::close() - close an attached file
+*
+*Purpose:
+*	Close attached file.
+*
+*Entry:
+*	None.
+*Exit:
+*	Returns NULL if error, otherwise returns "this" pointer.
+*
+*******************************************************************************/
+filebuf* filebuf::close()
+{
+    int retval;
+    if (x_fd==-1)
+	return NULL;
+
+    lock();
+    retval = sync();
+
+    if ((_close(x_fd)==-1) || (retval==EOF))
+	{
+	unlock();
+	return NULL;
+	}
+    x_fd = -1;
+    unlock();
+    return this;
+}
+
+/***
+*virtual int filebuf::overflow(int c) - overflow virtual function
+*
+*Purpose:
+*	flush any characters in the reserve area and handle 'c'.
+*
+*Entry:
+*	c = character to output (if not EOF)
+*
+*Exit:
+*	Returns EOF if error, otherwise returns something else.
+*
+*Exceptions:
+*	Returns EOF if error.
+*
+*******************************************************************************/
+int filebuf::overflow(int c)
+{
+    if (allocate()==EOF)	// make sure there is a reserve area
+	return EOF;
+    if (filebuf::sync()==EOF) // sync before new buffer created below
+	return EOF;
+
+    if (!unbuffered())
+	setp(base(),ebuf());
+
+    if (c!=EOF)
+	{
+	if ((!unbuffered()) && (pptr() < epptr())) // guard against recursion
+	    sputc(c);
+	else
+	    {
+	    if (_write(x_fd,&c,1)!=1)
+		return(EOF);
+	    }
+	}
+    return(1);	// return something other than EOF if successful
+}
+
+/***
+*virtual int filebuf::underflow() - underflow virtual function
+*
+*Purpose:
+*	return next character in get area, or get more characters from source.
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	Returns current character in file.  Does not advance get pointer.
+*
+*Exceptions:
+*	Returns EOF if error.
+*
+*******************************************************************************/
+int filebuf::underflow()
+{
+    int count;
+    unsigned char tbuf;
+
+    if (in_avail())
+	return (int)(unsigned char) *gptr();
+
+    if (allocate()==EOF)	// make sure there is a reserve area
+	return EOF;
+    if (filebuf::sync()==EOF)
+	return EOF;
+
+    if (unbuffered())
+	{
+	if (_read(x_fd,(void *)&tbuf,1)<=0)
+	    return EOF;
+	return (int)tbuf;
+	}
+
+    if ((count=_read(x_fd,(void *)base(),blen())) <= 0)
+	return EOF;	// reached EOF
+    setg(base(),base(),base()+count);
+    return (int)(unsigned char) *gptr(); // CONSIDER: possible recursion
+}
+
+
+/***
+*virtual streampos filebuf::seekoff() - seekoff virtual function
+*
+*Purpose:
+*	Seeks to given absolute or relative file offset.
+*
+*Entry:
+*	off = offset to seek to relative to beginning, end or current
+*		position in the file.
+*	dir = one of ios::beg, ios::cur, or ios::end
+*
+*Exit:
+*	Returns current file position after seek.
+*
+*Exceptions:
+*	Returns EOF if error.
+*
+*******************************************************************************/
+streampos filebuf::seekoff(streamoff off, ios::seek_dir dir, int)
+{
+
+    int fdir;
+    long retpos;
+    switch (dir) {
+	case ios::beg :
+	    fdir = SEEK_SET;
+	    break;
+	case ios::cur :
+	    fdir = SEEK_CUR;
+	    break;
+	case ios::end :
+	    fdir = SEEK_END;
+	    break;
+	default:
+	// error
+	    return(EOF);
+	}
+		
+    if (filebuf::sync()==EOF)
+	return EOF;
+    if ((retpos=_lseek(x_fd, off, fdir))==-1L)
+	return (EOF);
+    return((streampos)retpos);
+}
+
+/*  NOT IN SPEC.
+int filebuf::pbackfail(int c)
+{
+    if (eback()<gptr()) return sputbackc(c); // CONSIDER: should never happen
+
+    if (filebuf::seekoff( -1, ios::cur, ios::in)==EOF)
+	return EOF;
+    if (!unbuffered())
+	filebuf::underflow();
+	// assert c = underflow()
+	}
+    return(c);
+}
+*/
+
+#if 0
+// NOT IN SPEC.
+// UNDONE: consider removing this?
+int filebuf::xsgetn(char * ptr, int n)
+{
+    int retval;
+    int oldmode;
+
+    if (x_fd==-1)
+	return 0;
+    if (filebuf::sync()!=EOF)
+	{
+	// set to BINARY and save old mode.
+	oldmode = _setmode(x_fd,O_BINARY);
+	}
+    retval = sgetn(ptr,n);
+    filebuf::sync();	// put back any excess (ignore errors)
+
+    if (oldmode==O_TEXT)	// check != -1
+	{
+	_setmode(x_fd,oldmode);
+	}
+    return retval;
+}
+
+// NOT IN SPEC.
+// UNDONE: consider removing this?
+int filebuf::xsputn(const char * ptr, int n)
+{
+    int retval;
+    int oldmode;
+
+    if (x_fd==-1)
+	return 0;
+    if (filebuf::sync()!=EOF)
+	{
+	// set to BINARY and save old mode.
+	oldmode = _setmode(x_fd,O_BINARY);
+	}
+
+    retval = sputn(ptr,n);
+    filebuf::sync();	// flush output;
+
+    if (oldmode==O_TEXT)	// check != -1
+	{
+	_setmode(x_fd,oldmode);
+	}
+    return retval;
+}
+#endif
+
+
+/***
+*virtual int filebuf::sync() - synchronize buffers with external file postion.
+*
+*Purpose:
+*	Synchronizes buffer with external file, by flushing any output and/or
+*	discarding any unread input data.  Discards any get or put area(s).
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	Returns EOF if error, else 0.
+*
+*Exceptions:
+*	Returns EOF if error.
+*
+*******************************************************************************/
+int filebuf::sync()
+{
+    long count, nout;
+    char * p;
+    if (x_fd==-1)
+	return(EOF);
+//  lock();		// CONSIDER: do we need/want locking here?
+    if (!unbuffered())
+	{
+	if ((count=out_waiting())!=0)
+	    {
+	    if ((nout =_write(x_fd,(void *) pbase(),(unsigned int)count)) != count)
+		{
+		// should set _pptr -= nout
+		pbump(-(int)nout);
+		memmove(pbase(), pbase()+nout, (int)(count-nout));
+//		unlock();
+		return(EOF);
+		}
+	    }
+	setp(0,0); // empty put area
+
+	if ((count=in_avail()) > 0)
+	    {
+	    // can't use seekoff here!!
+	    if (_osfile[x_fd] & FTEXT)
+		{
+	        // If text mode, need to account for CR/LF etc.
+		for (p = gptr(); p < egptr(); p++)
+		    if (*p == '\n')
+			count++;
+
+		// account for EOF if read, not counted by _read
+		// UNDONE: is this necessary / useful?
+		if ((_osfile[x_fd] & FEOFLAG))
+		    count++;
+#if 0
+		// UNDONE: is this correct?
+		if ((gptr()==eback()) && (_osfile[x_fd] & FCRLF))
+		    count--;
+#endif
+		}
+    	    if (_lseek(x_fd, -count, SEEK_CUR)==-1L)
+		{
+//		unlock();
+		return (EOF);
+		}
+	    }
+	setg(0,0,0); // empty get area
+	}
+//  unlock();
+    return(0);
+}
+
+/***
+*virtual streambuf* filebuf::setbuf(char* ptr, int len) - set reserve area.
+*
+*Purpose:
+*	Synchronizes buffer with external file, by flushing any output and/or
+*	discarding any unread input data.  Discards any get or put area(s).
+*
+*Entry:
+*	ptr = requested reserve area.  If NULL, request is for unbuffered.
+*	len = size of reserve area.  If <= 0, request is for unbuffered.
+*
+*Exit:
+*	Returns this pointer if request is honored, else NULL.
+*
+*Exceptions:
+*	Returns NULL if request is not honored.
+*
+*******************************************************************************/
+streambuf * filebuf::setbuf(char * ptr, int len)
+{
+    if (is_open() && (ebuf()))
+	return NULL;
+    if ((!ptr) || (len <= 0))
+	unbuffered(1);
+    else
+	{
+	lock();	// consider: necessary?
+	setb(ptr, ptr+len, 0);
+	unlock();
+	}
+    return this;
+}
diff --git a/private/crt32/iostream/filebuf1.cxx b/private/crt32/iostream/filebuf1.cxx
new file mode 100644
index 000000000..6079d69e2
--- /dev/null
+++ b/private/crt32/iostream/filebuf1.cxx
@@ -0,0 +1,231 @@
+/***
+*filebuf1.cxx - non-core filebuf member functions.
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains optional member functions for filebuf class.
+*
+*Revision History:
+*	09-21-91  KRS	Created.  Split off from fstream.cxx.
+*	10-24-91  KRS	C700 #4909: Typo/logic bug in setmode().
+*	11-06-91  KRS	Add support for share mode in open().  Use _sopen().
+*	08-19-92  KRS	Use _SH_DENYNO for default mode for NT.
+*	03-02-93  SKS	Avoid setting _O_TRUNC when noreplace is specified
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <share.h>
+#include <sys\types.h>
+#include <io.h>
+#include <fstream.h>
+#pragma hdrstop
+
+#include <sys\stat.h>
+
+/***
+*filebuf* filebuf::attach(filedesc fd) - filebuf attach function
+*
+*Purpose:
+*	filebuf attach() member function.  Attach filebuf object to the
+*	given file descriptor previously obtained from _open() or _sopen().
+*
+*Entry:
+*	fd = file descriptor.
+*
+*Exit:
+*	Returns this pointer or NULL if error.
+*
+*Exceptions:
+*	Returns NULL if fd = -1.
+*
+*******************************************************************************/
+filebuf* filebuf::attach(filedesc fd)
+{
+    if (x_fd!=-1)
+	return NULL;	// error if already attached
+
+    lock();
+    x_fd = fd;
+    if ((fd!=-1) && (!unbuffered()) && (!ebuf()))
+	{
+        char * sbuf = new char[BUFSIZ];
+	if (!sbuf)
+	    {
+	    unbuffered(1);
+	    }
+	else
+	    {
+	    streambuf::setb(sbuf,sbuf+BUFSIZ,1);
+	    }
+	}
+    unlock();
+    return this; 
+}
+
+/***
+*filebuf* filebuf::open(const char* name, int mode, int share) - filebuf open
+*
+*Purpose:
+*	filebuf open() member function.  Open a file and attach to filebuf
+*	object.
+*
+*Entry:
+*	name  = file name string.
+*	mode  = open mode: Combination of ios:: in, out, binary, nocreate, app,
+*		ate, noreplace and trunc.  See spec. for details on behavior.
+*	share = share mode (optional).  sh_compat, sh_none, sh_read, sh_write.
+*
+*Exit:
+*	Returns this pointer or NULL if error.
+*
+*Exceptions:
+*	Returns NULL if filebuf is already attached to an open file, or if
+*	invalid mode options, or if call to _sopen or filebuf::seekoff() fails.
+*
+*******************************************************************************/
+filebuf* filebuf::open(const char* name, int mode, int share)
+{
+    int dos_mode;
+    int smode;
+    if (x_fd!=-1)
+	return NULL;	// error if already open
+// translate mode argument
+    dos_mode = (mode & ios::binary) ? O_BINARY : O_TEXT;
+    if (!(mode & ios::nocreate))
+	dos_mode |= O_CREAT;
+    if (mode & ios::noreplace)
+	dos_mode |= O_EXCL;
+    if (mode & ios::app)
+	{
+	mode |= ios::out;
+	dos_mode |= O_APPEND;
+	}
+    if (mode & ios::trunc)
+	{
+	mode |= ios::out;  // IMPLIED
+	dos_mode |= O_TRUNC;
+	}
+    if (mode & ios::out)
+	{
+	if (mode & ios::in)
+	    {
+	    dos_mode |= O_RDWR;
+	    }
+	else
+	    {
+	    dos_mode |= O_WRONLY;
+	    }
+	// CONSIDER: a bit weaker  treatment than in spec.
+	if (!(mode & (ios::in|ios::app|ios::ate|ios::noreplace)))
+	    {
+	    mode |= ios::trunc;	// IMPLIED
+	    dos_mode |= O_TRUNC;
+	    }
+	}
+    else if (mode & ios::in)
+	dos_mode |= O_RDONLY;
+    else
+	return NULL;	// error if not ios:in or ios::out
+
+    smode = _SH_DENYNO;	// default for NT
+    share &= (sh_read|sh_write|sh_none); // ignore other bits
+    if (share)	// optimization  openprot serves as default
+	{
+	switch (share)
+	    {
+/*	    case 03000 : Reserved for sh_compat  */
+
+//	    case sh_none : 
+	    case 04000 : 
+		smode = _SH_DENYRW;
+		break;
+//	    case sh_read : 
+	    case 05000 : 
+		smode = _SH_DENYWR;
+		break;
+//	    case sh_write : 
+	    case 06000 : 
+		smode = _SH_DENYRD;
+		break;
+//	    case (sh_read|sh_write) :
+	    case 07000 :
+		smode = _SH_DENYNO;
+		break;
+	    default :	// unrecognized value same as default
+		break;
+	    };
+	}
+
+    x_fd = _sopen(name, dos_mode, smode, S_IREAD|S_IWRITE);
+    if (x_fd==-1)
+	return NULL;
+    lock();
+    x_fOpened = 1;
+    if ((!unbuffered()) && (!ebuf()))
+	{
+        char * sbuf = new char[BUFSIZ];
+	if (!sbuf)
+	    {
+	    unbuffered(1);
+	    }
+	else
+	    {
+	    streambuf::setb(sbuf,sbuf+BUFSIZ,1);
+	    }
+	}
+    if (mode & ios::ate)
+	if (seekoff(0,ios::end,mode)==EOF)
+	    {
+	    close();
+	    unlock();
+	    return NULL;
+	    }
+    unlock();
+    return this;
+}
+
+/***
+*int filebuf::setmode(int mode) - filebuf setmode function
+*
+*Purpose:
+*	filebuf setmode() member function.  Set binary or text access mode.
+*	Calls _setmode().
+*
+*	MS-specific extension.
+*
+*Entry:
+*	mode = filebuf::binary or filebuf::text.
+*
+*Exit:
+*	Returns previous mode, or -1 error.
+*
+*Exceptions:
+*	Return -1 (EOF) if invalid argument or _setmode fails.
+*
+*******************************************************************************/
+int filebuf::setmode(int mode)
+{
+    int retval;
+    if ((mode!=filebuf::binary) && (mode!=filebuf::text))
+	return -1;
+
+    lock();
+    if ((x_fd==-1) || (sync()==EOF))
+	{
+	retval = -1;
+	}
+    else
+	{
+	retval = _setmode(x_fd,mode);
+	}
+
+    unlock();
+    return retval;
+}
diff --git a/private/crt32/iostream/fstream.cxx b/private/crt32/iostream/fstream.cxx
new file mode 100644
index 000000000..8cecf6c8e
--- /dev/null
+++ b/private/crt32/iostream/fstream.cxx
@@ -0,0 +1,261 @@
+/***
+*fstream.cxx -
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the member functions for the fstream class.
+*
+*Revision History:
+*	09-21-91   KRS  Created.  Split off from filebuf.cxx for granularity.
+*	10-22-91   KRS	C700 #4883: fix error status of fstream::open().
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <string.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <sys\types.h>
+#include <io.h>
+#include <fstream.h>
+#pragma hdrstop
+
+#include <sys\stat.h>
+
+/***
+*fstream::fstream() - fstream default constructor
+*
+*Purpose:
+*	Default constructor for fstream objects.
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*
+*******************************************************************************/
+	fstream::fstream()
+: iostream(new filebuf)
+{
+    istream::delbuf(1);
+    ostream::delbuf(1);
+    // CONSIDER: do anything else?
+}
+
+/***
+*fstream::fstream(const char * name, int mode, int prot) - fstream constructor
+*
+*Purpose:
+*	Constructor for fstream objects.  Creates an associated filebuf object,
+*	opens a named file and attaches it to the new filebuf.
+*
+*Entry:
+*	name = filename to open.
+*	mode = see filebuf::open mode argument
+*	prot = see filebuf::open share argument
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*	Sets failbit if open fails.
+*
+*******************************************************************************/
+	fstream::fstream(const char * name, int mode, int prot)
+: iostream(new filebuf)
+{
+    istream::delbuf(1);
+    ostream::delbuf(1);
+    if (!(rdbuf()->open(name, mode, prot)))
+	{
+	istream::state = istream::failbit;
+	ostream::state = ostream::failbit;
+	}
+}
+
+/***
+*fstream::fstream(filedesc fd) - fstream constructor
+*
+*Purpose:
+*	Constructor for fstream objects.  Creates an associated filebuf object
+*	and attaches it to the given file descriptor.
+*
+*Entry:
+*	fd = file descriptor of file previously opened using _open or _sopen.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*
+*******************************************************************************/
+	fstream::fstream(filedesc _fd)
+: iostream(new filebuf(_fd))
+{
+    istream::delbuf(1);
+    ostream::delbuf(1);
+}
+
+/***
+*fstream::fstream(filedesc fd, char * sbuf, int len) - fstream constructor
+*
+*Purpose:
+*	Constructor for fstream objects.  Creates an associated filebuf object
+*	and attaches it to the given file descriptor.  Filebuf object uses
+*	user-supplied buffer or is unbuffered if sbuf or len = 0.
+*
+*Entry:
+*	fd   = file descriptor of file previously opened using _open or _sopen.
+*	sbuf = pointer to character buffer or NULL if request for unbuffered.
+*	len  = lenght of character buffer sbuf or 0 if request for unbuffered.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*
+*******************************************************************************/
+	fstream::fstream(filedesc _fd, char * sbuf, int len)
+: iostream(new filebuf(_fd, sbuf, len))
+{
+    istream::delbuf(1);
+    ostream::delbuf(1);
+}
+
+/***
+*fstream::~fstream() - fstream destructor
+*
+*Purpose:
+*	fstream destructor.
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*
+*******************************************************************************/
+	fstream::~fstream()
+{
+    // CONSIDER: do anything else?
+}
+
+/***
+*streambuf* fstream::setbuf(char * ptr, int len) - setbuf function
+*
+*Purpose:
+*	fstream setbuf function
+*
+*Entry:
+*	ptr = pointer to buffer or NULL for unbuffered.
+*	len = length of buffer or zero for unbuffered.
+*
+*Exit:
+*	Returns rdbuf() or NULL if error.
+*
+*Exceptions:
+*	If fstream is already open or if rdbuf()->setbuf fails, sets failbit
+*	and returns NULL.
+*
+*******************************************************************************/
+streambuf * fstream::setbuf(char * ptr, int len)
+{
+    if ((is_open()) || (!(rdbuf()->setbuf(ptr, len))))
+	{
+	istream::clear(istream::state | istream::failbit);
+	ostream::clear(ostream::state | ostream::failbit);
+	return NULL;
+	}
+    return rdbuf();
+}
+
+/***
+*void fstream::attach(filedesc _fd) - attach member function
+*
+*Purpose:
+*	fstream attach member function.  Just calls rdbuf()->attach().
+*
+*Entry:
+*	_fd = file descriptor of previously opened file.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*	Sets failbit if rdbuf()->attach fails.
+*
+*******************************************************************************/
+void fstream::attach(filedesc _fd)	// CONSIDER: inline?
+{
+    if (!(rdbuf()->attach(_fd)))
+	{
+	istream::clear(istream::state | istream::failbit);
+	ostream::clear(ostream::state | ostream::failbit);
+	}
+}
+
+/***
+*void fstream::open(const char * name, int mode, int prot) - fstream open()
+*
+*Purpose:
+*	Opens a named file and attaches it to the associated filebuf.
+*	Just calls rdbuf()->open().
+*
+*Entry:
+*	name = filename to open.
+*	mode = see filebuf::open mode argument
+*	prot = see filebuf::open share argument
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*	Sets failbit if already open or rdbuf()->open() fails.
+*
+*******************************************************************************/
+void fstream::open(const char * name, int mode, int prot)
+{
+    if (is_open() || !(rdbuf()->open(name, mode, prot)))
+	{
+	istream::clear(istream::state | istream::failbit);
+	ostream::clear(ostream::state | ostream::failbit);
+	}
+}
+
+/***
+*void fstream::close() - close member function
+*
+*Purpose:
+*	fstream close member function.  Just calls rdbuf()->close().
+*	Clears rdstate() error bits if successful.
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*	Sets failbit if rdbuf()->close fails.
+*
+*******************************************************************************/
+void fstream::close()
+{
+    if (rdbuf()->close())
+	{
+	istream::clear();
+	ostream::clear();
+	}
+    else 
+	{
+	istream::clear(istream::state | istream::failbit);
+	ostream::clear(ostream::state | ostream::failbit);
+	}
+}
diff --git a/private/crt32/iostream/ifstream.cxx b/private/crt32/iostream/ifstream.cxx
new file mode 100644
index 000000000..e49e26d40
--- /dev/null
+++ b/private/crt32/iostream/ifstream.cxx
@@ -0,0 +1,240 @@
+/***
+*ifstream.cxx - ifstream member function definitions
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the member functions for the ifstream class.
+*
+*Revision History:
+*	09-21-91   KRS  Created.  Split up fstream.cxx for granularity.
+*	10-22-91   KRS	C700 #4883: fix error status for ifstream::open().
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <string.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <sys\types.h>
+#include <io.h>
+#include <fstream.h>
+#pragma hdrstop
+
+#include <sys\stat.h>
+
+/***
+*ifstream::ifstream() - ifstream default constructor
+*
+*Purpose:
+*	Default constructor for ifstream objects.
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*
+*******************************************************************************/
+	ifstream::ifstream()
+: istream(new filebuf)
+{
+    delbuf(1);	// schedule automatic deletion too...
+    // CONSIDER: do anything else?
+}
+
+/***
+*ifstream::ifstream(const char * name, int mode, int prot) - ifstream ctor
+*
+*Purpose:
+*	Constructor for ifstream objects.  Creates an associated filebuf object,
+*	opens a named file and attaches it to the new filebuf.
+*
+*Entry:
+*	name = filename to open.
+*	mode = see filebuf::open mode argument.  ios::in is implied.
+*	prot = see filebuf::open share argument
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*	Sets failbit if open fails.
+*
+*******************************************************************************/
+	ifstream::ifstream(const char * name, int mode, int prot)
+: istream(new filebuf)
+{
+    delbuf(1);	// schedule automatic deletion too...
+    if (!(rdbuf()->open(name, (mode|ios::in), prot)))
+	state |= ios::failbit;
+}
+
+/***
+*ifstream::ifstream(filedesc fd) - ifstream constructor
+*
+*Purpose:
+*	Constructor for ifstream objects.  Creates an associated filebuf object
+*	and attaches it to the given file descriptor.
+*
+*Entry:
+*	fd = file descriptor of file previously opened using _open or _sopen.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*
+*******************************************************************************/
+	ifstream::ifstream(filedesc _fd)
+: istream(new filebuf(_fd))
+{
+    delbuf(1);
+}
+
+/***
+*ifstream::ifstream(filedesc fd, char * sbuf, int len) - ifstream constructor
+*
+*Purpose:
+*	Constructor for ifstream objects.  Creates an associated filebuf object
+*	and attaches it to the given file descriptor.  Filebuf object uses
+*	user-supplied buffer or is unbuffered if sbuf or len = 0.
+*
+*Entry:
+*	fd   = file descriptor of file previously opened using _open or _sopen.
+*	sbuf = pointer to character buffer or NULL if request for unbuffered.
+*	len  = lenght of character buffer sbuf or 0 if request for unbuffered.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*
+*******************************************************************************/
+	ifstream::ifstream(filedesc _fd, char * sbuf, int len)
+: istream(new filebuf(_fd, sbuf, len))
+//: istream(new filebuf);
+{
+    delbuf(1);
+}
+
+/***
+*ifstream::~ifstream() - ifstream destructor
+*
+*Purpose:
+*	ifstream destructor.
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*
+*******************************************************************************/
+	ifstream::~ifstream()
+{
+    // CONSIDER: do anything else?
+}
+
+/***
+*streambuf* ifstream::setbuf(char * ptr, int len) - setbuf function
+*
+*Purpose:
+*	ifstream setbuf function
+*
+*Entry:
+*	ptr = pointer to buffer or NULL for unbuffered.
+*	len = length of buffer or zero for unbuffered.
+*
+*Exit:
+*	Returns rdbuf() or NULL if error.
+*
+*Exceptions:
+*	If ifstream is already open or if rdbuf()->setbuf fails, sets failbit
+*	and returns NULL.
+*
+*******************************************************************************/
+streambuf * ifstream::setbuf(char * ptr, int len)
+{
+    if ((is_open()) || (!(rdbuf()->setbuf(ptr, len))))
+	{
+	clear(state | ios::failbit);
+	return NULL;
+	}
+    // UNDONE: turn off output buffer??
+    return rdbuf();
+}
+
+/***
+*void ifstream::attach(filedesc _fd) - attach member function
+*
+*Purpose:
+*	ifstream attach member function.  Just calls rdbuf()->attach().
+*
+*Entry:
+*	_fd = file descriptor of previously opened file.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*	Sets failbit if rdbuf()->attach fails.
+*
+*******************************************************************************/
+void ifstream::attach(filedesc _fd)	// CONSIDER: inline?
+{
+    if (!(rdbuf()->attach(_fd)))
+	clear(state | ios::failbit);
+}
+
+/***
+*void ifstream::open(const char * name, int mode, int prot) - ifstream open()
+*
+*Purpose:
+*	Opens a named file and attaches it to the associated filebuf.
+*	Just calls rdbuf()->open().
+*
+*Entry:
+*	name = filename to open.
+*	mode = see filebuf::open mode argument.  ios::in is implied.
+*	prot = see filebuf::open share argument
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*	Sets failbit if already open or rdbuf()->open() fails.
+*
+*******************************************************************************/
+void ifstream::open(const char * name, int mode, int prot)
+{
+    if (is_open() || !(rdbuf()->open(name, (mode|ios::in), prot)))
+	clear(state | ios::failbit);
+}
+
+/***
+*void ifstream::close() - close member function
+*
+*Purpose:
+*	ifstream close member function.  Just calls rdbuf()->close().
+*	Clears rdstate() error bits if successful.
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*	Sets failbit if rdbuf()->close fails.
+*
+*******************************************************************************/
+void ifstream::close()
+{
+    clear((rdbuf()->close()) ? 0 : (state | ios::failbit));
+}
diff --git a/private/crt32/iostream/ios.cxx b/private/crt32/iostream/ios.cxx
new file mode 100644
index 000000000..6fc3468dc
--- /dev/null
+++ b/private/crt32/iostream/ios.cxx
@@ -0,0 +1,323 @@
+/***
+*ios.cxx - fuctions for ios class.
+*
+*	Copyright (c) 1990-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Functions for ios class.
+*
+*Revision History:
+*	09-10-90  WAJ	Initial version.
+*	07-02-91  KRS	Initial version completed.
+*	09-19-91  KRS	Make use of delbuf() in destructor.
+*	11-04-91  KRS	Change init().  Add operator=.  Fix constructors.
+*	11-11-91  KRS	Change xalloc() to conform to AT&T usage.
+*	11-20-91  KRS	Add copy constructor.
+*	02-12-92  KRS	Fix init of delbuf in ios::ios(streambuf*).
+*	03-30-92  KRS	Add MTHREAD lock init calls to constructors.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <iostream.h>
+#pragma hdrstop
+
+const long ios::basefield = (ios::dec | ios::oct | ios::hex);
+const long ios::adjustfield = (ios::left | ios::right | ios::internal);
+const long ios::floatfield = (ios::scientific | ios::fixed);
+
+long ios::x_maxbit = 0x8000;	// ios::openprot
+int  ios::x_curindex = -1;
+
+#ifdef MTHREAD
+// UNDONE: enough? 15?
+#define MAXINDEX 7
+long ios::x_statebuf[MAXINDEX+1] = { 0,0,0,0,0,0,0,0 }; // MAXINDEX * 0
+int ios::fLockcInit = 0;	// nonzero = static lock initialized
+RTL_CRITICAL_SECTION ios::x_lockc;
+#else	// MTHREAD
+long  * ios::x_statebuf = NULL;
+#endif	// MTHREAD
+
+/***
+*ios::ios() - default constructor.
+*
+*Purpose:
+*   Initializes an ios.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+ios::ios()
+{
+    bp = NULL;
+    state = ios::badbit;
+
+    ispecial = 0;
+    ospecial = 0;
+    x_tie = (0);
+    x_flags = 0;
+    x_precision = 6;
+    x_fill = ' ';
+    x_width = 0;
+    x_delbuf = 0;
+
+#ifdef MTHREAD
+    LockFlg = 1;		// default is no locking
+    _mtlockinit(lockptr());
+    if (!fLockcInit) 		// UNDONE: find a cheaper way to do this
+	{
+	_mtlockinit(&x_lockc);
+	fLockcInit++;
+	}
+#endif  /* MTHREAD */
+
+}
+
+
+
+/***
+*ios::ios( streambuf* pSB ) - constructor.
+*
+*Purpose:
+*   Initializes an ios.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+ios::ios( streambuf* pSB )
+{
+//  this->ios();
+
+    bp = pSB;
+    state = (bp) ? 0 : ios::badbit;
+
+    ispecial = 0;
+    ospecial = 0;
+    x_tie = (0);
+    x_flags = 0;
+    x_precision = 6;
+    x_fill = ' ';
+    x_width = 0;
+    x_delbuf = 0;
+
+#ifdef MTHREAD
+    LockFlg = 1;		// default is no locking
+    _mtlockinit(lockptr());
+    if (!fLockcInit) 		// UNDONE: find a cheaper way to do this
+	{
+	_mtlockinit(&x_lockc);
+	fLockcInit++;
+	}
+#endif  /* MTHREAD */
+
+}
+
+/***
+*ios::ios(const ios& _strm) - copy constructor.
+*
+*Purpose:
+*	Copy constructor.
+*
+*Entry:
+*	_strm = ios to copy data members from.
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+ios::ios(const ios& _strm)	// copy constructor
+{
+    bp = NULL;
+    x_delbuf = 0;
+
+//  init(_strm.rdbuf());
+//  delbuf(_strm.delbuf());
+
+    *this = _strm;		// invoke assignment operator
+//  state = (bp) ? 0 : ios::badbit;
+
+#ifdef MTHREAD
+    LockFlg = 1;		// default is no locking
+    _mtlockinit(lockptr());
+    if (!fLockcInit) 		// UNDONE: find a cheaper way to do this
+	{
+	_mtlockinit(&x_lockc);
+	fLockcInit++;
+	}
+#endif  /* MTHREAD */
+
+}
+
+
+/***
+*virtual ios::~ios() - default destructor.
+*
+*Purpose:
+*   Terminates an ios.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+ios::~ios()
+{
+    lock();	// make sure no one else is using it
+    if ((x_delbuf) && (bp))
+	delete bp;
+    bp = NULL;
+    state = badbit;
+    
+}
+
+
+/***
+*void ios::init( streambuf* pSB ) - initializes ios
+*
+*Purpose:
+*   Initializes an ios.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+void ios::init( streambuf* pSB )
+{
+    if (delbuf() && (bp))	// delete previous bp if necessary
+	delete bp;
+    bp = pSB;
+    if (bp)
+	state &= ~ios::badbit;
+    else
+	state |= ios::badbit;
+}
+
+
+
+/***
+*ios& ios::operator=( const ios& _strm ) - copy an ios.
+*
+*Purpose:
+*   Copy an ios.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+ios& ios::operator=(const ios& _strm)
+{
+	x_tie = _strm.tie();
+	x_flags = _strm.flags();
+	x_precision = (char)_strm.precision();
+	x_fill	= _strm.fill();
+	x_width = (char)_strm.width();
+
+	state = _strm.rdstate();
+	if (!bp)
+	    state |= ios::badbit;	// adjust state for uninitialized bp
+
+//	init(_strm.rdbuf());
+//	delbuf(_strm.delbuf());
+
+	return *this;
+}
+
+/***
+*int ios::xalloc() - ios xalloc member function
+*
+*Purpose:
+*	UNDONE:
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	Returns index of of new entry in new buffer, or EOF if error.
+*
+*Exceptions:
+*	Returns EOF if OM error.
+*
+*******************************************************************************/
+int  ios::xalloc()
+{
+#ifdef MTHREAD
+    // buffer must be static if multithread, since thread can't keep track of
+    // validity of pointer otherwise
+    int index;
+    lockc();
+    if (x_curindex >= MAXINDEX)
+	index = EOF;
+    else
+	{
+	index = ++x_curindex;
+//	x_statebuf[index] = 0;
+	}
+    unlockc();
+    return index;
+#else	// MTHREAD
+    long * tptr;
+    int i;
+
+    if (!(tptr=new long[x_curindex+2]))	// allocate new buffer
+	return EOF;
+
+    for (i=0; i <= x_curindex; i++)	// copy old buffer, if any
+	tptr[i] = x_statebuf[i];
+
+    tptr[++x_curindex] = 0L;		// init new entry, bump size
+
+    if (x_statebuf)			// delete old buffer, if any
+	delete x_statebuf;
+    x_statebuf = tptr;			// and assign new buffer
+    return x_curindex;
+#endif	// MTHREAD
+}
+
+/***
+*long ios::bitalloc() - ios bitalloc member function
+*
+*Purpose:
+*	Returns a unused bit mask for flags().
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	Returns next available bit maskf.
+*
+*Exceptions:
+*
+*******************************************************************************/
+long ios::bitalloc()		// CONSIDER: make inline?
+{
+    long b;
+    lockc();		// lock to make sure mask in unique (MTHREAD)
+    b = (x_maxbit<<=1);
+    unlockc();
+    return b;
+}
diff --git a/private/crt32/iostream/iostream.cxx b/private/crt32/iostream/iostream.cxx
new file mode 100644
index 000000000..1ae765423
--- /dev/null
+++ b/private/crt32/iostream/iostream.cxx
@@ -0,0 +1,83 @@
+/***
+* iostream.cxx - definitions for iostream classes
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the member function definitions for iostream classes.  Also,
+*	precompile all header files used by iostream lib into iostream.pch.
+*
+*Revision History:
+*	09-23-91   KRS	Created.
+*	11-13-91   KRS	Rearranged.
+*	11-20-91   KRS	Added copy constructor and assignment operators.
+*	01-23-92   KRS	Merge pch.cxx into this file.
+*
+*******************************************************************************/
+
+// NOTE: the follow must include ALL header files used by any of the iostream
+//       source files which we want built into iostream.pch.  It is necessary
+//	 to have the pch associated with exactly one of the library modules
+//	 for efficient storage of Codeview info.
+
+#include <cruntime.h>
+#include <internal.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <ctype.h>
+#include <share.h>
+#include <fcntl.h>
+#include <io.h>
+// #include <sys\stat.h>	// compile problems
+#include <sys\types.h>
+#include <float.h>
+#include <iostream.h>
+// #include <ios.h>
+// #include <streamb.h>
+// #include <istream.h>
+// #include <ostream.h>
+#include <fstream.h>
+#include <strstrea.h>
+#include <stdiostr.h>
+
+#pragma hdrstop			// end of headers to precompile
+
+// CONSIDER: not used, is this required???
+	iostream::iostream()
+: istream(), ostream()
+{
+// CONSIDER: do anything else?
+}
+
+	iostream::iostream(streambuf * _sb)
+: istream(_sb), ostream(_sb)
+{
+// CONSIDER: do anything else?
+}
+
+	iostream::iostream(const iostream& _strm)
+: istream(_strm), ostream(_strm)
+{
+// CONSIDER: do anything else?
+}
+
+iostream::~iostream()
+{
+// if both input and output share the same streambuf, but not the same ios,
+// make sure only deleted once
+if ((istream::bp==ostream::bp) && (&istream::bp!=&ostream::bp))
+	istream::bp = NULL;	// let ostream::ios::~ios() do it
+// CONSIDER: do anything else?
+}
+
+/* done inline
+iostream& iostream::operator=(streambuf* _sb)
+{
+	istream::operator=(_sb);
+	ostream::operator=(_sb);
+	return *this;
+}
+*/
diff --git a/private/crt32/iostream/iostrini.cxx b/private/crt32/iostream/iostrini.cxx
new file mode 100644
index 000000000..e6bb83ba2
--- /dev/null
+++ b/private/crt32/iostream/iostrini.cxx
@@ -0,0 +1,83 @@
+/***
+*iostrini.cxx - definition and initialization for predefined stream cout.
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definition and initialization of and predefined iostream cout.
+*
+*Revision History:
+*	11-18-91   KRS	Created.
+*
+*******************************************************************************/
+#include <cruntime.h>
+#include <internal.h>
+#include <iostream.h>
+#include <fstream.h>
+#pragma hdrstop
+
+// put contructors in special MS-specific XIFM segment
+#pragma warning(disable:4074)	// disable init_seg warning
+#pragma init_seg(compiler)
+
+#if ((!defined(_WINDOWS)) || defined(_QWIN))
+ostream_withassign cout(new filebuf(1));
+
+static Iostream_init  __InitCout(cout,-1);
+
+#endif
+
+/***
+*Iostream_init::Iostream_init() - initialize predefined streams
+*
+*Purpose:
+*	 For compatibility only.  Not used.
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+	Iostream_init::Iostream_init() { }	// do nothing
+
+/***
+*Iostream_init::Iostream_init() - initialize predefined streams
+*
+*Purpose:
+*	 Initializes predefined streams: cin, cout, cerr, clog;
+*Entry:
+*	pstrm = cin, cout, cerr, or clog
+*	sflg =  1 if cerr (unit buffered)
+*	sflg = -1 if cout
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+	Iostream_init::Iostream_init(ios& pstrm, int sflg)
+{
+#if ((!defined(_WINDOWS)) || defined(_QWIN))
+	pstrm.delbuf(1);
+	if (sflg>=0)	// make sure not cout
+		pstrm.tie(&cout);
+	if (sflg>0)
+		pstrm.setf(ios::unitbuf);
+#endif
+}
+
+/***
+*Iostream_init::~Iostream_init() - destroy predefined streams on exit
+*
+*Purpose:
+*	 Destroy predefined streams: cin, cout, cerr, clog;
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+	Iostream_init::~Iostream_init() { }	// do nothing
+
diff --git a/private/crt32/iostream/istrchar.cxx b/private/crt32/iostream/istrchar.cxx
new file mode 100644
index 000000000..0896a3e9d
--- /dev/null
+++ b/private/crt32/iostream/istrchar.cxx
@@ -0,0 +1,40 @@
+/***
+* istrchar.cxx - definitions for istream class operator>>(char&)
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions of member function for istream operator>>(char&).
+*	[AT&T C++]
+*
+*Revision History:
+*	09-23-91   KRS	Created.  Split out from istream.cxx for granularity.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <iostream.h>
+#pragma hdrstop
+
+// CONSIDER: validify all these maximum lengths...
+
+istream& istream::operator>>(char& c)
+{
+    int tchar;
+    if (ipfx(0))
+	{
+	tchar=bp->sbumpc();
+	if (tchar==EOF)
+	    {
+	    state |= ios::eofbit|ios::badbit;
+	    }
+	else
+	    {
+	    c = (char)tchar;
+	    }
+	isfx();
+	}
+    return *this;
+}
diff --git a/private/crt32/iostream/istrdbl.cxx b/private/crt32/iostream/istrdbl.cxx
new file mode 100644
index 000000000..a129d4d20
--- /dev/null
+++ b/private/crt32/iostream/istrdbl.cxx
@@ -0,0 +1,46 @@
+/***
+* istrdbl.cxx - definition for operator>>(double) member funct for istream class
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definition of operator>>(double) member function for istream class.
+*	[AT&T C++]
+*
+*Revision History:
+*	09-26-91   KRS	Created.  Split off from istream.cxx for granularity.
+*	12-30-92   KRS	Fix indirection problem with **endptr.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <iostream.h>
+#pragma hdrstop
+
+#pragma check_stack(on)		// large buffer(s)
+
+// CONSIDER: validate this maximum length
+#define MAXDBLSIZ	28
+
+istream& istream::operator>>(double& n)
+{
+_WINSTATIC char ibuffer[MAXDBLSIZ];
+    char ** endptr = (char**)NULL;
+    if (ipfx(0))
+	{
+	if (getdouble(ibuffer, MAXDBLSIZ)>0)
+	    {
+	    n = strtod(ibuffer, endptr);
+#if 0
+	    if (**endptr)
+		{
+		//UNDONE: put back any unread characters, if possible
+		}
+#endif
+	    }
+        isfx();
+	}
+return *this;
+}
diff --git a/private/crt32/iostream/istream.cxx b/private/crt32/iostream/istream.cxx
new file mode 100644
index 000000000..d5916001d
--- /dev/null
+++ b/private/crt32/iostream/istream.cxx
@@ -0,0 +1,278 @@
+/***
+* istream.cxx - definitions for istream and istream_withassign classes
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions of member functions for istream and istream_withassign
+*	classes.
+*	[AT&T C++]
+*
+*Revision History:
+*	07-15-91   KRS	Created.
+*	08-15-91   KRS	Fix handling of 1-length strings in get(char*,int,int)
+*	08-20-91   KRS  Make read() not do text translation (for filebufs)
+*	08-21-91   KRS  Fix >>(streambuf *) to advance pointer properly.
+*	08-22-91   KRS  Fix octal error in getint().
+*	08-26-91   KRS	Fix for Windows DLL's and set max. ibuffer[] lengths.
+*	09-05-91   KRS	Don't special-case 0x in getint(). Spec. conformance...
+*	09-10-91   KRS	Reinstate text translation (by default) for read().
+*	09-12-91   KRS	Treat count as unsigned in get() and read().
+*	09-16-91   KRS	Fix get(char *, int lim, char) for lim=0 case.
+*	09-23-91   KRS	Split up flie for granularity purposes.
+*	10-21-91   KRS	Make eatwhite() return void again.
+*	10-24-91   KRS	Move istream_withassign::operator=(streambuf*) here.
+*	11-04-91   KRS	Make constructors work with virtual base.
+*			Fix whitespace error handling in ipfx().
+*	11-20-91   KRS	Add/fix copy constructor and assignment operators.
+*	01-23-92   KRS	C700 #5883: Fix behaviour of peek() to call ipfx(1).
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <iostream.h>
+#pragma hdrstop
+
+	istream::istream()
+// : ios()
+{
+	x_flags |= ios::skipws;
+	x_gcount = 0;
+	_fGline = 0;
+	// CONSIDER: do anything else?
+}
+
+	istream::istream(streambuf* _inistbf)
+// : ios()
+{
+	init(_inistbf);
+
+	x_flags |= ios::skipws;
+	x_gcount = 0;
+	_fGline = 0;
+	// CONSIDER: do anything else?
+}
+
+	istream::istream(const istream& _istrm)
+// : ios()
+{
+	init(_istrm.rdbuf());
+
+	x_flags |= ios::skipws;
+	x_gcount = 0;
+	_fGline = 0;
+	// CONSIDER: do anything else?
+}
+
+	istream::~istream()
+// : ~ios()
+{
+	// CONSIDER: do anything else?
+}
+
+// used by ios::sync_with_stdio()
+istream& istream::operator=(streambuf * _sbuf)
+{
+// consider: may be some redundency here, depending on spec.
+	if (delbuf() && rdbuf())
+	    delete rdbuf();
+	bp = 0;
+
+	this->ios::operator=(ios());	// initialize ios members
+	delbuf(0);			// important!
+	init(_sbuf);	// set up bp
+
+	x_flags |= ios::skipws;		// init istream members too
+	x_gcount = 0;
+//	_fGline = 0;			// not necessary
+
+	return *this;
+}
+int istream::ipfx(int need)
+{
+    lock();
+    if (need)		// reset gcount if unformatted input
+	x_gcount = 0;
+    if (state)		// return 0 iff error condition
+	{
+	state |= ios::failbit;	// solves cin>>buf problem
+	unlock();
+	return 0;
+	}
+    if (x_tie && ((need==0) || (need > bp->in_avail())))
+	{
+	x_tie->flush();
+	}
+    lockbuf();
+    if ((need==0) && (x_flags & ios::skipws))
+	{
+	eatwhite();
+	if (state)	// eof or error
+	    {
+	    state |= ios::failbit;
+	    unlockbuf();
+	    unlock();
+	    return 0;
+	    }
+	}
+    // leave locked ; isfx() will unlock
+    return 1;		// return nz if okay
+}
+
+// formatted input functions
+
+istream& istream::operator>>(char * s)
+{
+    int c;
+    unsigned int i, lim;
+    if (ipfx(0))
+	{
+	lim = (unsigned)(x_width-1);
+	x_width = 0;
+	if (!s)
+	    {
+	    state |= ios::failbit;
+	    }
+	else
+	    {
+	    for (i=0; i< lim; i++)
+		{
+		c=bp->sgetc();
+		if (c==EOF)
+		    {
+		    state |= ios::eofbit;
+		    if (!i)
+			state |= ios::failbit|ios::badbit;
+		    break;
+		    }
+		else if (isspace(c))
+		    {
+		    break;
+		    }
+		else
+		    {
+		    s[i] = (char)c;
+		    bp->stossc(); // advance pointer
+		    }
+	        }
+	    if (!i)
+		state |= ios::failbit;
+	    else
+		s[i] = '\0';
+	    }
+	isfx();
+	}
+    return *this;
+}
+
+#if 0
+istream& istream::operator>>(char& c)
+{
+    int tchar;
+    if (ipfx(0))
+	{
+	tchar=bp->sbumpc();
+	if (tchar==EOF)
+	    {
+	    state |= ios::eofbit|ios::badbit;
+	    }
+	else
+	    {
+	    c = (char)tchar;
+	    }
+	isfx();
+	}
+    return *this;
+}
+#endif
+
+int istream::peek()
+{
+int retval;
+    if (ipfx(1))
+	{
+	retval = (bp->sgetc());
+	isfx();
+	}
+    else
+	retval = EOF;
+    return retval;
+}
+
+istream& istream::putback(char c)
+{
+//    if (!bad())		// CONSIDER: just return if bad error?
+      if (good())		// this is how it's spec.ed out...
+	{
+	lockbuf();
+
+	if (bp->sputbackc(c)==EOF)
+	    {
+	    clear(state | ios::failbit);
+	    }
+//	else
+//	    clear(state & ~(ios::eof)); // no longer at end of file, if we were...
+
+	unlockbuf();
+	}
+    return *this;
+}
+
+int istream::sync()
+{
+    int retval;
+    lockbuf();
+
+    if ((retval=bp->sync())==EOF)
+	{
+	clear(state | (ios::failbit|ios::badbit));
+	}
+
+    unlockbuf();
+    return retval;
+}
+
+void istream::eatwhite()
+{
+    int c;
+    lockbuf();
+    c = bp->sgetc();
+    for ( ; ; )
+	{
+	if (c==EOF)
+	    {
+	    clear(state | ios::eofbit);
+	    break;
+	    }
+	if (isspace(c))
+	    {
+	    c = bp->snextc();
+	    }
+	else
+	    {
+	    break;
+	    }
+	}
+    unlockbuf();
+}
+
+	istream_withassign::istream_withassign()
+: istream()
+{
+	// CONSIDER: do anything else?
+}
+
+	istream_withassign::istream_withassign(streambuf* _is)
+: istream(_is)
+{
+	// CONSIDER: do anything else?
+}
+
+	istream_withassign::~istream_withassign()
+// : ~istream()
+{
+	// CONSIDER: do anything else?
+}
diff --git a/private/crt32/iostream/istream1.cxx b/private/crt32/iostream/istream1.cxx
new file mode 100644
index 000000000..ff2bc8098
--- /dev/null
+++ b/private/crt32/iostream/istream1.cxx
@@ -0,0 +1,98 @@
+/***
+* istream1.cxx - non-core definitions for istream & istream_withassign classes
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions of non-core member functions for istream and
+*	istream_withassign classes.
+*	[AT&T C++]
+*
+*Revision History:
+*	09-23-91   KRS	Created.  Split off from istream.cxx for granularity.
+*	10-07-91   KRS	Increment x_gcount in get(sb).
+*	10-24-91   KRS	Fix istream_withassign::operator=() functions.
+*	11-20-91   KRS  Make operator= inline.
+*	03-30-92   KRS	Add multithread locking.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <iostream.h>
+#pragma hdrstop
+
+istream& istream::operator>>(streambuf* _sbuf)
+{
+    int c;
+    if (ipfx(0))
+	{
+	while ((c=bp->sbumpc())!=EOF)
+	    {
+	    if (_sbuf->sputc(c)==EOF)
+		{
+		state |= ios::failbit;
+		}
+	    }
+	isfx();
+	}
+return *this;
+}
+
+
+// unformatted input functions
+
+istream& istream::get( streambuf& sbuf, char delim)
+{
+    int c;
+    if (ipfx(1))	// resets x_gcount
+	{
+	while ((c  = bp->sgetc())!=delim)
+	    {
+	    if (c==EOF)  // stop if EOF encountered
+		{
+		state |= ios::eofbit;
+		break;
+		}
+	    bp->stossc();	// advance get pointer
+	    x_gcount++;		// and increment count
+
+	    // store c into sbuf  // UNDONE:  is this what they meant???
+	    if (sbuf.sputc(c)==EOF)
+ 		state |= ios::failbit;
+	    }
+	isfx();
+	}
+    return *this;
+}
+
+istream& istream::seekg(streampos _strmp)
+{
+    lockbuf();
+    if (bp->seekpos(_strmp, ios::in)==EOF)
+	{
+	clear(state | failbit);
+	}
+    unlockbuf();
+    return(*this);
+}
+
+istream& istream::seekg(streamoff _strmf, seek_dir _sd)
+{
+    lockbuf();
+    if (bp->seekoff(_strmf, _sd, ios::in)==EOF)
+	clear(state | failbit);
+    unlockbuf();
+    return(*this);
+}
+
+streampos istream::tellg()
+{
+    streampos retval;
+    lockbuf();
+    if ((retval=bp->seekoff(streamoff(0), ios::cur, ios::in))==EOF)
+	clear(state | failbit);
+    unlockbuf();
+    return(retval);
+}
diff --git a/private/crt32/iostream/istrflt.cxx b/private/crt32/iostream/istrflt.cxx
new file mode 100644
index 000000000..79c04a11b
--- /dev/null
+++ b/private/crt32/iostream/istrflt.cxx
@@ -0,0 +1,58 @@
+/***
+* istrflt.cxx - definitions for istream operator>>(float) member function
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions of operator>>(float) member function for istream class.
+*	[AT&T C++]
+*
+*Revision History:
+*	09-26-91   KRS	Created.  Split out from istream.cxx for granularity.
+*	12-30-92   KRS	Fix indirection problem with **endptr.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <float.h>
+#include <iostream.h>
+#pragma hdrstop
+
+#pragma check_stack(on)		// large buffer(s)
+
+// CONSIDER: validate this maximum length
+#define MAXFLTSIZ	20
+
+istream& istream::operator>>(float& n)
+{
+_WINSTATIC char ibuffer[MAXFLTSIZ];
+    double d;
+    char ** endptr = (char**)NULL;
+    if (ipfx(0))
+	{
+	if (getdouble(ibuffer, MAXFLTSIZ)>0)
+	    {
+	    d = strtod(ibuffer, endptr);
+#if 0
+	    if (**endptr)
+		{
+		//UNDONE: put back any unread characters, if possible
+		}
+#endif
+	    if (d > FLT_MAX)
+		n = FLT_MAX;
+	    else if (d < -FLT_MAX)
+		n =  -FLT_MAX;
+	    else if ((d>0) && (d< FLT_MIN))
+		n = FLT_MIN;
+	    else if ((d<0) && (d> -FLT_MIN))
+		n = - FLT_MIN;
+	    else
+		n = (float) d;
+	    }
+        isfx();
+        }
+return *this;
+}
diff --git a/private/crt32/iostream/istrgdbl.cxx b/private/crt32/iostream/istrgdbl.cxx
new file mode 100644
index 000000000..e3bb18b2b
--- /dev/null
+++ b/private/crt32/iostream/istrgdbl.cxx
@@ -0,0 +1,105 @@
+/***
+* istrgdbl.cxx - definitions for istream class core double routine
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions of member function for istream getdouble().
+*	[AT&T C++]
+*
+*Revision History:
+*	09-26-91   KRS	Created.  Split off from istream.cxx for granularity.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <ctype.h>
+#include <iostream.h>
+#pragma hdrstop
+
+/***
+*int istream::getdouble(char * buffer, int buflen) - get a double
+*
+*Purpose:
+*	Get a double from stream.
+*
+*Entry:
+*	char * buffer	= area for number to be copied.
+*	int buflen	= max. length of buffer
+*
+*Exit:
+*	Returns 0 if fatal error
+*	Otherwise, returns length of buffer filled.
+*	Sets ios::failbit on error forming number.
+*	If successful, buffer[] contains the number, followed by \0.
+*
+*Exceptions:
+*
+*******************************************************************************/
+int	istream::getdouble(char * buffer, int buflen)	// returns length
+{
+    int c;
+    int i = 0;
+    int fDigit = 0;	// true if legal digit encountered
+    int fDecimal=0;	// true if '.' encountered or no longer valid
+    int fExp=0;		// true if 'E' or 'e' encounted
+
+    if (ipfx(0))
+	{
+	c=bp->sgetc();
+	for (; i<buflen; buffer[i] = (char)c,c=bp->snextc(),i++)
+	    {
+	    if (c==EOF)
+		{
+		state |= ios::eofbit;
+		break;
+		}
+	    if ((!i) || (fExp==1))
+		{
+	        if ((c=='-') || (c=='+'))
+		    {
+		    continue;
+		    }
+		}
+		// UNDONE: use locale-dependent decimal point character!!!
+	    if ((c=='.') && (!fExp) && (!fDecimal))
+		{
+		fDecimal++;
+		continue;
+		}
+	    if (((c=='E') || (c=='e')) && (!fExp))
+		{
+		fDecimal++;	// can't allow decimal now
+		fExp++;
+		continue;
+		}
+	    if (!isdigit(c))
+		break;
+	    if (fExp)
+		fExp++;
+	    else
+		fDigit++;
+	    }
+	if (fExp==1)		// E or e with no number after it
+	    {
+	    if (bp->sputbackc(buffer[i])!=EOF)
+		{
+		i--;
+		state &= ~(ios::eofbit);
+		}
+	    else
+		{
+		state |= ios::failbit;		// CONSIDER: correct?
+		}
+	    }
+	if ((!fDigit) || (i==buflen))
+	    state |= ios::failbit;
+
+	// buffer contains a valid number or '\0'
+	buffer[i] = '\0';
+	isfx();
+	}
+    // UNDONE: check for errors, return EOF
+    return i;
+}
diff --git a/private/crt32/iostream/istrget.cxx b/private/crt32/iostream/istrget.cxx
new file mode 100644
index 000000000..7b099cda7
--- /dev/null
+++ b/private/crt32/iostream/istrget.cxx
@@ -0,0 +1,65 @@
+/***
+* istrget.cxx - definitions for istream class get() member functions
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions of get() member functions for istream class.
+*	[AT&T C++]
+*
+*Revision History:
+*	09-26-91   KRS	Created.  Split off from istream.cxx for granularity.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <iostream.h>
+#pragma hdrstop
+
+// unformatted input functions
+
+int istream::get()
+{
+    int c;
+    if (ipfx(1))	// resets x_gcount
+	{
+	if ((c=bp->sbumpc())==EOF)
+	    state |= ios::eofbit;
+	else
+	    x_gcount++;
+	isfx();
+	return c;
+	}
+    return EOF;
+}
+
+// signed and unsigned char make inline calls to this:
+istream& istream::get( char& c)
+{
+    int temp;
+    if (ipfx(1))	// resets x_gcount
+	{
+	if ((temp=bp->sbumpc())==EOF)
+	    state |= (ios::failbit|ios::eofbit);	// UNDONE ??
+	else
+	    x_gcount++;
+	c = (char) temp;
+	isfx();
+	}
+    return *this;
+}
+
+
+// called by signed and unsigned char versions
+istream& istream::read(char * ptr, int n)
+{
+    if (ipfx(1))	// resets x_gcount
+	{
+	x_gcount = bp->sgetn(ptr, n);
+	if ((unsigned)x_gcount < (unsigned)n)
+	    state |= (ios::failbit|ios::eofbit);
+	isfx();
+	}
+    return *this;
+}
diff --git a/private/crt32/iostream/istrgetl.cxx b/private/crt32/iostream/istrgetl.cxx
new file mode 100644
index 000000000..a8ce283cf
--- /dev/null
+++ b/private/crt32/iostream/istrgetl.cxx
@@ -0,0 +1,70 @@
+/***
+* istrgetl.cxx - definitions for istream class getl() member function
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions of get and getline member functions istream class.
+*	[AT&T C++]
+*
+*Revision History:
+*	09-26-91   KRS	Created.  Split off from istream.cxx for granularity.
+*	01-23-92   KRS	C700 #5880: Add cast to fix comparison in get().
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <iostream.h>
+#pragma hdrstop
+
+// unformatted input functions
+
+// signed and unsigned char make inline calls to this:
+// all versions of getline also share this code:
+
+istream& istream::get( char *b, int lim, char delim)
+{
+    int c;
+    unsigned int i = 0;
+    if (ipfx(1))	// resets x_gcount
+	{
+	if (lim--)
+	    {
+	    while (i < (unsigned)lim)
+		{
+		c=bp->sgetc();
+		if (c==EOF)
+		    {
+		    state |= ios::eofbit;
+		    if (!i)
+			state |= ios::failbit;
+		    break;
+		    }
+		else if (c==(int)(unsigned char)delim)
+		    {
+		    if (_fGline)
+			{
+			x_gcount++;
+			bp->stossc(); // extract delim if called from getline
+			}
+		    break;
+		    }
+		else
+		    {
+		    if (b)
+			b[i] = (char)c;
+		    bp->stossc(); // advance pointer
+		    }
+		i++;
+		}
+	    x_gcount += i;		// set gcount()
+	    }
+	isfx();
+	lim++;		// restore lim for test below
+	}
+    if ((b) && (lim))	// always null-terminate, if possible
+	b[i] = '\0';
+    _fGline = 0;
+    return *this;
+}
diff --git a/private/crt32/iostream/istrgint.cxx b/private/crt32/iostream/istrgint.cxx
new file mode 100644
index 000000000..0f4997483
--- /dev/null
+++ b/private/crt32/iostream/istrgint.cxx
@@ -0,0 +1,145 @@
+/***
+* istrgint.cxx - definitions for istream class core integer routines
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions of member function getint() for istream class.
+*	[AT&T C++]
+*
+*Revision History:
+*	09-26-91   KRS	Created.  Split off from istream.cxx for granularity.
+*	01-06-92   KRS	Remove buflen argument.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <ctype.h>
+#include <iostream.h>
+#pragma hdrstop
+
+#define MAXLONGSIZE	16
+
+/***
+*int istream::getint(char * buffer) - get an int
+*
+*Purpose:
+*	Get an int from stream.
+*
+*Entry:
+*	char * buffer	= area for number to be copied.
+*
+*Exit:
+*	Returns base for conversion: (0, 2, 8, or 16).
+*	If successful, buffer[] contains the number, followed by \0.
+*
+*Exceptions:
+*	Sets ios::failbit on error forming number.
+*	Sets ios::badbit on error after failbit
+*	Sets ios::eofbit if at EOF at return
+*
+*******************************************************************************/
+int	istream::getint(char * buffer)	// returns length
+{
+    int base, i;
+    int c;
+    int fDigit = 0;
+    int bindex = 1;
+
+    if (x_flags & ios::dec)
+	base = 10;
+    else if (x_flags & ios::hex)
+	base = 16;
+    else if (x_flags & ios::oct)
+	base = 8;
+    else
+	base = 0;
+
+    if (ipfx(0))
+	{
+	c=bp->sgetc();
+	for (i = 0; i<MAXLONGSIZE; buffer[i] = (char)c,c=bp->snextc(),i++)
+	    {
+	    if (c==EOF)
+		{
+		state |= ios::eofbit;
+		break;
+		}
+	    if (!i)
+		{
+	        if ((c=='-') || (c=='+'))
+		    {
+		    bindex++;
+		    continue;
+		    }
+		}
+	    if ((i==bindex) && (buffer[i-1]=='0'))
+		{
+	        if (((c=='x') || (c=='X')) && ((base==0) || (base==16)))
+		    {
+		    base = 16;	// simplifies matters
+		    fDigit = 0;
+		    continue;
+		    }
+		else if (base==0)
+		    {
+		    base = 8;
+		    }
+		}
+
+	   
+	    // now simply look for a digit and set fDigit if found else break
+
+	    if (base==16)
+		{
+		if (!isxdigit(c))
+		    break;
+		}
+	    else if ((!isdigit(c)) || ((base==8) && (c>'7')))
+		break;
+	    
+	    fDigit++;
+	    }
+	if (!fDigit)
+	    {
+#if 0
+	    if ((i==bindex+1) && ((buffer[bindex]=='x') || (buffer[bindex]=='X')))
+		{
+		// found 0x but no number, so back up one and return '0'
+		if (bp->sputbackc(buffer[bindex])!=EOF)
+		    {
+		    i--;
+		    state &= ~(ios::eofbit);
+	//	    fDigit++;
+		    }
+		else
+		    state |= (ios::failbit|ios::badbit);  // CONSIDER: correct?
+		}
+	    else
+#endif
+		{
+		state |= ios::failbit;
+		while (i--)
+		    {
+		    if(bp->sputbackc(buffer[i])==EOF)
+			{
+			state |= ios::badbit;		// CONSIDER: correct?
+			break;
+			}
+		    else
+		    	state &= ~(ios::eofbit);
+		    }
+		i=0;
+		}
+	    }
+	// buffer contains a valid number or '\0'
+	buffer[i] = '\0';
+	isfx();
+	}
+    if (i==MAXLONGSIZE)
+	{
+	state |= ios::failbit;
+	}
+    return base;
+}
diff --git a/private/crt32/iostream/istrint.cxx b/private/crt32/iostream/istrint.cxx
new file mode 100644
index 000000000..30c8eae48
--- /dev/null
+++ b/private/crt32/iostream/istrint.cxx
@@ -0,0 +1,71 @@
+/***
+* istrint.cxx - definitions for istream class operaotor>>(int) member functions
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions of operator>>(int) member function(s) for istream class.
+*	[AT&T C++]
+*
+*Revision History:
+*	09-26-91   KRS	Created.  Split out from istream.cxx for granularity.
+*	12-30-92   KRS	Fix indirection problem with **endptr.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <iostream.h>
+#pragma hdrstop
+
+// CONSIDER: validify all this maximum length
+#define MAXLONGSIZ	16
+
+/***
+*istream& istream::operator>>(int& n) - extract int
+*
+*Purpose:
+*	Extract int value from stream
+*
+*Entry:
+*	n = value to update
+*
+*Exit:
+*	n updated, or ios::failbit & n=INT_MAX/INT_MIN on overflow/underflow
+*
+*Exceptions:
+*	Stream error on entry or value out of range
+*
+*******************************************************************************/
+istream& istream::operator>>(int& n)
+{
+_WINSTATIC char ibuffer[MAXLONGSIZ];
+    long value;
+    char ** endptr = (char**)NULL;
+    if (ipfx(0))
+	{
+	value = strtol(ibuffer, endptr, getint(ibuffer));
+	if (value>INT_MAX)
+	    {
+	    n = INT_MAX;
+	    state |= ios::failbit;
+	    }
+	else if (value<INT_MIN)
+	{
+	    n = INT_MIN;
+	    state |= ios::failbit;
+	    }
+	else
+	    n = (int) value;
+#if 0
+	if (**endptr)
+	    {
+	    // UNDONE: put back any unread characters, if possible
+	    }
+#endif
+        isfx();
+	}
+return *this;
+}
diff --git a/private/crt32/iostream/istrldbl.cxx b/private/crt32/iostream/istrldbl.cxx
new file mode 100644
index 000000000..6059685b2
--- /dev/null
+++ b/private/crt32/iostream/istrldbl.cxx
@@ -0,0 +1,48 @@
+/***
+* istrldbl.cxx - definitions for istream class operator>>(long double) funct
+*
+*	Copyright (c) 1991-1993, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions of operator>>(long double) member function for istream
+*	class.
+*	[AT&T C++]
+*
+*Revision History:
+*	09-26-91   KRS	Created.  Split off from istream.cxx for granularity.
+*	12-30-92   KRS	Fix indirection problem with **endptr.
+*	05-10-93   CFW	Re-enable function, use strtod since no _strtold.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <iostream.h>
+#pragma hdrstop
+
+#pragma check_stack(on)		// large buffer(s)
+
+// CONSIDER: validate this maximum length
+#define MAXLDBLSIZ	32
+
+istream& istream::operator>>(long double& n)
+{
+_WINSTATIC char ibuffer[MAXLDBLSIZ];
+    char ** endptr = (char**)NULL;
+    if (ipfx(0))
+	{
+	if (getdouble(ibuffer, MAXLDBLSIZ)>0)
+	    {
+	    n = (long double)strtod(ibuffer, endptr);
+#if 0
+	    if (**endptr)
+		{
+		//UNDONE: put back any unread characters, if possible
+		}
+#endif
+	    }
+        isfx();
+	}
+return *this;
+}
diff --git a/private/crt32/iostream/istrlong.cxx b/private/crt32/iostream/istrlong.cxx
new file mode 100644
index 000000000..1a701da0b
--- /dev/null
+++ b/private/crt32/iostream/istrlong.cxx
@@ -0,0 +1,63 @@
+/***
+* istrlong.cxx - definitions for istream class operator>>(long) member function
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions of operator>>(long) member function(s) for istream class.
+*	[AT&T C++]
+*
+*Revision History:
+*	09-26-91   KRS	Created.  Split off from istream.cxx for granularity.
+*	01-06-92   KRS	Added check of errno.
+*	12-30-92   KRS	Fix indirection problem with **endptr.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <errno.h>
+#include <iostream.h>
+#pragma hdrstop
+
+// CONSIDER: validify this maximum length
+#define MAXLONGSIZ	16
+
+/***
+*istream& istream::operator>>(long& n) - extract long
+*
+*Purpose:
+*	Extract long value from stream
+*
+*Entry:
+*	n = value to update
+*
+*Exit:
+*	n updated, or ios::failbit & n=LONG_MAX/LONG_MIN on overflow/underflow
+*
+*Exceptions:
+*	Stream error on entry or value out of range
+*
+*******************************************************************************/
+istream& istream::operator>>(long& n)
+{
+_WINSTATIC char ibuffer[MAXLONGSIZ];
+    char ** endptr = (char**)NULL;
+    if (ipfx(0)) {
+	n = strtol(ibuffer, endptr, getint(ibuffer));
+	if (errno==ERANGE)
+	    {
+	    state |= ios::failbit;
+	    }
+#if 0
+	if (**endptr)
+	    {
+	    //UNDONE: put back any unread characters, if possible
+	    }
+#endif
+        isfx();
+    }
+return *this;
+}
diff --git a/private/crt32/iostream/istrshrt.cxx b/private/crt32/iostream/istrshrt.cxx
new file mode 100644
index 000000000..e61a71dbf
--- /dev/null
+++ b/private/crt32/iostream/istrshrt.cxx
@@ -0,0 +1,71 @@
+/***
+* istrshrt.cxx - definitions for istream class operator>>(short) function(s)
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions of operator>>(short) member function(s) for istream class.
+*	[AT&T C++]
+*
+*Revision History:
+*	09-26-91   KRS	Created.  Split off from istream.cxx for granularity.
+*	12-30-92   KRS	Fix indirection problem with **endptr.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <iostream.h>
+#pragma hdrstop
+
+// CONSIDER: validify this maximum length
+#define MAXLONGSIZ	16
+
+/***
+*istream& istream::operator>>(short& n) - extract short
+*
+*Purpose:
+*	Extract short value from stream
+*
+*Entry:
+*	n = value to update
+*
+*Exit:
+*	n updated, or ios::failbit & n=SHRT_MAX/SHRT_MIN on overflow/underflow
+*
+*Exceptions:
+*	Stream error on entry or value out of range
+*
+*******************************************************************************/
+istream& istream::operator>>(short& n)
+{
+_WINSTATIC char ibuffer[MAXLONGSIZ];
+    long value;
+    char ** endptr = (char**)NULL;
+    if (ipfx(0))
+	{
+	value = strtol(ibuffer, endptr, getint(ibuffer));
+	if (value>SHRT_MAX)
+	    {
+	    n = SHRT_MAX;
+	    state |= ios::failbit;
+	    }
+	else if (value<SHRT_MIN)
+	    {
+	    n = SHRT_MIN;
+	    state |= ios::failbit;
+	    }
+	else
+	    n = (short) value;
+#if 0
+	if (**endptr)
+	    {
+	    //UNDONE: put back any unread characters, if possible
+	    }
+#endif
+	isfx();
+	}
+return *this;
+}
diff --git a/private/crt32/iostream/istruint.cxx b/private/crt32/iostream/istruint.cxx
new file mode 100644
index 000000000..9432b08f4
--- /dev/null
+++ b/private/crt32/iostream/istruint.cxx
@@ -0,0 +1,72 @@
+/***
+* istruint.cxx - definitions for istream class operaotor>>(unsigned int) funct
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions of operator>>(unsigned int) member function for istream
+*	class.
+*	[AT&T C++]
+*
+*Revision History:
+*	09-26-91   KRS	Created.  Split out from istream.cxx for granularity.
+*	01-06-92   KRS	Improve error handling.
+*	12-30-92   KRS	Fix indirection problem with **endptr.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <errno.h>
+#include <iostream.h>
+#pragma hdrstop
+
+// CONSIDER: validify all this maximum length
+#define MAXLONGSIZ	16
+
+/***
+*istream& istream::operator>>(unsigned int& n) - extract unsigned int
+*
+*Purpose:
+*	Extract unsigned int value from stream
+*	Valid range is INT_MIN to UINT_MAX.
+*
+*Entry:
+*	n = value to update
+*
+*Exit:
+*	n updated, or ios::failbit and n=UINT_MAX if error
+*
+*Exceptions:
+*	Stream error on entry or value out of range
+*
+*******************************************************************************/
+istream& istream::operator>>(unsigned int& n)
+{
+_WINSTATIC char ibuffer[MAXLONGSIZ];
+    unsigned long value;
+    char ** endptr = (char**)NULL;
+    if (ipfx(0)) {
+	value = strtoul(ibuffer, endptr, getint(ibuffer));
+
+	// CONSIDER: all but the first check is to emulate strtoul behavior
+	if (((value>UINT_MAX) && (value<=(ULONG_MAX-(-INT_MIN))))
+		|| ((value==ULONG_MAX) && (errno==ERANGE)))
+	    {
+	    n = UINT_MAX;
+	    state |= ios::failbit;
+	    }
+	else
+	    n = (unsigned int) value;
+#if 0
+	if (**endptr)
+	    {
+	    //UNDONE: put back any unread characters, if possible
+	    }
+#endif
+        isfx();
+	}
+return *this;
+}
diff --git a/private/crt32/iostream/istrulng.cxx b/private/crt32/iostream/istrulng.cxx
new file mode 100644
index 000000000..f57d2572a
--- /dev/null
+++ b/private/crt32/iostream/istrulng.cxx
@@ -0,0 +1,65 @@
+/***
+* istrulng.cxx - definitions for istream class operator>>(unsigned long) funct
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions of operator>>(unsigned long) member function(s) for istream
+*	class.
+*	[AT&T C++]
+*
+*Revision History:
+*	09-26-91   KRS	Created.  Split off from istream.cxx for granularity.
+*	01-06-91   KRS	Added check of errno.
+*	12-30-92   KRS	Fix indirection problem with **endptr.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <errno.h>
+#include <iostream.h>
+#pragma hdrstop
+
+
+// CONSIDER: validify this maximum length
+#define MAXLONGSIZ	16
+
+/***
+*istream& istream::operator>>(unsigned long& n) - extract unsigned long
+*
+*Purpose:
+*	Extract unsigned long value from stream
+*
+*Entry:
+*	n = value to update
+*
+*Exit:
+*	n updated, or ios::failbit and n=ULONG_MAX if error
+*
+*Exceptions:
+*	Stream error on entry or value out of range
+*
+*******************************************************************************/
+istream& istream::operator>>(unsigned long& n)
+{
+_WINSTATIC char ibuffer[MAXLONGSIZ];
+    char ** endptr = (char**)NULL;
+    if (ipfx(0)) {
+	n = strtoul(ibuffer, endptr, getint(ibuffer));
+	if ((n==ULONG_MAX) && (errno==ERANGE))
+	    {
+	    state |= ios::failbit;
+	    }
+#if 0
+	if (**endptr)
+	    {
+	    //UNDONE: put back any unread characters, if possible
+	    }
+#endif
+        isfx();
+	}
+return *this;
+}
diff --git a/private/crt32/iostream/istrusht.cxx b/private/crt32/iostream/istrusht.cxx
new file mode 100644
index 000000000..a464dedbb
--- /dev/null
+++ b/private/crt32/iostream/istrusht.cxx
@@ -0,0 +1,73 @@
+/***
+* istrusht.cxx - definitions for istream class operator>>(unsigned short) funct
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Definitions of operator>>(unsigned short) member function for istream
+*	class.
+*	[AT&T C++]
+*
+*Revision History:
+*	09-26-91   KRS	Created.  Split off from istream.cxx for granularity.
+*	01-06-92   KRS	Improved error handling.
+*	12-30-92   KRS	Fix indirection problem with **endptr.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <errno.h>
+#include <iostream.h>
+#pragma hdrstop
+
+// CONSIDER: validify this maximum length
+#define MAXLONGSIZ	16
+
+/***
+*istream& istream::operator>>(unsigned short& n) - extract unsigned short
+*
+*Purpose:
+*	Extract unsigned short value from stream
+*	Valid range is SHRT_MIN to USHRT_MAX.
+*
+*Entry:
+*	n = value to update
+*
+*Exit:
+*	n updated, or ios::failbit and n=USHRT_MAX if error
+*
+*Exceptions:
+*	Stream error on entry or value out of range
+*
+*******************************************************************************/
+istream& istream::operator>>(unsigned short& n)
+{
+_WINSTATIC char ibuffer[MAXLONGSIZ];
+    unsigned long value;
+    char ** endptr = (char**)NULL;
+    if (ipfx(0))
+	{
+	value = strtoul(ibuffer, endptr, getint(ibuffer));
+
+	// CONSIDER: all but the first check is to emulate strtoul behavior
+	if (((value>USHRT_MAX) && (value<=(ULONG_MAX-(-SHRT_MIN))))
+		|| ((value==ULONG_MAX) && (errno==ERANGE)))
+	    {
+	    n = USHRT_MAX;
+	    state |= ios::failbit;
+	    }
+	else
+	    n = (unsigned short) value;
+#if 0
+	if (**endptr)
+	    {
+	    //UNDONE: put back any unread characters, if possible
+	    }
+#endif
+        isfx();
+	}
+return *this;
+}
diff --git a/private/crt32/iostream/makefile b/private/crt32/iostream/makefile
new file mode 100644
index 000000000..9e18c9a05
--- /dev/null
+++ b/private/crt32/iostream/makefile
@@ -0,0 +1,7 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+BLDCRT=1
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/crt32/iostream/mtlock.c b/private/crt32/iostream/mtlock.c
new file mode 100644
index 000000000..78201917d
--- /dev/null
+++ b/private/crt32/iostream/mtlock.c
@@ -0,0 +1,943 @@
+/***
+*mtlock.c - Multi-thread locking routines
+*
+*	Copyright (c) 1987-1992, Microsoft Corporation. All rights reserved.
+*
+*Purpose:
+*	Contains definitions for general-purpose multithread locking functions.
+*	_mtlockinit()
+*	_mtlock()
+*	_mtunlock()
+*
+*Revision History:
+*	03-10-92   KRS	Created from mlock.c.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <oscalls.h>
+#include <internal.h>
+#include <os2dll.h>
+#include <rterr.h>
+#include <stddef.h>
+#include <limits.h>
+
+#ifdef MTHREAD
+
+void _CALLTYPE2 _mtlockinit( PRTL_CRITICAL_SECTION pLk)
+{
+
+#ifdef	_CRUISER_
+	if ( DOSCREATEMUTEXSEM(NULL, pLk, 0, 0) != 0)
+		_FATAL;
+#else	/* ndef _CRUISER_ */
+#ifdef	_WIN32_
+	/*
+	 * Initialize the critical section.
+	 */
+	InitializeCriticalSection( pLk );
+#else	/* ndef _WIN32_ */
+#error ERROR - ONLY CRUISER OR WIN32 TARGET SUPPORTED!
+#endif	/* _WIN32_ */
+#endif	/* _CRUISER_ */
+
+}
+
+void _CALLTYPE2 _mtlock ( PRTL_CRITICAL_SECTION pLk)
+{
+#ifdef	_CRUISER_
+
+	if (DOSREQUESTMUTEXSEM(pLk,-1) != 0)
+		_FATAL;
+
+#else	/* ndef _CRUISER_ */
+
+#ifdef	_WIN32_
+
+	/*
+	 * Enter the critical section.
+	 */
+	EnterCriticalSection( pLk );
+
+#else	/* ndef _WIN32_ */
+
+#error ERROR - ONLY CRUISER OR WIN32 TARGET SUPPORTED!
+
+#endif	/* _WIN32_ */
+
+#endif	/* _CRUISER_ */
+
+}
+
+void _CALLTYPE2 _mtunlock ( PRTL_CRITICAL_SECTION pLk)
+{
+#ifdef	_CRUISER_
+	/*
+	 * Release the lock
+	 */
+	if (DOSRELEASEMUTEXSEM(pLk) != 0)
+		_FATAL;
+
+#else	/* ndef _CRUISER_ */
+
+#ifdef	_WIN32_
+
+	/*
+	 * leave the critical section.
+	 */
+	LeaveCriticalSection( pLk );
+
+#else	/* ndef _WIN32_ */
+
+#error ERROR - ONLY CRUISER OR WIN32 TARGET SUPPORTED!
+
+#endif	/* _WIN32_ */
+
+#endif	/* _CRUISER_ */
+
+}
+
+#endif  /* MTHREAD */
+
+
+
+
+
+
+
+
+
+
+
+/* history: mlock.c */
+
+#if 0
+#ifdef DEBUG
+#include <assert.h>
+#endif
+
+/*
+ * Local routines
+ */
+
+static void _CALLTYPE1 _lock_create (unsigned);
+
+#ifdef DEBUG
+static struct _debug_lock * _CALLTYPE1 _lock_validate(int);
+#endif
+
+
+/*
+ * Global Data
+ */
+
+#ifdef _CRUISER_
+/*
+ * Lock Table
+ * This table contains the semaphore handle for each lock (lock number
+ * is used as an index into the table).
+ */
+
+unsigned _locktable[_TOTAL_LOCKS];		/* array of locks */
+
+#else	/* ndef _CRUISER_ */
+
+#ifdef	_WIN32_
+/*
+ * Lock Table
+ * This table contains the critical section management structure of each
+ * lock.
+ */
+
+RTL_CRITICAL_SECTION _locktable[_TOTAL_LOCKS];	/* array of locks */
+
+#else	/* ndef _WIN32_ */
+
+#error ERROR - ONLY CRUISER OR WIN32 TARGET SUPPORTED!
+
+#endif	/* _WIN32_ */
+
+#endif	/* _CRUISER_ */
+
+/*
+ * Lock Bit Map
+ * This table contains one bit for each lock (i.e., each entry in the
+ * _locktable[] array).
+ *
+ *	 If bit = 0, lock has not been created/opened
+ *	 If bit = 1, lock has been created/opened
+ */
+
+char _lockmap[(_TOTAL_LOCKS/CHAR_BIT)+1];	/* lock bit map */
+
+
+#ifdef _LOCKCOUNT
+/*
+ * Total number of locks held
+ */
+
+unsigned _lockcnt = 0;
+#endif
+
+
+#ifdef DEBUG
+/*
+ * Lock Debug Data Table Segment
+ * Contains debugging data for each lock.
+ */
+
+struct _debug_lock _debug_locktable[_TOTAL_LOCKS];
+
+#endif
+
+#define _FATAL	_amsg_exit(_RT_LOCK)
+
+/***
+* Bit map macros
+*
+*Purpose:
+*	_CLEARBIT() - Clear the specified bit
+*	_SETBIT()   - Set the specified bit
+*	_TESTBIT()  - Test the specified bit
+*
+*Entry:
+*	char a[] = character array
+*	unsigned b = bit number (0-based, range from 0 to whatever)
+*	unsigned x = bit number (0-based, range from 0 to 31)
+*
+*Exit:
+*	_CLEARBIT() = void
+*	_SETBIT()   = void
+*	_TESTBIT()  = 0 or 1
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+/*
+ * Macros for use when managing a bit in a character array (e.g., _lockmap)
+ * a = character array
+ * b = bit number (0-based)
+ */
+
+#define _CLEARBIT(a,b) \
+		( a[b>>3] &= (~(1<<(b&7))) )
+
+#define _SETBIT(a,b) \
+		( a[b>>3] |= (1<<(b&7)) )
+
+#define _TESTBIT(a,b) \
+		( a[b>>3] & (1<<(b&7)) )
+
+/*
+ * Macros for use when managing a bit in an unsigned int
+ * x = bit number (0-31)
+ */
+
+#define _BIT_INDEX(x)	(1 << (x & 0x1F))
+
+
+/***
+*_mtinitlocks() - Initialize the semaphore lock data base
+*
+*Purpose:
+*	Initialize the mthread semaphore lock data base.
+*
+*	NOTES:
+*	(1) Only to be called ONCE at startup
+*	(2) Must be called BEFORE any mthread requests are made
+*
+*	Schemes for creating the mthread locks:
+*
+*	Create the locks one at a time on demand the first
+*	time the lock is attempted.  This is more complicated but
+*	is much faster than creating them all at startup time.
+*	These is currently the default scheme.
+*
+*	Create and open the semaphore that protects the lock data
+*	base.
+*
+*Entry:
+*	<none>
+*
+*Exit:
+*	returns on success
+*	calls _amsg_exit on failure
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+void _CALLTYPE1 _mtinitlocks (
+	void
+	)
+{
+
+	/*
+	 * All we need to do is create the lock table lock
+	 */
+
+	_lock_create(_LOCKTAB_LOCK);
+
+	/*
+	 * Make sure the assumptions we make in this source are correct.
+	 * The following is a tricky way to validate sizeof() assumptions
+	 * at compile time without generating any runtime code (can't
+	 * use sizeof() in an #ifdef).	If the assumption fails, the
+	 * compiler will generate a divide by 0 error.
+	 *
+	 * This here only because it must be inside a subroutine.
+	 */
+
+	( (sizeof(char) == 1) ? 1 : (1/0) );
+	( (sizeof(int) == 4) ? 1 : (1/0) );
+
+}
+
+
+/***
+*_lock_create() - Create and open a lock
+*
+*Purpose:
+*	Create and open a mthread lock.
+*
+*	NOTES:
+*
+*	(1) The caller must have previously determined that the lock
+*	needs to be created/opened (and this hasn't already been done).
+*
+*	(2) The caller must have aquired the _LOCKTAB_LOCK, if needed.
+*	(The only time this isn't required is at init time.)
+*
+*Entry:
+*	unsigned locknum = lock to create
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static void _CALLTYPE1 _lock_create (
+	unsigned locknum
+	)
+{
+
+#ifdef DEBUG
+	/*
+	 * See if the lock already exists; if so, die.
+	 */
+
+	if (_TESTBIT(_lockmap, locknum))
+		_FATAL;
+#endif
+
+	/*
+	 * Convert the lock number into a lock address
+	 * and create the semaphore.
+	 */
+#ifdef	_CRUISER_
+
+	if ( DOSCREATEMUTEXSEM(NULL, &_locktable[locknum], 0, 0) != 0)
+		_FATAL;
+
+#else	/* ndef _CRUISER_ */
+
+#ifdef	_WIN32_
+
+	/*
+	 * Convert the lock number into a lock address
+	 * and initialize the critical section.
+	 */
+	InitializeCriticalSection( &_locktable[locknum] );
+
+#else	/* ndef _WIN32_ */
+
+#error ERROR - ONLY CRUISER OR WIN32 TARGET SUPPORTED!
+
+#endif	/* _WIN32_ */
+
+#endif	/* _CRUISER_ */
+
+	/*
+	 * Set the appropriate bit in the lock bit map.
+	 */
+
+	_SETBIT(_lockmap, locknum);
+
+}
+
+
+/***
+* _lock_stream, etc. - Routines to lock/unlock streams, files, etc.
+*
+*Purpose:
+*	_lock_stream = Lock a stdio stream
+*	_unlock_stream = Unlock a stdio stream
+*	_lock_file = Lock a lowio file
+*	_unlock_file = Unlock a lowio file
+*
+*Entry:
+*	stream/file identifier
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+void _CALLTYPE2 _lock_stream (
+	int stream_id
+	)
+{
+	_lock(stream_id+_STREAM_LOCKS);
+}
+
+void _CALLTYPE2 _unlock_stream (
+	int stream_id
+	)
+{
+	_unlock(stream_id+_STREAM_LOCKS);
+}
+
+void _CALLTYPE2 _lock_file (
+	int fh
+	)
+{
+	_lock(fh+_FH_LOCKS);
+}
+
+void _CALLTYPE2 _unlock_file (
+	int fh
+	)
+{
+	_unlock(fh+_FH_LOCKS);
+}
+
+
+/***
+* _lock - Acquire a multi-thread lock
+*
+*Purpose:
+*	Note that it is legal for a thread to aquire _EXIT_LOCK1
+*	multiple times.
+*
+*Entry:
+*	locknum = number of the lock to aquire
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+void _CALLTYPE2 _lock (
+	int locknum
+	)
+{
+
+#ifdef DEBUG
+	struct _debug_lock *deblock;
+	unsigned tidbit;
+#endif
+
+	/*
+	 * Create/open the lock, if necessary
+	 */
+
+	if (!_TESTBIT(_lockmap, locknum)) {
+
+		_mlock(_LOCKTAB_LOCK);	/*** WARNING: Recursive lock call ***/
+
+		/* if lock still doesn't exist, create it */
+
+		if (!_TESTBIT(_lockmap, locknum))
+			_lock_create(locknum);
+
+		_munlock(_LOCKTAB_LOCK);
+
+	}
+
+#ifdef DEBUG
+	/*
+	 * Validate the lock and get pointer to debug lock structure, etc.
+	 */
+
+	deblock = _lock_validate(locknum);
+
+#ifdef	_CRUISER_
+
+	tidbit = _BIT_INDEX(*_threadid);
+
+#else	/* ndef _CRUISER_ */
+
+#ifdef	_WIN32_
+
+	/*
+	 * Set tidbit to 2**(index of ptd[] entry).
+	 *
+	 * call non-locking form of _getptd to avoid recursing
+	 */
+	tidbit = _getptd_lk() - _ptd;	/* index of _ptd[] entry */
+
+	tidbit = _BIT_INDEX(tidbit);
+
+#else	/* ndef _WIN32_ */
+
+#error ERROR - ONLY CRUISER OR WIN32 TARGET SUPPORTED!
+
+#endif	/* _WIN32_ */
+
+#endif	/* _CRUISER_ */
+
+	/*
+	 * Make sure we're not trying to get lock we already have
+	 * (except for _EXIT_LOCK1).
+	 */
+
+	if (locknum != _EXIT_LOCK1)
+		if ((deblock->holder) & tidbit)
+			_FATAL;
+
+	/*
+	 * Set waiter bit for this thread
+	 */
+
+	deblock->waiters |= tidbit;
+
+#endif	/* DEBUG */
+
+	/*
+	 * Get the lock
+	 */
+
+#ifdef _LOCKCOUNT
+	_lockcnt++;
+#endif
+
+#ifdef	_CRUISER_
+
+	if (DOSREQUESTMUTEXSEM(_locktable[locknum],-1) != 0)
+		_FATAL;
+
+#else	/* ndef _CRUISER_ */
+
+#ifdef	_WIN32_
+
+	/*
+	 * Enter the critical section.
+	 */
+	EnterCriticalSection( &_locktable[locknum] );
+
+#else	/* ndef _WIN32_ */
+
+#error ERROR - ONLY CRUISER OR WIN32 TARGET SUPPORTED!
+
+#endif	/* _WIN32_ */
+
+#endif	/* _CRUISER_ */
+
+#ifdef DEBUG
+	/*
+	 * Clear waiter bit
+	 */
+
+	deblock->waiters &= (~tidbit);
+
+	/*
+	 * Make sure there are no lock holders (unless this is
+	 * _EXIT_LOCK1); then set holder bit and bump lock count.
+	 */
+
+	assert(THREADINTS==1);
+
+	if (locknum != _EXIT_LOCK1)
+		if ( (unsigned) deblock->holder != 0)
+		       _FATAL;
+
+	deblock->holder &= tidbit;
+	deblock->lockcnt++;
+
+#endif
+
+}
+
+
+/***
+* _unlock - Release multi-thread lock
+*
+*Purpose:
+*	Note that it is legal for a thread to aquire _EXIT_LOCK1
+*	multiple times.
+*
+*Entry:
+*	locknum = number of the lock to release
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+void _CALLTYPE2 _unlock (
+	int locknum
+	)
+{
+#ifdef DEBUG
+	struct _debug_lock *deblock;
+	unsigned tidbit;
+#endif
+
+#ifdef DEBUG
+	/*
+	 * Validate the lock and get pointer to debug lock structure, etc.
+	 */
+
+	deblock = _lock_validate(locknum);
+
+#ifdef	_CRUISER_
+
+	tidbit = _BIT_INDEX(*_threadid);
+
+#else	/* ndef _CRUISER_ */
+
+#ifdef	_WIN32_
+
+	/*
+	 * Set tidbit to 2**(index of ptd[] entry).
+	 */
+	tidbit = _getptd_lk() - _ptd;	/* index of _ptd[] entry */
+
+	tidbit = _BIT_INDEX(tidbit);
+
+#else	/* ndef _WIN32_ */
+
+#error ERROR - ONLY CRUISER OR WIN32 TARGET SUPPORTED!
+
+#endif	/* _WIN32_ */
+
+#endif	/* _CRUISER_ */
+
+	/*
+	 * Make sure we hold this lock then clear holder bit.
+	 * [Note: Since it is legal to aquire _EXIT_LOCK1 several times,
+	 * it's possible the holder bit is already clear.]
+	 */
+
+	if (locknum != _EXIT_LOCK1)
+		if (!((deblock->holder) & tidbit))
+			_FATAL;
+
+	deblock->holder &= (~tidbit);
+
+	/*
+	 * See if anyone else is waiting for this lock.
+	 */
+
+	assert(THREADINTS==1);
+
+	if ((unsigned) deblock->waiters != 0)
+		deblock->collcnt++;
+
+#endif
+
+#ifdef	_CRUISER_
+
+	/*
+	 * Release the lock
+	 */
+	if (DOSRELEASEMUTEXSEM(_locktable[locknum]) != 0)
+		_FATAL;
+
+#else	/* ndef _CRUISER_ */
+
+#ifdef	_WIN32_
+
+	/*
+	 * leave the critical section.
+	 */
+	LeaveCriticalSection( &_locktable[locknum] );
+
+#else	/* ndef _WIN32_ */
+
+#error ERROR - ONLY CRUISER OR WIN32 TARGET SUPPORTED!
+
+#endif	/* _WIN32_ */
+
+#endif	/* _CRUISER_ */
+
+#ifdef _LOCKCOUNT
+	_lockcnt--;
+#endif
+
+}
+
+
+/*
+ * Debugging code
+ */
+
+#ifdef DEBUG
+
+/***
+*_lock_validate() - Validate a lock
+*
+*Purpose:
+*	Debug lock validations common to both lock and unlock.
+*
+*Entry:
+*	lock number
+*
+*Exit:
+*	ptr to lock's debug structure
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+static struct _debug_lock * _CALLTYPE1 _lock_validate (
+	int locknum
+	)
+{
+	/*
+	 * Make sure lock is legal
+	 */
+
+	if (locknum > _TOTAL_LOCKS)
+		_FATAL;
+
+#ifdef	_CRUISER_
+
+	/*
+	 * Make sure threadid is in range
+	 */
+
+	if (*_threadid > MAXTHREADID)
+		_FATAL;
+
+#endif	/* _CRUISER_ */
+
+	/*
+	 * Return pointer to this lock's debug structure
+	 */
+
+	return(&_debug_locktable[locknum]);
+
+}
+
+
+/***
+*_fh_locknum() - Return the lock number for a file handle
+*
+*Purpose:
+*
+*Entry:
+*	int fh = file handle
+*
+*Exit:
+*	int locknum = corresponding lock number
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int  _CALLTYPE2 _fh_locknum (
+	int fh
+	)
+{
+	return(fh+_FH_LOCKS);
+}
+
+
+/***
+*_stream_locknum() - Return the lock number for a stream
+*
+*Purpose:
+*
+*Entry:
+*	int stream = stream number (i.e., offset of the stream
+*			in the _iob table)
+*
+*Exit:
+*	int locknum = corresponding lock number
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int  _CALLTYPE2 _stream_locknum (
+	int stream
+	)
+{
+	return(stream+_STREAM_LOCKS);
+}
+
+
+#ifdef	_CRUISER_
+
+/***
+*_check_lock() - Make sure a lock is in good shape
+*
+*Purpose:
+*	This routine checks to make sure that a lock is in a 'good'
+*	released state.  That is, abort if any of the following
+*	are true:
+*		(1) lock is held
+*		(2) holder bits are set
+*		(3) waiter bits are set
+*
+*	NOTE: This routine does NOT aquire the lock but simply looks
+*	at the lock data bases.
+*
+*Entry:
+*	locknum = number of the lock to aquire
+*
+*Exit:
+*	success = 0
+*	failure = !0
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int  _CALLTYPE2 _check_lock (
+	int locknum
+	)
+{
+	unsigned pid;
+	unsigned long tid;
+	unsigned cnt;
+	struct _debug_lock *deblock;
+
+	/*
+	 * See if lock exists.
+	 */
+
+	if (_TESTBIT(_lockmap, locknum)) {
+
+		/*
+		 * Lock exists.  Ask the OS about the lock and
+		 * make sure lock isn't held.
+		 */
+
+		if (DOSQUERYMUTEXSEM(_locktable[locknum], &pid, &tid, &cnt) != 0)
+			goto error_return;
+
+		if (cnt != 0)
+			goto error_return;
+	}
+
+	else {
+
+		/*
+		 * Lock doesn't exist, handle better be 0.
+		 */
+
+		if (_locktable[locknum] != 0)
+			goto error_return;
+	}
+
+
+	/*
+	 * Make sure there are no lock waiters or holders.
+	 */
+
+	assert(THREADINTS==1);
+
+	if ((deblock->waiters != 0) || (deblock->holder != 0))
+		goto error_return;
+
+	/*
+	 * Good Return
+	 */
+
+	return(0);
+
+	/*
+	 * Error return
+	 */
+
+error_return:
+	return(-1);
+
+}
+
+#endif	/* _CRUISER_ */
+
+
+/***
+*_collide_cnt() - Return the collision count for a lock
+*
+*Purpose:
+*
+*Entry:
+*	int lock = lock number
+*
+*Exit:
+*	int count = collision count
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int  _CALLTYPE2 _collide_cnt (
+	int locknum
+	)
+{
+	return(_debug_locktable[locknum].collcnt);
+}
+
+
+/***
+*_lock_cnt() - Return the lock count for a lock
+*
+*Purpose:
+*
+*Entry:
+*	int lock = lock number
+*
+*Exit:
+*	int count = lock count
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int  _CALLTYPE2 _lock_cnt (
+	int locknum
+	)
+{
+	return(_debug_locktable[locknum].lockcnt);
+}
+
+
+/***
+*_lock_exist() - Check to see if a lock exists
+*
+*Purpose:
+*	Test lock bit map to see if the lock has
+*	been created or not.
+*
+*Entry:
+*	int lock = lock number
+*
+*Exit:
+*	int 0 = lock has NOT been created
+*	    1 = lock HAS been created
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int  _CALLTYPE2 _lock_exist (
+	int locknum
+	)
+{
+	if (_TESTBIT(_lockmap, locknum))
+		return(1);
+	else
+		return(0);
+}
+
+#endif
+#endif
diff --git a/private/crt32/iostream/ofstream.cxx b/private/crt32/iostream/ofstream.cxx
new file mode 100644
index 000000000..cf915082b
--- /dev/null
+++ b/private/crt32/iostream/ofstream.cxx
@@ -0,0 +1,239 @@
+/***
+*ofstream.cxx -
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the member functions for the ofstream class.
+*
+*Revision History:
+*	09-21-91   KRS  Created.  Split up fstream.cxx for granularity.
+*	10-22-91   KRS  C700 #4883: fix error status for ofstream::open().
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <string.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <sys\types.h>
+#include <io.h>
+#include <fstream.h>
+#pragma hdrstop
+
+#include <sys\stat.h>
+
+/***
+*ofstream::ofstream() - ofstream default constructor
+*
+*Purpose:
+*	Default constructor for ofstream objects.
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*
+*******************************************************************************/
+	ofstream::ofstream()
+: ostream(new filebuf)
+{
+    delbuf(1);
+    // CONSIDER: do anything else?
+}
+
+/***
+*ofstream::ofstream(const char * name, int mode, int prot) - ofstream ctor
+*
+*Purpose:
+*	Constructor for ofstream objects.  Creates an associated filebuf object,
+*	opens a named file and attaches it to the new filebuf.
+*
+*Entry:
+*	name = filename to open.
+*	mode = see filebuf::open mode argument.  ios::out is implied.
+*	prot = see filebuf::open share argument
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*	Sets failbit if open fails.
+*
+*******************************************************************************/
+	ofstream::ofstream(const char * name, int mode, int prot)
+: ostream(new filebuf)
+{
+    delbuf(1);
+    if (!(rdbuf()->open(name, (mode|ios::out), prot)))
+	state |= ios::failbit;
+}
+
+/***
+*ofstream::ofstream(filedesc fd) - ofstream constructor
+*
+*Purpose:
+*	Constructor for ofstream objects.  Creates an associated filebuf object
+*	and attaches it to the given file descriptor.
+*
+*Entry:
+*	fd = file descriptor of file previously opened using _open or _sopen.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*
+*******************************************************************************/
+	ofstream::ofstream(filedesc _fd)
+: ostream(new filebuf(_fd))
+{
+    delbuf(1);
+}
+
+/***
+*ofstream::ofstream(filedesc fd, char * sbuf, int len) - ofstream constructor
+*
+*Purpose:
+*	Constructor for ofstream objects.  Creates an associated filebuf object
+*	and attaches it to the given file descriptor.  Filebuf object uses
+*	user-supplied buffer or is unbuffered if sbuf or len = 0.
+*
+*Entry:
+*	fd   = file descriptor of file previously opened using _open or _sopen.
+*	sbuf = pointer to character buffer or NULL if request for unbuffered.
+*	len  = lenght of character buffer sbuf or 0 if request for unbuffered.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*
+*******************************************************************************/
+	ofstream::ofstream(filedesc _fd, char * sbuf, int len)
+: ostream(new filebuf(_fd, sbuf, len))
+{
+    delbuf(1);
+}
+
+/***
+*ofstream::~ofstream() - ofstream destructor
+*
+*Purpose:
+*	ofstream destructor.
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*
+*******************************************************************************/
+	ofstream::~ofstream()
+{
+    // CONSIDER: do anything else?
+}
+
+/***
+*streambuf* ofstream::setbuf(char * ptr, int len) - setbuf function
+*
+*Purpose:
+*	ofstream setbuf function
+*
+*Entry:
+*	ptr = pointer to buffer or NULL for unbuffered.
+*	len = length of buffer or zero for unbuffered.
+*
+*Exit:
+*	Returns rdbuf() or NULL if error.
+*
+*Exceptions:
+*	If ofstream is already open or if rdbuf()->setbuf fails, sets failbit
+*	and returns NULL.
+*
+*******************************************************************************/
+streambuf * ofstream::setbuf(char * ptr, int len)
+{
+    if ((is_open()) || (!(rdbuf()->setbuf(ptr, len))))
+	{
+	clear(state | ios::failbit);
+	return NULL;
+	}
+    // UNDONE: turn off input buffer??
+    return rdbuf();
+}
+
+/***
+*void ofstream::attach(filedesc _fd) - attach member function
+*
+*Purpose:
+*	ofstream attach member function.  Just calls rdbuf()->attach().
+*
+*Entry:
+*	_fd = file descriptor of previously opened file.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*	Sets failbit if rdbuf()->attach fails.
+*
+*******************************************************************************/
+void ofstream::attach(filedesc _fd)	// CONSIDER: inline?
+{
+    if (!(rdbuf()->attach(_fd)))
+	clear(state | ios::failbit);
+}
+
+/***
+*void ofstream::open(const char * name, int mode, int prot) - ofstream open()
+*
+*Purpose:
+*	Opens a named file and attaches it to the associated filebuf.
+*	Just calls rdbuf()->open().
+*
+*Entry:
+*	name = filename to open.
+*	mode = see filebuf::open mode argument.  ios::out is implied.
+*	prot = see filebuf::open share argument
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*	Sets failbit if already open or rdbuf()->open() fails.
+*
+*******************************************************************************/
+void ofstream::open(const char * name, int mode, int prot)
+{
+    if (is_open() || !(rdbuf()->open(name, (mode|ios::out), prot)))
+	clear(state | ios::failbit);
+}
+
+/***
+*void ofstream::close() - close member function
+*
+*Purpose:
+*	ofstream close member function.  Just calls rdbuf()->close().
+*	Clears rdstate() error bits if successful.
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*	Sets failbit if rdbuf()->close fails.
+*
+*******************************************************************************/
+void ofstream::close()
+{
+    clear((rdbuf()->close()) ? 0 : (state | ios::failbit));
+}
diff --git a/private/crt32/iostream/ostrchar.cxx b/private/crt32/iostream/ostrchar.cxx
new file mode 100644
index 000000000..3e8bb07a2
--- /dev/null
+++ b/private/crt32/iostream/ostrchar.cxx
@@ -0,0 +1,39 @@
+/***
+* ostrchar.cxx - definitions for ostream class operator<<(char) functions.
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the member function definitions for ostream operator<<(char).
+*
+*Revision History:
+*	09-23-91   KRS	Created.  Split out from ostream.cxx for granularity.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <iostream.h>
+#pragma hdrstop
+
+// note: called inline by char and signed char versions:
+ostream&  ostream::operator<<(unsigned char c)
+{
+    if (opfx())
+	{
+	if (x_width)
+	    {
+	    _WINSTATIC char outc[2];
+	    outc[0] = c;
+	    outc[1] = '\0';
+	    writepad("",outc);
+	    }
+	else if (bp->sputc(c)==EOF)
+	    {
+	    if (bp->overflow(c)==EOF)
+		state |= (badbit|failbit);  // fatal error?
+	    }
+	osfx();
+	}
+    return *this;
+}
diff --git a/private/crt32/iostream/ostrdbl.cxx b/private/crt32/iostream/ostrdbl.cxx
new file mode 100644
index 000000000..1d8f22060
--- /dev/null
+++ b/private/crt32/iostream/ostrdbl.cxx
@@ -0,0 +1,65 @@
+/***
+* ostrdbl.cxx - definitions for ostream class operator<<(double) functions
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the member function definitions for ostream operator<<(double).
+*
+*Revision History:
+*	09-23-91   KRS	Created.  Split out from ostream.cxx for granularity.
+*	10-24-91   KRS	Combine float version with double.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <iostream.h>
+#pragma hdrstop
+
+#pragma check_stack(on)		// large buffer(s)
+
+ostream& ostream::operator<<(double f)
+{
+_WINSTATIC char obuffer[24];
+_WINSTATIC char fmt[8];
+_WINSTATIC char leader[4];
+    char * optr = obuffer;
+    int x = 0;
+
+    // x_floatused nonzero indicates called for float, not double
+    unsigned int curprecision = (x_floatused) ? FLT_DIG : DBL_DIG;
+    x_floatused = 0;	// reset for next call
+
+    curprecision = __min((unsigned)x_precision,curprecision);
+
+    if (opfx()) {
+	if (x_flags & ios::showpos)
+	    leader[x++] = '+';
+	if (x_flags & ios::showpoint)
+	    leader[x++] = '#';	// show decimal and trailing zeros
+	leader[x] = '\0';
+	x = sprintf(fmt,"%%%s.%.0ug",leader,curprecision) - 1;
+	if ((x_flags & ios::floatfield)==ios::fixed)
+	    fmt[x] = 'f';
+	else
+	    {
+	    if ((x_flags & ios::floatfield)==ios::scientific)
+		fmt[x] = 'e';
+	    if (x_flags & uppercase)
+		fmt[x] = (char)toupper(fmt[x]);
+	    }
+	
+	sprintf(optr,fmt,f);
+	x = 0;
+	if (*optr=='+' || *optr=='-')
+	    leader[x++] = *(optr++);
+	leader[x] = '\0';
+	writepad(leader,optr);
+	osfx();
+	}
+    return *this;
+}
diff --git a/private/crt32/iostream/ostream.cxx b/private/crt32/iostream/ostream.cxx
new file mode 100644
index 000000000..69eaefabe
--- /dev/null
+++ b/private/crt32/iostream/ostream.cxx
@@ -0,0 +1,229 @@
+/***
+* ostream.cxx - definitions for ostream and ostream_withassign classes
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the core member function definitions for ostream and
+*	ostream_withassign classes.
+*
+*Revision History:
+*	07-01-91   KRS	Created.
+*	08-19-91   KRS	Corrected my interpretation of the spec. for negative
+*			hex or octal integers.
+*	08-20-91   KRS  Replace 'clear(x)' with 'state |= x'.
+*			Skip text translation for write().
+*	08-26-91   KRS	Modify to work with DLL's/MTHREAD.
+*	09-05-91   KRS	Fix opfx() to flush tied ostream, not current one.
+*	09-09-91   KRS	Remove sync_with_stdio() call from Iostream_init().
+*			Reinstate text-translation (by default) for write().
+*	09-19-91   KRS	Add opfx()/osfx() calls to put() and write().
+*			Schedule destruction of predefined streams.
+*	09-23-91   KRS	Split up for granularity.
+*	10-04-91   KRS	Use bp->sputc, not put(), in writepad().
+*	10-24-91   KRS	Added initialization of x_floatused.
+*	11-04-91   KRS	Make constructors work with virtual base.
+*	11-20-91   KRS	Add/fix copy constructor and assignment operators.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <iostream.h>
+#pragma hdrstop
+
+int ostream::opfx()
+{
+    lock();
+    if (state)
+	{
+	state |= ios::failbit;	// CONSIDER???
+	unlock();
+	return 0;
+	}
+    if (x_tie)
+	{
+	x_tie->flush();
+	}
+    lockbuf();
+    return(1);	// return non-zero
+}
+
+void ostream::osfx()
+{
+    x_width = 0;
+    if (x_flags & unitbuf)
+	{
+	if (bp->sync()==EOF)
+	    state = failbit | badbit;
+	}
+#ifndef	_WINDLL
+    if (x_flags & ios::stdio)
+	{
+	if (fflush(stdout)==EOF)
+	    state |= failbit;
+	if (fflush(stderr)==EOF)
+	    state |= failbit;
+	}
+#endif
+    unlockbuf();
+    unlock();
+}
+
+// note: called inline by char and signed char versions:
+#if 0
+ostream&  ostream::operator<<(unsigned char c)
+{
+    if (opfx())
+	{
+	if (x_width)
+	    {
+	    _WINSTATIC char outc[2];
+	    outc[0] = c;
+	    outc[1] = '\0';
+	    writepad("",outc);
+	    }
+	else if (bp->sputc(c)==EOF)
+	    {
+	    if (bp->overflow(c)==EOF)
+		state |= (badbit|failbit);  // fatal error?
+	    }
+	osfx();
+	}
+    return *this;
+}
+#endif
+
+// note: called inline by unsigned char * and signed char * versions:
+ostream& ostream::operator<<(const char * s)
+{
+    if (opfx()) {
+	writepad("",s);
+	osfx();
+    }
+    return *this;
+}
+
+ostream& ostream::flush()
+{
+    lock();
+    lockbuf();
+    if (bp->sync()==EOF)
+	state |= ios::failbit;
+    unlockbuf();
+    unlock();
+    return(*this);
+}
+
+	ostream::ostream()
+// : ios()
+{
+	x_floatused = 0;
+	// CONSIDER: do anything else?
+}
+
+	ostream::ostream(streambuf* _inistbf)
+// : ios()
+{
+	init(_inistbf);
+
+	x_floatused = 0;
+	// CONSIDER: do anything else?
+}
+
+	ostream::ostream(const ostream& _ostrm)
+// : ios()
+{
+	init(_ostrm.rdbuf());
+
+	x_floatused = 0;
+	// CONSIDER: do anything else?
+}
+
+	ostream::~ostream()
+// : ~ios()
+{
+	// CONSIDER: do anything else?
+}
+
+// used in ios::sync_with_stdio()
+ostream& ostream::operator=(streambuf * _sbuf)
+{
+// consider: may be some redundency here, depending on spec.
+
+	if (delbuf() && rdbuf())
+	    delete rdbuf();
+	bp = 0;
+
+	this->ios::operator=(ios());	// initialize ios members
+	delbuf(0);			// important!
+	init(_sbuf);
+
+//	x_floatused = 0;		// not necessary
+
+	return *this;
+}
+
+
+	ostream_withassign::ostream_withassign()
+: ostream()
+{
+	// CONSIDER: do anything else?
+}
+
+	ostream_withassign::ostream_withassign(streambuf* _os)
+: ostream(_os)
+{
+	// CONSIDER: do anything else?
+}
+
+	ostream_withassign::~ostream_withassign()
+// : ~ostream()
+{
+;	// CONSIDER: do anything else?
+}
+
+ostream& ostream::writepad(const char * leader, const char * value)
+
+	{
+unsigned int len, leadlen;
+long padlen;
+	leadlen = strlen(leader);
+	len = strlen(value);
+	padlen = (((unsigned)x_width) > (len+leadlen)) ? ((unsigned)x_width) - (len + leadlen) : 0;
+	if (!(x_flags & (left|internal)))  // default is right-adjustment
+	    {
+	    while (padlen-- >0)
+		{
+		if (bp->sputc((unsigned char)x_fill)==EOF)
+		    state |= (ios::failbit|ios::badbit);
+		}
+	    }
+	if (leadlen)
+	    {
+	    if ((unsigned)bp->sputn(leader,leadlen)!=leadlen)
+	        state |= (failbit|badbit);	// CONSIDER: right error?
+	    }
+	if (x_flags & internal) 
+	    {
+	    while (padlen-- >0)
+		{
+		if (bp->sputc((unsigned char)x_fill)==EOF)
+		    state |= (ios::failbit|ios::badbit);
+		}
+	    }
+	if ((unsigned)bp->sputn(value,len)!=len)
+	    state |= (failbit|badbit);	// CONSIDER: right error?
+	if (x_flags & left) 
+	    {
+	    while ((padlen--)>0)        // left-adjust if necessary
+		{
+		if (bp->sputc((unsigned char)x_fill)==EOF)
+		    state |= (ios::failbit|ios::badbit);
+		}
+	    }
+	return (*this);
+	}
diff --git a/private/crt32/iostream/ostream1.cxx b/private/crt32/iostream/ostream1.cxx
new file mode 100644
index 000000000..5f486537e
--- /dev/null
+++ b/private/crt32/iostream/ostream1.cxx
@@ -0,0 +1,70 @@
+/***
+* ostream1.cxx - definitions for ostream class non-core member functions
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the non-core member function definitions for ostream class.
+*
+*Revision History:
+*	07-01-91   KRS	Created.  Split out from ostream.cxx for granularity.
+*	11-20-91   KRS	Make operator= inline.
+*	03-30-92   KRS	Add multithread locks.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <iostream.h>
+#pragma hdrstop
+
+ostream& ostream::seekp(streampos _strmp)
+{
+    lockbuf();
+
+    if (bp->seekpos(_strmp, ios::out)==EOF)
+	clear(state | failbit);
+
+    unlockbuf();
+    return(*this);
+}
+
+ostream& ostream::seekp(streamoff _strmf, seek_dir _sd)
+{
+    lockbuf();
+
+    if (bp->seekoff(_strmf, _sd, ios::out)==EOF)
+	clear(state | failbit);
+
+    unlockbuf();
+    return(*this);
+}
+
+streampos ostream::tellp()
+{
+    streampos retval;
+    lockbuf();
+
+    if ((retval=bp->seekoff(streamoff(0), ios::cur, ios::out))==EOF)
+	clear(state | failbit);
+
+    unlockbuf();
+    return(retval);
+}
+
+ostream& ostream::operator<<(streambuf * instm)
+{
+    int c;
+    if (opfx())
+	{
+	while ((c=instm->sbumpc())!=EOF)
+	    if (bp->sputc(c) == EOF)
+		{
+		state |= failbit;	// CONSIDER: is this redundent?
+		break;
+		}
+// CONSIDER: not very efficient in many cases
+	osfx();
+	}
+    return *this;
+}
diff --git a/private/crt32/iostream/ostrint.cxx b/private/crt32/iostream/ostrint.cxx
new file mode 100644
index 000000000..09cb6490e
--- /dev/null
+++ b/private/crt32/iostream/ostrint.cxx
@@ -0,0 +1,55 @@
+/***
+* ostrint.cxx - definitions for ostream class operator<<(int) member functions
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the member function definitions for ostream operator<<(int).
+*
+*Revision History:
+*	09-23-91   KRS	Created.  Split out from ostream.cxx for granularity.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdio.h>
+#include <iostream.h>
+#pragma hdrstop
+
+ostream& ostream::operator<<(int n)
+{
+_WINSTATIC char obuffer[12];
+_WINSTATIC char fmt[4] = "%d";
+_WINSTATIC char leader[4] = "\0\0";
+    if (opfx()) {
+
+	if (n) 
+	    {
+            if (x_flags & (hex|oct))
+		{
+		if (x_flags & hex)
+		    {
+		    if (x_flags & uppercase) 
+			fmt[1] = 'X';
+		    else
+			fmt[1] = 'x';
+		    leader[1] = fmt[1];   // 0x or 0X  (or \0X)
+		    }
+		else
+		    fmt[1] = 'o';
+		if (x_flags & showbase)
+	            leader[0] = '0';
+		}
+	    else if ((n>0) && (x_flags & showpos))
+		{
+		leader[0] = '+';
+		}
+	    }
+	sprintf(obuffer,fmt,n);
+	writepad(leader,obuffer);
+	osfx();
+    }
+    return *this;
+
+}
diff --git a/private/crt32/iostream/ostrldbl.cxx b/private/crt32/iostream/ostrldbl.cxx
new file mode 100644
index 000000000..0bb3fbfc7
--- /dev/null
+++ b/private/crt32/iostream/ostrldbl.cxx
@@ -0,0 +1,61 @@
+/***
+* ostrldbl.cxx - definitions for ostream class operator<<(long double) functs
+*
+*	Copyright (c) 1991-1993, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the member function definitions for ostream
+*	operator<<(long double).
+*
+*Revision History:
+*	09-23-91   KRS	Created.  Split out from ostream.cxx for granularity.
+*	10-24-91   KRS  Minor robustness work.
+*	05-10-93   CFW	Re-enable function.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <float.h>
+#include <iostream.h>
+#pragma hdrstop
+
+#pragma check_stack(on)		// large buffer(s)
+
+ostream& ostream::operator<<(long double f)
+{
+_WINSTATIC char obuffer[28];
+_WINSTATIC char fmt[12];
+_WINSTATIC char leader[4];
+    char * optr = obuffer;
+    int x = 0;
+    unsigned int curprecision = __min((unsigned)x_precision,LDBL_DIG);
+    if (opfx()) {
+	if (x_flags & ios::showpos)
+	    leader[x++] = '+';
+	if (x_flags & ios::showpoint)
+	    leader[x++] = '#';	// show decimal and trailing zeros
+	leader[x] = '\0';
+	x = sprintf(fmt,"%%%s.%.0uLg",leader,curprecision) - 1;
+	if ((x_flags & ios::floatfield)==ios::fixed)
+	    fmt[x] = 'f';
+	else
+	    {
+	    if ((x_flags & ios::floatfield)==ios::scientific)
+		fmt[x] = 'e';
+	    if (x_flags & uppercase)
+		fmt[x] = (char)toupper(fmt[x]);
+	    }
+	
+	sprintf(optr,fmt,f);
+	x = 0;
+	if (*optr=='+' || *optr=='-')
+	    leader[x++] = *(optr++);
+	leader[x] = '\0';
+	writepad(leader,optr);
+	osfx();
+	}
+    return *this;
+}
diff --git a/private/crt32/iostream/ostrlong.cxx b/private/crt32/iostream/ostrlong.cxx
new file mode 100644
index 000000000..959c5fb94
--- /dev/null
+++ b/private/crt32/iostream/ostrlong.cxx
@@ -0,0 +1,55 @@
+/***
+* ostrlong.cxx - definitions for ostream class operator<<(long) member functions
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the member function definitions for ostream operator<<(long).
+*
+*Revision History:
+*	09-23-91   KRS	Created.  Split out from ostream.cxx for granularity.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdio.h>
+#include <iostream.h>
+#pragma hdrstop
+
+ostream& ostream::operator<<(long n)
+{
+_WINSTATIC char obuffer[12];
+_WINSTATIC char fmt[4] = "%ld";
+_WINSTATIC char leader[4] = "\0\0";
+    if (opfx()) {
+
+	if (n) 
+	    {
+            if (x_flags & (hex|oct))
+		{
+		if (x_flags & hex)
+		    {
+		    if (x_flags & uppercase) 
+			fmt[2] = 'X';
+		    else
+			fmt[2] = 'x';
+		    leader[1] = fmt[2];   // 0x or 0X  (or \0X)
+		    }
+		else
+		    fmt[2] = 'o';
+		if (x_flags & showbase)
+	            leader[0] = '0';
+		}
+	    else if ((n>0) && (x_flags & showpos))
+		{
+		leader[0] = '+';
+		}
+	    }
+	sprintf(obuffer,fmt,n);
+	writepad(leader,obuffer);
+	osfx();
+    }
+    return *this;
+
+}
diff --git a/private/crt32/iostream/ostrptr.cxx b/private/crt32/iostream/ostrptr.cxx
new file mode 100644
index 000000000..adbb51607
--- /dev/null
+++ b/private/crt32/iostream/ostrptr.cxx
@@ -0,0 +1,41 @@
+/***
+* ostrptr.cxx - definitions for ostream operator<<(const void*) member function
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Member function definition for ostream operator<<(const void*).
+*
+*Revision History:
+*	09-23-91   KRS	Created.  Split out from ostream.cxx for granularity.
+*	06-03-92   KRS	CAV #1183: add 'const' to ptr output argument.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdio.h>
+#include <iostream.h>
+#pragma hdrstop
+
+ostream& ostream::operator<<(const void * ptr)
+{
+_WINSTATIC char obuffer[12];
+_WINSTATIC char fmt[4] = "%p";
+_WINSTATIC char leader[4] = "0x";
+    if (opfx())
+	{
+	if (ptr) 
+	    {
+	    if (x_flags & uppercase) 
+		leader[1] = 'X';
+//	    else		// initialized above by default
+//		leader[1] = 'x';
+	    }
+//CONSIDER: can we use and depend on out %p conversion to do this???
+	sprintf(obuffer,fmt,ptr);
+	writepad(leader,obuffer);
+	osfx();
+	}
+    return *this;
+}
diff --git a/private/crt32/iostream/ostrput.cxx b/private/crt32/iostream/ostrput.cxx
new file mode 100644
index 000000000..d1a51a5f8
--- /dev/null
+++ b/private/crt32/iostream/ostrput.cxx
@@ -0,0 +1,42 @@
+/***
+* ostrput.cxx - definitions for ostream classes put() and write() functions
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the member function definitions for ostream put() and write().
+*
+*Revision History:
+*	09-23-91   KRS	Created.  Split out from ostream.cxx for granularity.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <iostream.h>
+#pragma hdrstop
+	
+// note: called inline by char and signed char versions:
+ostream& ostream::put(unsigned char c)
+{
+    if (opfx())    	// CONSIDER: needed??
+	{
+	if (bp->sputc((int)c)==EOF)
+	    state |= (failbit|badbit);	// CONSIDER: right error?
+	osfx();
+	}
+    return(*this);
+}
+
+// note: called inline by unsigned char * and signed char * versions:
+ostream& ostream::write(const char * s, int n)
+{
+    if (opfx())		// CONSIDER: needed??
+	{
+// Note: 'n' treated as unsigned
+	if (bp->sputn(s,n)!=n)
+	    state |= (failbit|badbit);		// CONSIDER: right error?
+	osfx();
+	}
+    return(*this);
+}
diff --git a/private/crt32/iostream/ostrshrt.cxx b/private/crt32/iostream/ostrshrt.cxx
new file mode 100644
index 000000000..e4818c15d
--- /dev/null
+++ b/private/crt32/iostream/ostrshrt.cxx
@@ -0,0 +1,56 @@
+/***
+* ostrshrt.cxx - definitions for ostream class operator<<(short) member functions
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the member function definitions for ostream operator<<(short).
+*
+*Revision History:
+*	09-23-91   KRS	Created.  Split out from ostream.cxx for granularity.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <iostream.h>
+#pragma hdrstop
+
+ostream& ostream::operator<<(short n)
+{
+_WINSTATIC char obuffer[8];	// CONSIDER: assumes max int is 65535
+_WINSTATIC char fmt[4] = "%hd";
+_WINSTATIC char leader[4] = "\0\0";
+    if (opfx()) {
+
+	if (n) 
+	    {
+            if (x_flags & (hex|oct))
+		{
+		if (x_flags & hex)
+		    {
+		    if (x_flags & uppercase) 
+			fmt[2] = 'X';
+		    else
+			fmt[2] = 'x';
+		    leader[1] = fmt[2];   // 0x or 0X  (or \0X)
+		    }
+		else
+		    fmt[2] = 'o';
+		if (x_flags & showbase)
+	            leader[0] = '0';
+		}
+	    else if ((n>0) && (x_flags & showpos))
+		{
+		leader[0] = '+';
+		}
+	    }
+	sprintf(obuffer,fmt,n);
+	writepad(leader,obuffer);
+	osfx();
+    }
+    return *this;
+
+}
diff --git a/private/crt32/iostream/ostruint.cxx b/private/crt32/iostream/ostruint.cxx
new file mode 100644
index 000000000..f528fcc63
--- /dev/null
+++ b/private/crt32/iostream/ostruint.cxx
@@ -0,0 +1,55 @@
+/***
+* ostruint.cxx - definitions for ostream class operator<<(unsigned int) funct
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the member function definitions for ostream
+*	operator<<(unsigned int).
+*
+*Revision History:
+*	09-23-91   KRS	Created.  Split out from ostream.cxx for granularity.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdio.h>
+#include <iostream.h>
+#pragma hdrstop
+
+ostream& ostream::operator<<(unsigned int n)
+{
+_WINSTATIC char obuffer[12];
+_WINSTATIC char fmt[4] = "%u";
+_WINSTATIC char leader[4] = "\0\0";
+    if (opfx()) {
+	if (n) 
+	    {
+            if (x_flags & (hex|oct))
+		{
+		if (x_flags & hex)
+		    {
+		    if (x_flags & uppercase) 
+			fmt[1] = 'X';
+		    else
+			fmt[1] = 'x';
+		    leader[1] = fmt[1];   // 0x or 0X  (or \0X)
+		    }
+		else
+		    fmt[1] = 'o';
+		if (x_flags & showbase)
+	            leader[0] = '0';
+		}
+	    else if (x_flags & showpos)
+		{
+		leader[0] = '+';
+		}
+	    }
+	sprintf(obuffer,fmt,n);
+	writepad(leader,obuffer);
+	osfx();
+    }
+    return *this;
+
+}
diff --git a/private/crt32/iostream/ostrulng.cxx b/private/crt32/iostream/ostrulng.cxx
new file mode 100644
index 000000000..d09a5c9de
--- /dev/null
+++ b/private/crt32/iostream/ostrulng.cxx
@@ -0,0 +1,55 @@
+/***
+* ostrulng.cxx - definitions for ostream class operator<<(unsigned long) funct
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the member function definition for ostream
+*	operator<<(unsigned long).
+*
+*Revision History:
+*	09-23-91   KRS	Created.  Split out from ostream.cxx for granularity.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdio.h>
+#include <iostream.h>
+#pragma hdrstop
+
+ostream& ostream::operator<<(unsigned long n)
+{
+_WINSTATIC char obuffer[12];
+_WINSTATIC char fmt[4] = "%lu";
+_WINSTATIC char leader[4] = "\0\0";
+    if (opfx()) {
+	if (n) 
+	    {
+            if (x_flags & (hex|oct))
+		{
+		if (x_flags & hex)
+		    {
+		    if (x_flags & uppercase) 
+			fmt[2] = 'X';
+		    else
+			fmt[2] = 'x';
+		    leader[1] = fmt[2];   // 0x or 0X  (or \0X)
+		    }
+		else
+		    fmt[2] = 'o';
+		if (x_flags & showbase)
+	            leader[0] = '0';
+		}
+	    else if (x_flags & showpos)
+		{
+		leader[0] = '+';
+		}
+	    }
+	sprintf(obuffer,fmt,n);
+	writepad(leader,obuffer);
+	osfx();
+    }
+    return *this;
+
+}
diff --git a/private/crt32/iostream/ostrusht.cxx b/private/crt32/iostream/ostrusht.cxx
new file mode 100644
index 000000000..796ff3caf
--- /dev/null
+++ b/private/crt32/iostream/ostrusht.cxx
@@ -0,0 +1,56 @@
+/***
+* ostrusht.cxx - definition for ostream class operator<<(unsigned short) funct
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Contains the member function definition for ostream
+*	operator<<(unsigned short).
+*
+*Revision History:
+*	09-23-91   KRS	Created.  Split out from ostream.cxx for granularity.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <iostream.h>
+#pragma hdrstop
+
+ostream& ostream::operator<<(unsigned short n)
+{
+_WINSTATIC char obuffer[8];
+_WINSTATIC char fmt[4] = "%hu";
+_WINSTATIC char leader[4] = "\0\0";
+    if (opfx()) {
+	if (n) 
+	    {
+            if (x_flags & (hex|oct))
+		{
+		if (x_flags & hex)
+		    {
+		    if (x_flags & uppercase) 
+			fmt[2] = 'X';
+		    else
+			fmt[2] = 'x';
+		    leader[1] = fmt[2];   // 0x or 0X  (or \0X)
+		    }
+		else
+		    fmt[2] = 'o';
+		if (x_flags & showbase)
+	            leader[0] = '0';
+		}
+	    else if (x_flags & showpos)
+		{
+		leader[0] = '+';
+		}
+	    }
+	sprintf(obuffer,fmt,n);
+	writepad(leader,obuffer);
+	osfx();
+    }
+    return *this;
+
+}
diff --git a/private/crt32/iostream/sources b/private/crt32/iostream/sources
new file mode 100644
index 000000000..7c58ffce1
--- /dev/null
+++ b/private/crt32/iostream/sources
@@ -0,0 +1,83 @@
+!IF 0
+
+Copyright (c) 1992, Microsoft Corporation.  All rights reserved.
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+    Set MAKEFILE. for BLDCRT=1 definition that forces use of MS C8 C++ compiler
+    for all platforms to compile these files.
+
+Author:
+
+    karlsi      15-Jun-1992, Created.
+
+NOTE:   Commented description of this file is in \nt\bak\bin\sources.tpl
+
+!ENDIF
+
+MAJORCOMP=crt
+MINORCOMP=iostream
+
+TARGETNAME=iostream
+TARGETPATH=..\obj
+TARGETTYPE=LIBRARY
+386_STDCALL=0
+_AXPACC_=0
+
+!INCLUDE ..\crt32.def
+
+SOURCES=iostream.cxx    \
+        iostrini.cxx    \
+        cerrinit.cxx    \
+        cininit.cxx     \
+        cloginit.cxx    \
+        filebuf.cxx     \
+        filebuf1.cxx    \
+        fstream.cxx     \
+        ifstream.cxx    \
+        ios.cxx         \
+        istrchar.cxx    \
+        istrdbl.cxx     \
+        istream.cxx     \
+        istream1.cxx    \
+        istrflt.cxx     \
+        istrgdbl.cxx    \
+        istrget.cxx     \
+        istrgetl.cxx    \
+        istrgint.cxx    \
+        istrint.cxx     \
+        istrldbl.cxx    \
+        istrlong.cxx    \
+        istrshrt.cxx    \
+        istruint.cxx    \
+        istrulng.cxx    \
+        istrusht.cxx    \
+        mtlock.c        \
+        ofstream.cxx    \
+        ostrchar.cxx    \
+        ostrdbl.cxx     \
+        ostream.cxx     \
+        ostream1.cxx    \
+        ostrint.cxx     \
+        ostrldbl.cxx    \
+        ostrlong.cxx    \
+        ostrptr.cxx     \
+        ostrput.cxx     \
+        ostrshrt.cxx    \
+        ostruint.cxx    \
+        ostrulng.cxx    \
+        ostrusht.cxx    \
+        stdiostr.cxx    \
+        streamb.cxx     \
+        streamb1.cxx    \
+        strmbdbp.cxx    \
+        strstrea.cxx
diff --git a/private/crt32/iostream/stdiostr.cxx b/private/crt32/iostream/stdiostr.cxx
new file mode 100644
index 000000000..58c385a78
--- /dev/null
+++ b/private/crt32/iostream/stdiostr.cxx
@@ -0,0 +1,266 @@
+/***
+*stdiostr.cxx -
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*
+*Revision History:
+*
+*	07-10-91   KRS	Created.
+*	08-26-91   KRS	Switch out cout/cerr. etc. for Windows non-QuickWin.
+*	09-09-91   KRS	Modify sync_with_stdio() for filebuf defaults.
+*	09-12-91   KRS	Add stdiostream class.
+*	09-19-91   KRS	Use delbuf(1) in stdiostream constructor.
+*	09-20-91   KRS	C700 #4453: Improve efficiency in overflow().
+*	10-21-91   KRS	Eliminate last use of default iostream constructor.
+*	10-24-91   KRS	Avoid virtual calls from virtual functions.
+*	11-13-91   KRS	Split out streambuf::dbp() into separate file.
+*			Improve default buffer handling in underflow/overflow.
+*			Fix bug in sync().
+*	01-20-92   KRS	C700 #5803: account for CR/LF pairs in ssync().
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <string.h>
+#include <stdiostr.h>
+#pragma hdrstop
+
+extern "C" {
+#include <file2.h>
+#include <msdos.h>
+}
+#include <dos.h>
+
+	stdiobuf::stdiobuf(FILE * f)
+: streambuf()
+{
+	unbuffered(1);			// initially unbuffered
+	_str = f;
+}
+
+	stdiobuf::~stdiobuf()
+// : ~streambuf()
+{
+	stdiobuf::sync();		// make sure buffer flushed
+//	_str = 0;
+}
+
+	int stdiobuf::setrwbuf(int readsize, int writesize)
+{
+    char * tbuf;
+    unbuffered(!(readsize+writesize));
+    if (unbuffered())
+	return(0);
+
+    tbuf = new char[(readsize+writesize)];
+    if (!tbuf)
+	return(EOF);
+
+    setb( tbuf, tbuf + (readsize+writesize), 1);
+
+    if (readsize)
+	{
+	setg(base(),base()+readsize,base()+readsize);
+	}
+    else
+	{
+	setg(0,0,0);
+	}
+
+    if (writesize)
+	{
+	setp(base()+readsize,ebuf());
+	}
+    else
+	{
+	setp(0,0);
+	}
+
+    return(1);
+}
+
+int stdiobuf::overflow(int c) {
+    long count, nout;
+    if (allocate()==EOF)	// make sure there is a reserve area
+	return EOF;	
+    if (!unbuffered() && epptr())
+	{
+	if ((count = pptr() - pbase()) > 0)
+	    {
+	    nout=fwrite((void *) pbase(), 1, (int)count, _str);
+	    pbump(-(int)nout);
+	    if (nout != count)
+		{
+		memmove(pbase(),pbase()+nout,(int)(count-nout));
+		return(EOF);
+		}
+	    }
+	}
+    if ((!unbuffered()) && (!epptr()))
+	setp(base()+(blen()>>1),ebuf());	// hack: default to 2nd half
+    if (c!=EOF)
+	{
+	if ((!unbuffered()) && (pptr() < epptr())) // guard against recursion
+	    sputc(c);
+	else
+	    return fputc(c, _str);
+	}
+    return(1);	// return something other than EOF if successful
+}
+
+int stdiobuf::underflow()
+{
+    int count;
+    if (allocate()==EOF)	// make sure there is a reserve area
+	return EOF;	
+    if ((!unbuffered()) && (!egptr()))
+	setg(base(),(base()+(blen()>>1)),(base()+(blen()>>1))); // hack: default
+
+    if (unbuffered() || (!egptr()))
+	return fgetc(_str);
+    if (gptr() >= egptr())
+// buffer empty, try for more
+    {
+    if (!(count = fread((void *)eback(), 1, (size_t)(egptr()-eback()), _str)))
+	return(EOF); // reach EOF, nothing read
+    setg(eback(),(egptr()-count),egptr());   // _gptr = _egptr - count
+    if (gptr()!=eback())
+	{
+	// CONSIDER: expensive, is there a better sol'n?
+	memmove(gptr(), eback(), count);	// overlapping memory!
+	}
+    }
+    return sbumpc();		// CONSIDER: possible recursion
+}
+
+streampos stdiobuf::seekoff(streamoff off, ios::seek_dir dir, int)
+{
+
+    int fdir;
+    long retpos;
+    switch (dir) {
+	case ios::beg :
+	    fdir = SEEK_SET;
+	    break;
+	case ios::cur :
+	    fdir = SEEK_CUR;
+	    break;
+	case ios::end :
+	    fdir = SEEK_END;
+	    break;
+	default:
+	// error
+	    return(EOF);
+	}
+		
+// CONSIDER: is this needed?
+    stdiobuf::overflow(EOF);
+    if (fseek(_str, off, fdir))
+	return (EOF);
+    if ((retpos=ftell(_str))==-1L)
+	return(EOF);
+    return((streampos)retpos);
+}
+
+int stdiobuf::pbackfail(int c)
+{
+    if (eback()<gptr()) return sputbackc((char)c); // CONSIDER: should never happen
+
+    if (stdiobuf::seekoff( -1, ios::cur, ios::in)==EOF)
+	return EOF;
+    if (!unbuffered() && egptr())
+	{
+	memmove((gptr()+1),gptr(),(egptr()-(gptr()+1)));
+	*gptr()=(char)c;
+	}
+    return(c);
+}
+
+int stdiobuf::sync()
+{
+    long count;
+    char * p;
+    char flags;
+    if (!unbuffered())
+	{
+	if (stdiobuf::overflow(EOF)==EOF)
+	    return(EOF);
+	if ((count=in_avail())>0)
+	    {
+	    flags = _osfile[_fileno(_str)];
+	    if (flags & FTEXT)
+		{
+	        // If text mode, need to account for CR/LF etc.
+		for (p = gptr(); p < egptr(); p++)
+		    if (*p == '\n')
+			count++;
+
+		// account for EOF if read, not counted by _read
+		// UNDONE: is this necessary?
+		if (_str->_flag & _IOCTRLZ)
+		    count++;
+#if 0
+		// UNDONE: is this correct?
+		if ((gptr()==eback()) && (flags & FCRLF))
+		    count--;
+#endif
+		}
+	    if (stdiobuf::seekoff( -count, ios::cur, ios::in)==EOF)
+		return(EOF);
+	
+	    setg(eback(),egptr(),egptr()); // empty get area (_gptr = _egptr;)
+	    }
+	}
+    return(0);
+}
+
+	stdiostream::stdiostream(FILE * file)
+: iostream(new stdiobuf(file))
+{
+istream::delbuf(1);
+ostream::delbuf(1);
+// CONSIDER: do anything else?
+}
+
+	stdiostream::~stdiostream()
+{
+// CONSIDER: do anything else?
+}
+
+// include here for better granularity
+
+int ios::sunk_with_stdio = 0;
+
+void ios::sync_with_stdio()
+{
+#if ((!defined(_WINDOWS)) || defined(_QWIN))
+    if (!sunk_with_stdio)	// first time only
+	{
+//	printf("In sync_with_stdio\n");
+
+	cin = new stdiobuf(stdin);
+	cin.delbuf(1);
+	cin.setf(ios::stdio);
+
+	cout = new stdiobuf(stdout);
+	cout.delbuf(1);
+	cout.setf(ios::stdio|ios::unitbuf);
+	((stdiobuf*)(cout.rdbuf()))->setrwbuf(0,80);	// UNDONE: size??
+
+	cerr = new stdiobuf(stderr);
+	cerr.delbuf(1);
+	cerr.setf(ios::stdio|ios::unitbuf);
+	((stdiobuf*)(cerr.rdbuf()))->setrwbuf(0,80);	// UNDONE: size??
+
+	clog = new stdiobuf(stderr);
+	clog.delbuf(1);
+	clog.setf(ios::stdio);
+	((stdiobuf*)(clog.rdbuf()))->setrwbuf(0,BUFSIZ);
+
+	sunk_with_stdio++;
+	}
+#endif
+}
diff --git a/private/crt32/iostream/streamb.cxx b/private/crt32/iostream/streamb.cxx
new file mode 100644
index 000000000..bcfb9a1eb
--- /dev/null
+++ b/private/crt32/iostream/streamb.cxx
@@ -0,0 +1,514 @@
+/***
+*streamb.cxx - fuctions for streambuf class.
+*
+*	Copyright (c) 1990-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Functions for streambuf class.
+*
+*Revision History:
+*	09-10-90  WAJ	Initial version.
+*	07-02-91  KRS	Initial version completed.
+*	08-20-91  KRS	Treat chars as unsigned; fix sgetn() function.
+*	09-06-91  KRS	Do a sync() in ~streambuf before destroying buffer.
+*	11-18-91  KRS	Split off stream1.cxx for input-specific code.
+*	12-09-91  KRS	Fix up xsputn/xsgetn usage.
+*	03-03-92  KRS	Added mthread lock init calls to constructors.
+*	06-02-92  KRS	CAV #1745: Don't confuse 0xFF with EOF in xsputn()
+*			call to overflow().
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <string.h>
+#include <stdlib.h>
+#include <iostream.h>
+#pragma hdrstop
+
+
+#ifndef BUFSIZ
+#define BUFSIZ 512
+#endif
+
+/***
+*streambuf::streambuf() -
+*
+*Purpose:
+*	Default constructor.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+streambuf::streambuf()
+{
+    _fAlloc = 0;
+    _fUnbuf = 0;
+    x_lastc = EOF;
+    _base = NULL;
+    _ebuf = NULL;
+    _pbase = NULL;
+    _pptr = NULL;
+    _epptr = NULL;
+    _eback = NULL;
+    _gptr = NULL;
+    _egptr = NULL;
+
+#ifdef MTHREAD
+    LockFlg = 1;		// default is no locking
+    _mtlockinit(lockptr());
+#endif  /* MTHREAD */
+
+}
+
+/***
+*streambuf::streambuf(char* pBuf, int cbBuf) -
+*
+*Purpose:
+*	Constructor which specifies a buffer area.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+streambuf::streambuf( char* pBuf, int cbBuf )
+{
+    _fAlloc = 0;
+    _fUnbuf = 0;
+    x_lastc = EOF;
+    _base = pBuf;
+    _ebuf = pBuf + (unsigned)cbBuf;
+    _pbase = NULL;
+    _pptr = NULL;
+    _epptr = NULL;
+    _eback = NULL;
+    _gptr = NULL;
+    _egptr = NULL;
+
+    if( pBuf == NULL || cbBuf == 0 ){
+	_fUnbuf = 1;
+	_base = NULL;
+	_ebuf = NULL;
+    }
+
+#ifdef MTHREAD
+    LockFlg = 1;		// default is no locking
+    _mtlockinit(lockptr());
+#endif  /* MTHREAD */
+
+}
+
+
+/***
+*virtual streambuf::~streambuf() -
+*
+*Purpose:
+*	Destructor.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+streambuf::~streambuf()
+{
+    lock();		// make sure no one else still using it
+//    x_lastc = EOF;
+    sync();	// make sure buffer empty before possibly destroying it
+    if( (_fAlloc) && (_base) )
+	delete _base;
+}
+
+
+/***
+* virtual streambuf * streambuf::setbuf(char * p, int len) -
+*
+*Purpose:
+*	Offers the array at p with len bytes to be used as a reserve area.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+streambuf * streambuf::setbuf(char * p, int len)
+{
+    if (!_base)
+	{
+	if ((!p) || (!len))
+	    _fUnbuf = 1;	// mark as unbuffered
+	else
+	    {
+	    _base = p;
+	    _ebuf = p + (unsigned)len;
+	    _fUnbuf = 0;
+	    }
+	return (this);
+	}
+    return((streambuf *)NULL);
+}
+
+
+/***
+*virtual int streambuf::xsputn( char* pBuf, int cbBuf ) -
+*
+*Purpose:
+*	Tries to output cbBuf characters.  Returns number of characters
+*	that were outputted.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int streambuf::xsputn( const char* pBuf, int cbBuf )
+{
+    int	cbOut;
+#if 0
+    if (!this)
+	printf("xsputn: this = NULL\n");
+#endif
+    for (cbOut = 0; cbBuf--; cbOut++)
+	{
+	if ((_fUnbuf) || (_pptr >= _epptr))
+	    {
+// UNDONE: can be optimized like sgetn !!
+	    if (overflow((unsigned char)*pBuf)==EOF)	// 0-extend 0xFF !=EOF
+		break;
+	    }
+	else
+	    {
+	    *(_pptr++) = *pBuf;
+	    }
+	pBuf++;
+	}
+    return cbOut;
+}
+
+/***
+*virtual int streambuf::xsgetn( char* pBuf, int cbBuf ) -
+*
+*Purpose:
+*	Tries to input cbBuf characters.  Returns number of characters
+*	that were read from streambuf.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+// #pragma intrinsic(memcpy,__min)
+
+int streambuf::xsgetn( char * pBuf, int cbBuf)
+{
+    int count;
+    int cbIn = 0;
+    if (_fUnbuf)
+	{
+	if (x_lastc==EOF)
+	    x_lastc=underflow();
+		
+	while (cbBuf--)
+	    {
+	    if (x_lastc==EOF) 
+		break;
+	    *(pBuf++) = (char)x_lastc;
+	    cbIn++;
+	    x_lastc=underflow();
+	    }
+	}
+    else
+	{
+	while (cbBuf)
+	    {
+	    if (underflow()==EOF)	// make sure something to read
+		break;
+	    count = __min(egptr() - gptr(),cbBuf);
+	    if (count>0)
+		{
+	        memcpy(pBuf,gptr(),count);
+		pBuf  += count;
+		_gptr += count;
+		cbIn  += count;
+		cbBuf -= count;
+		}
+	    }
+	}
+    return cbIn;
+}
+// #pragma function(memcpy, __min)
+
+/***
+*virtual int streambuf::sync() -
+*
+*Purpose:
+*	Tries to flush all data in put area and give back any data in the
+*	get area (if possible), leaving both areas empty on exit.
+*	Default behavior is to fail unless buffers empty.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int streambuf::sync()
+{
+    if ((gptr() <_egptr) || (_pptr > _pbase))
+	{
+	return EOF;
+	}
+    return 0;
+}
+
+#if 0
+/***
+*int streambuf::sputn( char* pBuf, int cbBuf ) -
+*
+*Purpose:
+*	Tries to output cbBuf characters.  Returns number of characters
+*	that were output.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int streambuf::sputn( const char* pBuf, int cbBuf )
+{
+// UNDONE:
+	return xsputn(pBuf, cbBuf);
+}
+
+/***
+*int streambuf::sgetn( char* pBuf, int cbBuf ) -
+*
+*Purpose:
+*	Tries to input cbBuf characters.  Returns number of characters
+*	that were read from streambuf.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int streambuf::sgetn( char * pBuf, int cbBuf)
+{
+// UNDONE:
+	return xsgetn(pBuf, cbBuf);
+}
+#endif
+
+/***
+*int streambuf::allocate() -
+*
+*Purpose:
+*	Tries to set up a Reserve Area.  If one already exists, or if
+*	unbuffered, just returns 0.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int streambuf::allocate()
+{
+    if ((_fUnbuf) || (_base))
+	return 0;
+    if (doallocate()==EOF) return EOF;
+
+    return(1);
+}
+
+/***
+*virtual int streambuf::doallocate() -
+*
+*Purpose:
+*	Tries to set up a Reserve Area.  Returns EOF if unsuccessful.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+int streambuf::doallocate()
+{
+    char * tptr;
+    if (!( tptr = new char[BUFSIZ]))
+	return(EOF);
+    setb(tptr, tptr + BUFSIZ, 1);
+    return(1);
+}
+
+/***
+*void streambuf::unbuffered(int fUnbuf) -
+*
+*Purpose:
+*	Sets unbuffered status.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+// void streambuf::unbuffered(int fUnbuf)
+// {
+//    _fUnbuf = fUnbuf;
+// if ((_fUnbuf) && (_base)) delete _base;	// UNDONE: not doc'd as such ??
+// }
+
+/***
+*void streambuf::setb(char * b, char * eb, int a = 0) -
+*
+*Purpose:
+*	Sets up reserve area.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+
+void streambuf::setb(char * b, char * eb, int a )
+{
+    if ((_fAlloc) && (_base)) delete _base;
+    _base = b;
+    _fAlloc = a;
+    _ebuf = eb;
+}
+
+#if 0
+int streambuf::overflow(int d)
+{
+     printf("Error: *%p streambuf::overflow(%d) called!\n",this,d);
+     return EOF;
+}
+
+int streambuf::underflow()
+{
+     printf("Error: *%p streambuf::underflow() called!\n",this);
+     return EOF;
+}
+#endif
+
+/***
+*virtual streampos streambuf::seekoff(streamoff off, ios::seekdir dir, int mode)
+*
+*Purpose:
+*	seekoff member function.  seek forward or backward in the stream.
+*	Default behavior: returns EOF.
+*
+*Entry:
+*	off  = offset (+ or -) to seek by
+*	dir  = one of ios::beg, ios::end, or ios::cur.
+*	mode = ios::in or ios::out.
+*
+*Exit:
+*	Returns new file position or EOF if error or seeking not supported.
+*
+*Exceptions:
+*	Returns EOF if error.
+*
+*******************************************************************************/
+streampos streambuf::seekoff(streamoff,ios::seek_dir,int)
+{
+return EOF;
+}
+
+/***
+*virtual streampos streambuf::seekpos(streampos pos, int mode) -
+*
+*Purpose:
+*	seekoff member function.  seek to absolute file position.
+*	Default behavior: returns seekoff(streamoff(pos), ios::beg, mode).
+*
+*Entry:
+*	pos  = absolute offset to seek to
+*	mode = ios::in or ios::out.
+*
+*Exit:
+*	Returns new file position or EOF if error or seeking not supported.
+*
+*Exceptions:
+*	Returns EOF if error.
+*
+*******************************************************************************/
+streampos streambuf::seekpos(streampos pos,int mode)
+{
+return seekoff(streamoff(pos), ios::beg, mode);
+}
+
+/***
+*virtual int streambuf::pbackfail(int c) - handle failure of putback
+*
+*Purpose:
+*	pbackfail member function.  Handle exception of pback function.
+*	Default behavior: returns EOF.  See spec. for details.
+*
+*	Note: the following implementation gives default behavior, thanks
+*	to the default seekoff, but also supports derived classes properly:
+*
+*Entry:
+*	c = character to put back
+*
+*Exit:
+*	Returns c if successful or EOF on error.
+*
+*Exceptions:
+*	Returns EOF if error.  Behavior is undefined if c was not the
+*	previous character in the stream.
+*
+*******************************************************************************/
+int streambuf::pbackfail(int c)
+{
+    if (eback()<gptr()) return sputbackc((char)c); // CONSIDER: should never happen
+
+    if (seekoff( -1, ios::cur, ios::in)==EOF)  // always EOF for streambufs
+	return EOF;
+    if (!unbuffered() && egptr())
+	{
+	memmove((gptr()+1),gptr(),(egptr()-(gptr()+1)));
+	*gptr()=(char)c;
+	}
+    return(c);
+}
diff --git a/private/crt32/iostream/streamb1.cxx b/private/crt32/iostream/streamb1.cxx
new file mode 100644
index 000000000..d6899ea79
--- /dev/null
+++ b/private/crt32/iostream/streamb1.cxx
@@ -0,0 +1,165 @@
+/***
+*streamb1.cxx - non-core functions for streambuf class.
+*
+*	Copyright (c) 1990-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	None-core functions for streambuf class.
+*
+*Revision History:
+*	11-18-91  KRS	Split off from streamb.cxx.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <iostream.h>
+#pragma hdrstop
+
+
+/***
+*int streambuf::snextc() -
+*
+*Purpose:
+*	Increments get_pointer and returns the character following the new
+*	get_pointer.
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	Returns the next character or EOF.
+*
+*Exceptions:
+*	Returns EOF if error.
+*
+*******************************************************************************/
+int streambuf::snextc()
+{
+    if (_fUnbuf)
+	{
+	if (x_lastc==EOF)
+	    underflow();		// skip 1st character
+	return x_lastc = underflow();	// return next character, or EOF
+	}
+    else
+	{
+	if ((!egptr()) || (gptr()>=egptr()))
+	    underflow();		// make sure buffer
+
+	if ((++_gptr) < egptr())
+	    return (int)(unsigned char) *gptr();
+	return underflow();		// returns next character, or EOF
+	}
+}
+
+
+/***
+*int streambuf::sbumpc() -
+*
+*Purpose:
+*	Increments get_pointer and returns the character that the previous
+*	get_pointer pointed to.
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	Returns current character before bumping get pointer.
+*
+*Exceptions:
+*	Returns EOF if error.
+*
+*******************************************************************************/
+int streambuf::sbumpc()
+{
+    int c;
+    if (_fUnbuf) // no buffer
+	{
+	if (x_lastc==EOF) 
+	    {
+	    c = underflow();
+	    }
+	else
+	    {
+	    c = x_lastc;
+	    x_lastc = EOF;
+	    }
+	}
+    else
+	{
+	if( gptr() < egptr() )
+	    {
+	    c = (int)(unsigned char)*(gptr());
+	    }
+	else
+	    {
+	    // UNDONE: possible recursion
+	    c = underflow();
+	    }
+	_gptr++;
+	}
+    return c;
+}
+
+/***
+*void streambuf::stossc() - advance get pointer
+*
+*Purpose:
+*	Advances the get pointer.  Does not check for EOF.
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	None.
+*
+*Exceptions:
+*
+*******************************************************************************/
+void streambuf::stossc()
+{
+    if (_fUnbuf)
+	{
+	if (x_lastc==EOF)
+	    underflow();	// throw away current character
+	else
+	    x_lastc=EOF;	// discard current cached character
+	}
+    else
+	{
+	if (gptr() >= egptr())
+	    underflow();
+	if (gptr() < egptr())
+	    _gptr++;
+	}
+}
+
+/***
+*int streambuf::sgetc() -
+*
+*Purpose:
+*	Returns the character that the previous get_pointer points to.
+*	DOES NOT advance the get pointer.
+*
+*Entry:
+*	None.
+*
+*Exit:
+*	Returns current character or EOF if error.
+*
+*Exceptions:
+*	Returns EOF if error.
+*
+*******************************************************************************/
+int streambuf::sgetc()
+{
+    if (_fUnbuf)  // no buffer
+	{
+	if (x_lastc==EOF)
+	    x_lastc = underflow();
+	return x_lastc;
+	}
+     else
+	return underflow();
+}
diff --git a/private/crt32/iostream/strmbdbp.cxx b/private/crt32/iostream/strmbdbp.cxx
new file mode 100644
index 000000000..2f209a67f
--- /dev/null
+++ b/private/crt32/iostream/strmbdbp.cxx
@@ -0,0 +1,48 @@
+/***
+*strmbdbp.cxx - streambuf::dbp() debug routine
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	Dump debug info about streambuf to stdout.
+*
+*Revision History:
+*
+*	11-13-91   KRS	Created.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <io.h>
+#include <stdio.h>
+#include <iostream.h>
+#pragma hdrstop
+
+#pragma check_stack(on)		// large buffer(s)
+
+void streambuf::dbp()
+{
+#if ((!defined(_WINDOWS)) || defined(_QWIN))
+int olen;
+_WINSTATIC char obuffer[256];		// CONSIDER: size? (198 bytes?)
+    if (unbuffered())
+	olen = sprintf(obuffer,
+	    "\nSTREAMBUF DEBUG INFO: this=%p, unbuffered\n",
+	    (void *) this);
+    else
+	{
+	olen = sprintf(obuffer,
+	    "\nSTREAMBUF DEBUG INFO: this=%p, _fAlloc=%d\n"
+	    "  base()=%p, ebuf()=%p,  blen()=%d\n"
+	    " pbase()=%p, pptr()=%p, epptr()=%p\n"
+	    " eback()=%p, gptr()=%p, egptr()=%p\n",
+	    (void *) this, (_fAlloc),
+	     base(), ebuf(),  blen(),
+	    pbase(), pptr(), epptr(),
+	    eback(), gptr(), egptr());
+	}
+    _write(1,obuffer,olen);	// direct write to stdout
+    // CONSIDER: add more info?
+#endif
+}
diff --git a/private/crt32/iostream/strstrea.cxx b/private/crt32/iostream/strstrea.cxx
new file mode 100644
index 000000000..fba8e0126
--- /dev/null
+++ b/private/crt32/iostream/strstrea.cxx
@@ -0,0 +1,440 @@
+
+/***
+*strstream.cxx - definitions for strstreambuf, strstream
+*
+*	Copyright (c) 1991-1992, Microsoft Corporation.  All rights reserved.
+*
+*Purpose:
+*	This file defines the functions used by strstream and strstrembuf
+*	classes.
+*
+*Revision History:
+*	08-14-91  KRS	Initial version.
+*	08-23-91  KRS	Initial version completed.
+*	09-03-91  KRS	Fix typo in strstreambuf::seekoff(,ios::in,)
+*	09-04-91  KRS	Added virtual sync() to fix flush().  Fix underflow().
+*	09-05-91  KRS	Change str() and freeze() to match spec.
+*	09-19-91  KRS	Add calls to delbuf(1) in constructors.
+*	10-24-91  KRS	Avoid virtual calls from virtual functions.
+*
+*******************************************************************************/
+
+#include <cruntime.h>
+#include <internal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strstrea.h>
+#pragma hdrstop
+
+/***
+*strstreambuf::strstreambuf() - default constructor for strstreambuf
+*
+*Purpose:
+*	Default constructor for class strstreambuf.
+*
+*Entry:
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+	strstreambuf::strstreambuf()
+: streambuf()
+{
+x_bufmin = x_dynamic = 1;
+x_static = 0;
+x_alloc = (0);
+x_free = (0);
+// CONSIDER: do anything else??
+}
+
+/***
+*strstreambuf::strstreambuf(int n) - constructor for strstreambuf
+*
+*Purpose:
+*	Constructor for class strstreambuf.  Created in dynamic mode.
+*
+*Entry:
+*	n = minimum size for initial allocation.
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+strstreambuf::strstreambuf(int n)
+: streambuf()
+{
+x_dynamic = 1;
+x_static = 0;
+x_alloc = (0);
+x_free = (0);
+setbuf(0,n);
+// CONSIDER: do anything else??
+}
+
+/***
+*strstreambuf::strstreambuf(void* (*_a)(long), void (*_f)(void*)) - constructor for strstreambuf
+*
+*Purpose:
+*	Construct a strstreambuf in dynamic mode.  Use specified allocator
+*	and deallocator instead of new and delete.
+*
+*Entry:
+*	*_a  =	allocator: void * (*_a)(long)
+*	*_f  =	deallocator: void (*_f)(void *)
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+strstreambuf::strstreambuf(void* (*_a)(long), void (*_f)(void*))
+: streambuf()
+{
+// CONSIDER: do anything else??
+x_dynamic = x_bufmin = 1;
+x_static = 0;
+x_alloc = _a;
+x_free = _f;
+}
+
+/***
+*strstreambuf::strstreambuf(char * ptr, int size, char * pstart = 0) -
+*
+*Purpose:
+*	Construct a strstreambuf in static mode.  Buffer used is of 'size'
+*	bytes.  If 'size' is 0, uses a null-terminated string as buffer.
+*	If negative, size is considered infinite.  Get starts at ptr.
+*	If pstart!=0, put buffer starts at pstart.  Otherwise, no output.
+*
+*Entry:
+*	char * ptr;	pointer to buffer  base()
+*	int size;	size of buffer, or 0= use strlen to calculate size
+*			  or if negative size is 'infinite'.
+*	char * pstart;	pointer to put buffer of NULL if none.
+*
+*Exit:
+*
+*Exceptions:
+*
+*******************************************************************************/
+strstreambuf::strstreambuf(	char * ptr, int size, char * pstart)
+: streambuf()
+{
+    x_static = 1;
+    x_dynamic = 0;
+    char * pend;
+
+    if (!size)
+	pend = ptr + strlen(ptr);
+    else if (size < 0)
+	{
+	//  size = 32767 - (unsigned short)ptr;	// UNDONE: fix for 32-bit
+	// UNDONE: bogus segment math
+	pend = (char*)-1L;
+	}
+    else
+	pend = ptr + size;
+
+    setb(ptr, pend,0);
+// CONSIDER: is this right?  Not quite what spec. says...
+    if (pstart)
+	{
+	setg(ptr,ptr,pstart);
+	setp(pstart, pend);
+	}
+    else
+	{
+	setg(ptr,ptr,pend);
+	setp(0, 0);
+	}
+}
+
+strstreambuf::~strstreambuf()
+{
+    if ((x_dynamic) && (base()))
+	{
+	if (x_free)
+	    {
+	    (*x_free)(base());
+	    }
+	else
+	    {
+	    delete base();
+	    }
+	}
+// x_dynamic = 0;
+// x_static = 1;
+}
+
+void strstreambuf::freeze(int n)
+{
+    if (!x_static)
+        x_dynamic = (!n);
+}
+
+char * strstreambuf::str()
+{
+//  x_static = 1;	// CONSIDER: disallow further dynamic changes?
+
+    x_dynamic = 0;	// freeze();
+
+    return base();
+}
+
+int strstreambuf::doallocate()
+{
+    char * bptr;
+    int size;
+    size = __max(x_bufmin,blen()+1);
+    long offset = 0;
+    
+    if (x_alloc)
+	{
+	bptr = (char*)(*x_alloc)(size);
+	}
+    else
+	{
+	bptr = new char[size];
+	}
+    if (!bptr)
+	return EOF;
+
+    if (blen())
+	{
+	memcpy(bptr, base(), blen());
+        offset = bptr - base();	// amount to adjust pointers by
+	}
+    if (x_free)
+	{
+	(*x_free)(base());
+	}
+    else
+	{
+	delete base();
+	}
+    setb(bptr,bptr+size,0);	// we handle deallocation
+
+    // adjust get/put pointers too, if necessary
+    if (offset)
+	if (egptr())
+	    {
+	    setg(eback()+offset,gptr()+offset,egptr()+offset);
+	    }
+	if (epptr())
+	    {
+	    size = pptr() - pbase();
+	    setp(pbase()+offset,epptr()+offset);
+	    pbump(size);
+	}
+    return(1);
+}
+
+streambuf * strstreambuf::setbuf( char *, int l)
+{
+    if (l)
+	x_bufmin = l;
+    return this;
+}
+
+int strstreambuf::overflow(int c)
+{
+/*
+- if no room and not dynamic, give error
+- if no room and dynamic, allocate (1 more or min) and store
+- if and when the buffer has room, store c if not EOF
+*/
+    int temp;
+    if (pptr() >= epptr())
+	{
+	if (!x_dynamic) 
+	    return EOF;
+
+	if (strstreambuf::doallocate()==EOF)
+	    return EOF;
+
+	if (!epptr())	// init if first time through
+	    {
+	    setp(base() + (egptr() - eback()),ebuf());
+	    }
+	else
+	    {
+	    temp = pptr()-pbase();
+	    setp(pbase(),ebuf());
+	    pbump(temp);
+	    }
+	}
+
+    if (c!=EOF)
+	{
+	*pptr() = (char)c;
+	pbump(1);	// UNDONE:
+	}
+    return(1);
+}
+
+int strstreambuf::underflow()
+{
+    char * tptr;
+    if (gptr() >= egptr())
+	{
+	// try to grow get area if we can...
+	if (egptr()<pptr())
+	    {
+	    tptr = base() + (gptr()-eback());
+	    setg(base(),tptr,pptr());
+	    }
+	if (gptr() >= egptr())
+	    return EOF;
+	}
+
+    return *gptr();
+}
+
+int strstreambuf::sync()
+{
+// a strstreambuf is always in sync, by definition!
+return 0;
+}
+
+streampos strstreambuf::seekoff(streamoff off, ios::seek_dir dir, int mode)
+{
+char * tptr;
+long offset = EOF;	// default return value
+    if (mode & ios::in)
+	{
+	strstreambuf::underflow();	// makes sure entire buffer available
+	switch (dir) {
+	    case ios::beg :
+		tptr = eback();
+		break;
+	    case ios::cur :
+		tptr = gptr();
+		break;
+	    case ios::end :
+		tptr = egptr();
+		break;
+	    default:
+		return EOF;
+	    }
+	tptr += off;
+	offset = tptr - eback();
+	if ((tptr < eback()) || (tptr > egptr()))
+	    {
+	    return EOF;
+	    }
+	gbump(tptr-gptr());
+	}
+    if (mode & ios::out)
+	{
+	if (!epptr())
+	    {
+	    if (strstreambuf::overflow(EOF)==EOF) // make sure there's a put buffer
+		return EOF;
+	    }
+	switch (dir) {
+	    case ios::beg :
+		tptr = pbase();
+		break;
+	    case ios::cur :
+		tptr = pptr();
+		break;
+	    case ios::end :
+		tptr = epptr();
+		break;
+	    default:
+		return EOF;
+	    }
+	tptr += off;
+	offset = tptr - pbase();
+	if (tptr < pbase())
+	    return EOF;
+	if (tptr > epptr())
+	    {
+	    if (x_dynamic) 
+		{
+		x_bufmin = __max(x_bufmin, (tptr-pbase()));
+		if (strstreambuf::doallocate()==EOF)
+		    return EOF;
+		// _epptr = ebuf();
+		}
+	    else
+		return EOF;
+	    }
+	pbump(tptr-pptr());
+	}
+    return offset;	// note: if both in and out set, returns out offset
+}
+
+
+	istrstream::istrstream(char * pszStr)
+: istream(new strstreambuf(pszStr,0))
+{
+    delbuf(1);
+    // CONSIDER: do anything else?
+}
+
+	istrstream::istrstream(char * pStr, int len)
+: istream(new strstreambuf(pStr,len))
+{
+    delbuf(1);
+    // CONSIDER: do anything else?
+// CONSIDER: do anything else?
+}
+
+	istrstream::~istrstream()
+{
+// CONSIDER: do anything else?
+}
+
+	ostrstream::ostrstream()
+: ostream(new strstreambuf)
+{
+    delbuf(1);
+    // CONSIDER: do anything else?
+// CONSIDER: do anything else?
+}
+
+	ostrstream::ostrstream(char * str, int size, int mode)
+: ostream(new strstreambuf(str,size,str))
+{
+    delbuf(1);
+    if (mode & (ios::app|ios::ate))
+	seekp(strlen(str),ios::beg);
+//  CONSIDER: needed?
+//  rdbuf()->setg(0,0,0); // no input allowed
+// CONSIDER: do anything else?
+}
+
+	ostrstream::~ostrstream()
+{
+// CONSIDER: do anything else?
+}
+
+	strstream::strstream()
+: iostream(new strstreambuf)
+{
+    istream::delbuf(1);
+    ostream::delbuf(1);
+    // CONSIDER: do anything else?
+}
+
+	strstream::strstream(char * str, int size, int mode)
+: iostream(new strstreambuf(str,size,str))
+{
+// UNDONE: not quite correct!
+
+    istream::delbuf(1);
+    ostream::delbuf(1);
+    if ((mode & ostream::out)  && (mode & (ostream::app|ostream::ate)))
+	seekp(strlen(str),ostream::beg);
+//  rdbuf()->setg(rdbuf()->base(),rdbuf()->base(),rdbuf()->ebuf()); // UNDONE: how is input handled???
+// CONSIDER: do anything else?
+}
+
+	strstream::~strstream()
+{
+// CONSIDER: do anything else?
+}