Return to fseek.c CVS log

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

Annotation of 43BSDTahoe/lib/libc/stdio/fseek.c, revision 1.1.1.1

1.1       root        1: #if defined(LIBC_SCCS) && !defined(lint)
                      2: static char sccsid[] = "@(#)fseek.c    5.3 (Berkeley) 3/9/86";
                      3: #endif LIBC_SCCS and not lint
                      4: 
                      5: /*
                      6:  * Seek for standard library.  Coordinates with buffering.
                      7:  */
                      8: 
                      9: #include       <stdio.h>
                     10: 
                     11: long lseek();
                     12: 
                     13: fseek(iop, offset, ptrname)
                     14:        register FILE *iop;
                     15:        long offset;
                     16: {
                     17:        register resync, c;
                     18:        long p = -1;                    /* can't happen? */
                     19: 
                     20:        iop->_flag &= ~_IOEOF;
                     21:        if (iop->_flag&_IOREAD) {
                     22:                if (ptrname<2 && iop->_base &&
                     23:                        !(iop->_flag&_IONBF)) {
                     24:                        c = iop->_cnt;
                     25:                        p = offset;
                     26:                        if (ptrname==0) {
                     27:                                long curpos = lseek(fileno(iop), 0L, 1);
                     28:                                if (curpos == -1)
                     29:                                        return (-1);
                     30:                                p += c - curpos;
                     31:                        } else
                     32:                                offset -= c;
                     33:                        if(!(iop->_flag&_IORW) && c>0&&p<=c
                     34:                            && p>=iop->_base-iop->_ptr){
                     35:                                iop->_ptr += (int)p;
                     36:                                iop->_cnt -= (int)p;
                     37:                                return(0);
                     38:                        }
                     39:                        resync = offset&01;
                     40:                } else 
                     41:                        resync = 0;
                     42:                if (iop->_flag & _IORW) {
                     43:                        iop->_ptr = iop->_base;
                     44:                        iop->_flag &= ~_IOREAD;
                     45:                        resync = 0;
                     46:                }
                     47:                p = lseek(fileno(iop), offset-resync, ptrname);
                     48:                iop->_cnt = 0;
                     49:                if (resync && p != -1)
                     50:                        if (getc(iop) == EOF)
                     51:                                p = -1;
                     52:        }
                     53:        else if (iop->_flag & (_IOWRT|_IORW)) {
                     54:                p = fflush(iop);
                     55:                if (iop->_flag & _IORW) {
                     56:                        iop->_cnt = 0;
                     57:                        iop->_flag &= ~_IOWRT;
                     58:                        iop->_ptr = iop->_base;
                     59:                }
                     60:                return(lseek(fileno(iop), offset, ptrname) == -1 || p == EOF ?
                     61:                    -1 : 0);
                     62:        }
                     63:        return(p==-1?-1:0);
                     64: }

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