Return to fileio.c CVS log

Up to [MW Coherent from dump] / coherent / g / usr / bin / me

Annotation of coherent/g/usr/bin/me/fileio.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * The routines in this file read and write ASCII files from the
        !             3:  * disk.  All of the knowledge about files are here.  A better message
        !             4:  * writing scheme should be used.
        !             5:  */
        !             6: #include       <stdio.h>
        !             7: #include       "ed.h"
        !             8: #include       <access.h>
        !             9: 
        !            10: FILE   *ffp;                           /* File pointer, all functions. */
        !            11: 
        !            12: /*
        !            13:  * Open a file for reading.
        !            14:  */
        !            15: ffropen(fn)
        !            16: uchar  *fn;
        !            17: {
        !            18:        if ((ffp=fopen(fn, "r")) == NULL)
        !            19:                if (access(fn, AEXISTS)) /* access returns 0 on success */
        !            20:                        return (FIOFNF); /* new file */
        !            21:                else
        !            22:                        return (FIOERR); /* error */
        !            23:        return (FIOSUC);
        !            24: }
        !            25: 
        !            26: /*
        !            27:  * Open a file for writing.
        !            28:  * Return TRUE if all is well, and FALSE on error (cannot create).
        !            29:  */
        !            30: ffwopen(fn, w)
        !            31: uchar  *fn, *w;
        !            32: {
        !            33: #if    VMS
        !            34:        register int    fd;
        !            35: 
        !            36:        if ((fd=creat(fn, 0666, "rfm=var", "rat=cr")) < 0
        !            37:        || (ffp=fdopen(fd, w)) == NULL) {
        !            38: #else
        !            39:        if ((ffp=fopen(fn, w)) == NULL) {
        !            40: #endif
        !            41:                mlwrite("Cannot open file for writing");
        !            42:                return (FIOERR);
        !            43:        }
        !            44:        return (FIOSUC);
        !            45: }
        !            46: 
        !            47: /*
        !            48:  * Close a file.
        !            49:  * Should look at the status in all systems.
        !            50:  */
        !            51: ffclose()
        !            52: {
        !            53: #if    V7
        !            54:        if (fclose(ffp) != FALSE) {
        !            55:                mlwrite("Error closing file");
        !            56:                return (FIOERR);
        !            57:        }
        !            58:        return (FIOSUC);
        !            59: #endif
        !            60:        fclose(ffp);
        !            61:        return (FIOSUC);
        !            62: }
        !            63: 
        !            64: /*
        !            65:  * Write a line to the already opened file.  The "buf" points to the
        !            66:  * buffer, and the "nbuf" is its length, less the free newline.
        !            67:  * Return the status.
        !            68:  * Check only at the newline.
        !            69:  */
        !            70: ffputline(buf, nbuf)
        !            71: #ifdef SLOW
        !            72: register uchar buf[];
        !            73: #else
        !            74: uchar  buf[];
        !            75: #endif
        !            76: {
        !            77:        register int    i;
        !            78: 
        !            79: #ifdef SLOW
        !            80:        for (i=0; i<nbuf; ++i)
        !            81:                putc(buf[i]&0xFF, ffp);
        !            82: #else
        !            83:        fwrite(buf, 1, nbuf, ffp);
        !            84: #endif
        !            85:        putc('\n', ffp);
        !            86:        if (ferror(ffp) != FALSE) {
        !            87:                mlwrite("Write I/O error");
        !            88:                return (FIOERR);
        !            89:        }
        !            90:        return (FIOSUC);
        !            91: }
        !            92: 
        !            93: /*
        !            94:  * Read a line from a file and store the bytes in the supplied buffer.
        !            95:  * The "nbuf" is the length of the buffer.  Complain about long lines
        !            96:  * and lines at the end of the file that don't have a newline present.
        !            97:  * Check for I/O errors too.  Return status.
        !            98:  */
        !            99: ffgetline(buf, nbuf)
        !           100: register uchar buf[];
        !           101: {
        !           102:        register int    c;
        !           103:        register int    i;
        !           104: 
        !           105:        i = 0;
        !           106: #ifdef SLOW
        !           107:        while ((c=getc(ffp))!=EOF && c!='\n') {
        !           108:                if (i >= nbuf-1) {
        !           109:                        mlwrite("File has long line");
        !           110:                        buf[i] = 0;
        !           111:                        ungetc(c, ffp);
        !           112:                        return (FIOSUC);        /* Make long lines load */
        !           113:                }
        !           114:                buf[i++] = c;
        !           115:        }
        !           116: #else
        !           117:        if (fgets(buf, nbuf, ffp) != NULL) {
        !           118:                for (i=0; i<nbuf-1; i++) {
        !           119:                        if ((c = buf[i]) == '\n') {
        !           120:                                buf[i] = 0;
        !           121:                                goto lineread;
        !           122:                        }
        !           123:                }
        !           124:                mlwrite("File has long line");
        !           125:                buf[i] = 0;
        !           126:                return FIOSUC;
        !           127:        } else
        !           128:                c = EOF;
        !           129: lineread:
        !           130: #endif
        !           131:        if (c == EOF) {
        !           132:                if (ferror(ffp) != FALSE) {
        !           133:                        mlwrite("File read error");
        !           134:                        return (FIOERR);
        !           135:                }
        !           136:                if (i != 0) {
        !           137:                        mlwrite("File has funny line at EOF");
        !           138:                        buf[i]=0;               /* Make funny line show up. */
        !           139:                        return (FIOSUC);
        !           140:                }
        !           141:                return (FIOEOF);
        !           142:        }
        !           143:        buf[i] = 0;
        !           144:        return (FIOSUC);
        !           145: }

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