12292 retire libbc

Reviewed by: Peter Tribble <peter.tribble@gmail.com>
Reviewed by: Andy Stormont <astormont@racktopsystems.com>
Reviewed by: Alexander Eremin <aeremin@tintri.com>
Approved by: Garrett D'Amore <garrett@damore.org>

1 files changed, 0 insertions, 291 deletions

diff --git a/usr/src/lib/libbc/libc/stdio/sys5/flsbuf.c b/usr/src/lib/libbc/libc/stdio/sys5/flsbuf.c
deleted file mode 100644
index 4dcc1f3f18..0000000000
--- a/usr/src/lib/libbc/libc/stdio/sys5/flsbuf.c
+++ /dev/null
@@ -1,291 +0,0 @@
-/*
- * CDDL HEADER START
- *
- * The contents of this file are subject to the terms of the
- * Common Development and Distribution License, Version 1.0 only
- * (the "License").  You may not use this file except in compliance
- * with the License.
- *
- * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
- * or http://www.opensolaris.org/os/licensing.
- * See the License for the specific language governing permissions
- * and limitations under the License.
- *
- * When distributing Covered Code, include this CDDL HEADER in each
- * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
- * If applicable, add the following below this CDDL HEADER, with the
- * fields enclosed by brackets "[]" replaced with your own identifying
- * information: Portions Copyright [yyyy] [name of copyright owner]
- *
- * CDDL HEADER END
- */
-/*
- * Copyright 1989 Sun Microsystems, Inc.  All rights reserved.
- * Use is subject to license terms.
- */
-
-#pragma ident	"%Z%%M%	%I%	%E% SMI"
-
-/*LINTLIBRARY*/
-#include <stdio.h>
-#include <errno.h>
-#include "../common/stdiom.h"
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#include <malloc.h>
-
-extern unsigned char (*_smbuf)[_SBFSIZ];
-
-void	_findbuf(FILE *);
-void	_bufsync(FILE *);
-
-extern int fclose();
-
-/*
- * Flush buffers on exit
- */
-void
-_cleanup(void)
-{
-
-	_fwalk(fclose);
-}
-
-/*
- *	fclose() will flush (output) buffers for a buffered open
- *	FILE and then issue a system close on the _fileno.  The
- *	_base field will be reset to NULL for any but stdin and
- *	stdout, the _ptr field will be set the same as the _base
- *	field. The _flags and the _cnt field will be zeroed.
- *	If buffers had been obtained via malloc(), the space will
- *	be free()'d.  In case the FILE was not open, or fflush()
- *	or close() failed, an EOF will be returned, otherwise the
- *	return value is 0.
- */
-int
-fclose(FILE *iop)
-{
-	int rtn=EOF;
-
-	if(iop == NULL)
-		return(rtn);
-	if(iop->_flag & (_IOREAD | _IOWRT | _IORW)
-	   && (iop->_flag & _IOSTRG) == 0) {
-		rtn = (iop->_flag & _IONBF)? 0: fflush(iop);
-		if(close(fileno(iop)) < 0)
-			rtn = EOF;
-	}
-	if(iop->_flag & _IOMYBUF) {
-		free((char*)iop->_base);
-		iop->_base = NULL;
-	}
-	iop->_flag = 0;
-	iop->_cnt = 0;
-	iop->_ptr = iop->_base;
-	iop->_bufsiz = 0;
-	return(rtn);
-}
-
-/*
- *	The fflush() routine must take care because of the
- *	possibility for recursion. The calling program might
- *	do IO in an interupt catching routine that is likely
- *	to interupt the write() call within fflush()
- */
-
-int
-fflush(FILE *iop)
-{
-	if (!(iop->_flag & _IOWRT)) {
-		if ((iop->_base != NULL) && iop->_cnt) {
-			lseek(iop->_file, -(iop->_cnt), SEEK_CUR);
-			iop->_cnt = 0;
-		}
-		return(0);
-	}
-	while(!(iop->_flag & _IONBF) && (iop->_flag & _IOWRT) &&
-			(iop->_base != NULL) && (iop->_ptr > iop->_base) )
-		(void) _xflsbuf(iop);
-	return(ferror(iop) ? EOF : 0);
-}
-
-/*
- * The routine _flsbuf may or may not actually flush the output buffer.  If
- * the file is line-buffered, the fact that iop->_cnt has run below zero
- * is meaningless: it is always kept below zero so that invocations of putc
- * will consistently give control to _flsbuf, even if the buffer is far from
- * full.  _flsbuf, on seeing the "line-buffered" flag, determines whether the
- * buffer is actually full by comparing iop->_ptr to the end of the buffer
- * iop->_base + iop->_bufsiz.  If it is full, or if an output line is
- * completed (with a newline), the buffer is flushed.  (Note: the character
- * argument to _flsbuf is not flushed with the current buffer if the buffer
- * is actually full -- it goes into the buffer after flushing.)
- */
-
-int
-_flsbuf(unsigned char c, FILE *iop)
-{
-    unsigned char c1;
-
-    do {
-	/* check for linebuffered with write perm, but no EOF */
-	if ( (iop->_flag & (_IOLBF | _IOWRT | _IOEOF)) == (_IOLBF | _IOWRT) ) {
-		if ( iop->_ptr >= iop->_base + iop->_bufsiz )  /* if buffer full, */
-			break;		    /* exit do-while, and flush buf. */
-		if ( (*iop->_ptr++ = c) != '\n' )
-			return(c);
-		return(_xflsbuf(iop) == EOF ? EOF : c);
-	}
-	/* write out an unbuffered file, if have write perm, but no EOF */
-	if ( (iop->_flag & (_IONBF | _IOWRT | _IOEOF)) == (_IONBF | _IOWRT) ) {
-		c1 = c;
-		iop->_cnt = 0;
-		if (write(fileno(iop), (char *) &c1, 1) == 1)
-			return(c);
-		iop->_flag |= _IOERR;
-		return(EOF);
-	}
-	/* The _wrtchk call is here rather than at the top of _flsbuf to re- */
-	/* duce overhead for line-buffered I/O under normal circumstances.  */
-
-	if (_WRTCHK(iop))			/* is writing legitimate? */
-		return(EOF);
-    } while ( (iop->_flag & (_IONBF | _IOLBF)) );
-
-
-    (void) _xflsbuf(iop);   /* full buffer:  flush buffer */
-    (void) putc((char) c, iop);  /* then put "c" in newly emptied buf */
-			/* (which, because of signals, may NOT be empty) */
-    return( ferror(iop) ? EOF : c);
-}
-
-/*
- * The function _xflsbuf writes out the current contents of the output
- * buffer delimited by iop->_base and iop->_ptr.
- * iop->_cnt is reset appropriately, but its value on entry to _xflsbuf
- * is ignored.
- *
- * The following code is not strictly correct.  If a signal is raised,
- * invoking a signal-handler which generates output into the same buffer
- * being flushed, a peculiar output sequence may result (for example,
- * the output generated by the signal-handler may appear twice).  At
- * present no means has been found to guarantee correct behavior without
- * resorting to the disabling of signals, a means considered too expensive.
- * For now the code has been written with the intent of reducing the
- * probability of strange effects and, when they do occur, of confining
- * the damage.  Except under extremely pathological circumstances, this
- * code should be expected to respect buffer boundaries even in the face
- * of interrupts and other signals.
- */
-
-int
-_xflsbuf(FILE *iop)
-{
-	unsigned char *base;
-	int n;
-
-	n = iop->_ptr - (base = iop->_base);
-	iop->_ptr = base;
-	iop->_cnt = (iop->_flag &(_IONBF | _IOLBF)) ? 0 : iop->_bufsiz;
-	_BUFSYNC(iop);
-	if (n > 0 && n != write(fileno(iop),(char*)base,(unsigned)n) )  {
-		iop->_flag |= _IOERR;
-		return(EOF);
-	}
-	return(0);
-}
-
-/*
- * The function _wrtchk checks to see whether it is legitimate to write
- * to the specified device.  If it is, _wrtchk sets flags in iop->_flag for
- * writing, assures presence of a buffer, and returns 0.  If writing is not
- * legitimate, EOF is returned.
- */
-
-int
-_wrtchk(FILE *iop)
-{
-	if ( (iop->_flag & (_IOWRT | _IOEOF)) != _IOWRT ) {
-		if (!(iop->_flag & (_IOWRT | _IORW)))
-			return(EOF);  /* bogus call--read-only file */
-		iop->_flag = iop->_flag & ~_IOEOF | _IOWRT; /* fix flags */
-	}
-	if (iop->_flag & _IOSTRG)
-		return(0);	/* not our business to monkey with buffers or counts */
-	if (iop->_base == NULL)    /* this is first I/O to file--get buffer */
-		_findbuf(iop);
-	if (iop->_ptr == iop->_base && !(iop->_flag & (_IONBF | _IOLBF)) )  {
-		iop->_cnt = iop->_bufsiz; /* first write since seek--set cnt */
-		_BUFSYNC(iop);
-	}
-	return(0);
-}
-
-/*
- * _findbuf, called only when iop->_base == NULL, locates a predefined buffer
- * or allocates a buffer using malloc.  If a buffer is obtained from malloc,
- * the _IOMYBUF flag is set in iop->_flag.
- */
-
-void
-_findbuf(FILE *iop)
-{
-	int fno = fileno(iop); /* file number */
-	struct stat statb;
-	int size;
-
-	/* allocate a small block for unbuffered, large for buffered */
-	if (iop->_flag & _IONBF)  {
-		iop->_base = _smbuf[fno];
-		iop->_bufsiz = _SBFSIZ;
-	}  else  {
-
-		if ( isatty(fno) ) {
-			iop->_flag |= _IOLBF;
-			size = 128;
-		} else {
-			if (fstat(fno, &statb) < 0)
-				size = BUFSIZ;
-			else {
-				if ((size = statb.st_blksize) <= 0)
-					size = BUFSIZ;
-			}
-		}
-		if ((iop->_base = (unsigned char *) malloc(size+8)) != NULL) {
-			/* if  we got a buffer */
-			iop->_flag |= _IOMYBUF;
-			iop->_bufsiz = size;
-		} else {
-			/* if no room for buffer, use small buffer */
-			iop->_base = _smbuf[fno];
-			iop->_bufsiz = _SBFSIZ;
-			iop->_flag &= ~_IOLBF;
-			iop->_flag |= _IONBF;
-		}
-	}
-	iop->_ptr = iop->_base;
-}
-
-/*
- * The function _bufsync is called because interrupts and other signals
- * which occur in between the decrementing of iop->_cnt and the incrementing
- * of iop->_ptr, or in other contexts as well, may upset the synchronization
- * of iop->_cnt and iop->ptr.  If this happens, calling _bufsync should
- * resynchronize the two quantities (this is not always possible).  Resyn-
- * chronization guarantees that putc invocations will not write beyond
- * the end of the buffer.  Note that signals during _bufsync can cause
- * _bufsync to do the wrong thing, but usually with benign effects.
- */
-
-void
-_bufsync(FILE *iop)
-{
-	int spaceleft;
-	unsigned char *bufend = iop->_base + iop->_bufsiz;
-
-	if ((spaceleft = bufend - iop->_ptr) < 0)
-		iop->_ptr = bufend;
-	else if (spaceleft < iop->_cnt)
-		iop->_cnt = spaceleft;
-}