/***
*_sftbuf.c - temporary buffering initialization and flushing
*
*	Copyright (c) 1985-1992, Microsoft Corporation. All rights reserved.
*
*Purpose:
*	temporary buffering initialization and flushing. if stdout/err is
*	unbuffered, buffer it temporarily so that string is sent to kernel as
*	a batch of chars, not char-at-a-time. if appropriate, make buffering
*	permanent.
*
*	[NOTE 1: These routines assume that the temporary buffering is only
*	used for output.  In particular, note that _stbuf() sets _IOWRT.]
*
*	[NOTE 2: It is valid for this module to assign a value directly to
*	_flag instead of simply twiddling bits since we are initializing the
*	buffer data base.]
*
*Revision History:
*	09-01-83  RN	initial version
*	06-26-85  TC	added code to _stbuf to allow variable buffer lengths
*	??-??-??  TC	fixed case in _flbuf where flag is off, but a temporary
*			buffer still needs to be fflushed.
*	05-27-87  JCR	protect mode does not know about stdprn.
*	06-26-87  JCR	Conditionalized out code in _ftbuf that caused
*			redirected stdout to be flushed on every call.
*	07-01-87  JCR	Put in code to support re-entrant calling from
*			interrupt level (MSC only).
*	08-06-87  JCR	Fixed a _ftbuf() problem pertaining to stderr/stdprn
*			when _bufout is being used by stdout.
*	08-07-87  JCR	(1) When assigning _bufout to an _iob, we now set the
*			_IOWRT flag.  This fixes a bug involving freopen()
*			issued against one of the std handles.
*			(2) Removed some annoying commented out code.
*	08-13-87  JCR	_ftbuf() does NOT clear _IOWRT now.  Fixes a bug where
*			_getstream() would reassign stdout because none of the
*			flags were set.
*	09-28-87  JCR	Corrected _iob2 indexing (now uses _iob_index() macro).
*	11-05-87  JCR	Re-written for multi-thread support and simplicity
*	01-11-88  JCR	Merged mthread version into normal version
*	01-13-88  SKS	Changed bogus "_fileno_lk" to "fileno"
*	06-06-88  JCR	Optimized _iob2 references
*	06-10-88  JCR	Use near pointer to reference _iob[] entries
*	06-27-88  JCR	Added stdprn temporary buffering support (DOS only),
*			and made buffer allocation dynamic; also added _IOFLRTN
*			(flush stream on per routine basis).
*	08-25-88  GJF	Modified to also work for the 386 (small model only).
*	06-20-89  PHG	Changed return value to void
*	08-28-89  JCR	Removed _NEAR_ for 386
*	02-15-90  GJF	_iob[], _iob2[] merge. Also, fixed copyright and
*			indents.
*	03-16-90  GJF	Made calling type _CALLTYPE1, added #include
*			<cruntime.h> and removed #include <register.h>. Also,
*			removed some leftover 16-bit DOS support.
*	03-27-90  GJF	Added #include <io.h>.
*	05-29-90  SBM	Use _flush, not [_]fflush[_lk]
*	07-23-90  SBM	Replaced <assertm.h> by <assert.h>
*	10-03-90  GJF	New-style function declarator.
*	01-22-91  GJF	ANSI naming.
*	03-27-92  DJM	POSIX support.
*	08-26-92  GJF	Include unistd.h for POSIX build.
*
*******************************************************************************/

#include <cruntime.h>
#ifdef	_POSIX_
#include <unistd.h>
#endif
#include <stdio.h>
#include <file2.h>
#include <io.h>
#include <assert.h>
#include <internal.h>
#include <malloc.h>
#ifdef MTHREAD
#include <os2dll.h>
#endif

/* Buffer pointers for stdout and stderr */
void *_stdbuf[2] = { NULL, NULL};

/***
*int _stbuf(stream) - set temp buffer on stdout, stdprn, stderr
*
*Purpose:
*	if stdout/stderr is still unbuffered, buffer it.
*	this function works intimately with _ftbuf, and accompanies it in
*	bracketing normally unbuffered output. these functions intended for
*	library use only.
*
*	Multi-thread: It is assumed that the caller has already aquired the
*	stream lock.
*
*Entry:
*	FILE *stream - stream to temp buffer
*
*Exit:
*	returns 1 if buffer initialized, 0 if not
*	sets fields in stdout or stderr to indicate buffering
*
*Exceptions:
*
*******************************************************************************/

int _CALLTYPE1 _stbuf (
	FILE *str
	)
{
	REG1 FILE *stream;
	int index;

	assert(str != NULL);

	/* Init near stream pointer */
	stream = str;

        /* do nothing if not a tty device */
#ifdef _POSIX_
	if (!isatty(fileno(stream)))
#else
	if (!_isatty(_fileno(stream)))
#endif
                return(0);

	/* Make sure stream is stdout/stderr and init _stdbuf index */
	if (stream == stdout)
		index = 0;
	else if (stream == stderr)
		index = 1;
	else
		return(0);

	_cflush++;  /* force library pre-termination procedure */

	/* Make sure the stream is not already buffered. */
	if (anybuf(stream))
		return(0);

	/* Allocate a buffer for this stream if we haven't done so yet. */
	if (_stdbuf[index] == NULL)
		if ( (_stdbuf[index]=malloc(BUFSIZ)) == NULL )
			return(0);	/* error */

	/* Set up the buffer */
	stream->_ptr = stream->_base = _stdbuf[index];
	stream->_cnt = stream->_bufsiz = BUFSIZ;
	stream->_flag |= (_IOWRT | _IOYOURBUF | _IOFLRTN);

	return(1);
}


/***
*void _ftbuf(flag, stream) - take temp buffering off a stream
*
*Purpose:
*	If stdout/stderr is being buffered and it is a device, _flush and
*	dismantle the buffer. if it's not a device, leave the buffering on.
*	This function works intimately with _stbuf, and accompanies it in
*	bracketing normally unbuffered output. these functions intended for
*	library use only
*
*	Multi-thread: It is assumed that the caller has already aquired the
*	stream lock.
*
*Entry:
*	int flag     - a flag to tell whether to dismantle temp buffering on a
*		       stream
*	FILE *stream - the stream
*
*Exit:
*	no return value
*	sets fields in stdout/stderr
*
*Exceptions:
*
*******************************************************************************/

void _CALLTYPE1 _ftbuf (
	int flag,
	FILE *str
	)
{
	REG1 FILE *stream;

	assert(flag == 0 || flag == 1);

	/* Init near stream pointers */
	stream = str;

	if (flag) {

		if (stream->_flag & _IOFLRTN) {

			/* Flush the stream and tear down temp buffering. */
			_flush(stream);
			stream->_flag &= ~(_IOYOURBUF | _IOFLRTN);
			stream->_bufsiz = 0;
			stream->_base = stream->_ptr = NULL;
		}

		/* Note: If we expand the functionality of the _IOFLRTN bit to
		include other streams, we may want to clear that bit here under
		an 'else' clause (i.e., clear bit in the case that we leave the
		buffer permanently assigned.  Given our current use of the bit,
		the extra code is not needed. */

	} /* end flag = 1 */

#ifndef MTHREAD
/* NOTE: Currently, writing to the same string at interrupt level does not
   work in multi-thread programs. */

/* The following code is needed if an interrupt occurs between calls
   to _stbuf/_ftbuf and the interrupt handler also calls _stbuf/_ftbuf. */

	else
		if (stream->_flag & _IOFLRTN)
			_flush(stream);

#endif	/* MTHREAD */

}