Return to findiop.c CVS log

Up to [CSRG BSD Unix] / 43BSD / lib / libc / stdio

Annotation of 43BSD/lib/libc/stdio/findiop.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 1983, 1985 Regents of the University of California.
                      3:  * All rights reserved.  The Berkeley software License Agreement
                      4:  * specifies the terms and conditions for redistribution.
                      5:  */
                      6: 
                      7: #if defined(LIBC_SCCS) && !defined(lint)
                      8: static char sccsid[] = "@(#)findiop.c  5.6 (Berkeley) 3/9/86";
                      9: #endif LIBC_SCCS and not lint
                     10: 
                     11: #include <stdio.h>
                     12: #include <errno.h>
                     13: 
                     14: extern int errno;
                     15: 
                     16: #define active(iop)    ((iop)->_flag & (_IOREAD|_IOWRT|_IORW))
                     17: 
                     18: #define NSTATIC        20      /* stdin + stdout + stderr + the usual */
                     19: 
                     20: FILE _iob[NSTATIC] = {
                     21:        { 0, NULL, NULL, 0, _IOREAD,            0 },    /* stdin  */
                     22:        { 0, NULL, NULL, 0, _IOWRT,             1 },    /* stdout */
                     23:        { 0, NULL, NULL, 0, _IOWRT|_IONBF,      2 },    /* stderr */
                     24: };
                     25: 
                     26: extern char    *calloc();
                     27: 
                     28: static char sbuf[NSTATIC];
                     29: char   *_smallbuf = sbuf;
                     30: static FILE    **iobglue;
                     31: static FILE    **endglue;
                     32: 
                     33: /*
                     34:  * Find a free FILE for fopen et al.
                     35:  * We have a fixed static array of entries, and in addition
                     36:  * may allocate additional entries dynamically, up to the kernel
                     37:  * limit on the number of open files.
                     38:  * At first just check for a free slot in the fixed static array.
                     39:  * If none are available, then we allocate a structure to glue together
                     40:  * the old and new FILE entries, which are then no longer contiguous.
                     41:  */
                     42: FILE *
                     43: _findiop()
                     44: {
                     45:        register FILE **iov, *iop;
                     46:        register FILE *fp;
                     47: 
                     48:        if (iobglue == 0) {
                     49:                for (iop = _iob; iop < _iob + NSTATIC; iop++)
                     50:                        if (!active(iop))
                     51:                                return (iop);
                     52: 
                     53:                if (_f_morefiles() == 0) {
                     54:                        errno = ENOMEM;
                     55:                        return (NULL);
                     56:                }
                     57:        }
                     58: 
                     59:        iov = iobglue;
                     60:        while (*iov != NULL && active(*iov))
                     61:                if (++iov >= endglue) {
                     62:                        errno = EMFILE;
                     63:                        return (NULL);
                     64:                }
                     65: 
                     66:        if (*iov == NULL)
                     67:                *iov = (FILE *)calloc(1, sizeof **iov);
                     68: 
                     69:        return (*iov);
                     70: }
                     71: 
                     72: _f_morefiles()
                     73: {
                     74:        register FILE **iov;
                     75:        register FILE *fp;
                     76:        register char *cp;
                     77:        int nfiles;
                     78: 
                     79:        nfiles = getdtablesize();
                     80: 
                     81:        iobglue = (FILE **)calloc(nfiles, sizeof *iobglue);
                     82:        if (iobglue == NULL)
                     83:                return (0);
                     84: 
                     85:        endglue = iobglue + nfiles;
                     86: 
                     87:        for (fp = _iob, iov = iobglue; fp < &_iob[NSTATIC]; /* void */)
                     88:                *iov++ = fp++;
                     89: 
                     90:        _smallbuf = calloc(nfiles, sizeof(*_smallbuf));
                     91:        return (1);
                     92: }
                     93: 
                     94: f_prealloc()
                     95: {
                     96:        register FILE **iov;
                     97:        register FILE *fp;
                     98: 
                     99:        if (iobglue == NULL && _f_morefiles() == 0)
                    100:                return;
                    101: 
                    102:        for (iov = iobglue; iov < endglue; iov++)
                    103:                if (*iov == NULL)
                    104:                        *iov = (FILE *)calloc(1, sizeof **iov);
                    105: }
                    106: 
                    107: _fwalk(function)
                    108:        register int (*function)();
                    109: {
                    110:        register FILE **iov;
                    111:        register FILE *fp;
                    112: 
                    113:        if (iobglue == NULL) {
                    114:                for (fp = _iob; fp < &_iob[NSTATIC]; fp++)
                    115:                        if (active(fp))
                    116:                                (*function)(fp);
                    117:        } else {
                    118:                for (iov = iobglue; iov < endglue; iov++)
                    119:                        if (*iov && active(*iov))
                    120:                                (*function)(*iov);
                    121:        }
                    122: }
                    123: 
                    124: _cleanup()
                    125: {
                    126:        extern int fclose();
                    127: 
                    128:        _fwalk(fclose);
                    129: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.