Return to portli.cc CVS log

Up to [CSRG BSD Unix] / 40BSD / libc / stdio

Annotation of 40BSD/libc/stdio/portli.cc, revision 1.1

1.1     ! root        1: #include       <stdio.h>
        !             2: #define        ntof(n) (&_iob[n])
        !             3: 
        !             4: int    cin     0;
        !             5: int    cout    1;
        !             6: 
        !             7: cclose(n)
        !             8: {
        !             9:        return(fclose(ntof(n)));
        !            10: }
        !            11: 
        !            12: ceof(n)
        !            13: {
        !            14:        return(feof(ntof(n)));
        !            15: }
        !            16: 
        !            17: cexit(x)
        !            18: {
        !            19:        exit(x);
        !            20: }
        !            21: 
        !            22: cflush(n)
        !            23: {
        !            24:        return(fflush(ntof(n)));
        !            25: }
        !            26: 
        !            27: cgetc(n)
        !            28: {
        !            29:        register c;
        !            30: 
        !            31:        if ((c = getc(ntof(n))) < 0)
        !            32:                return(0);
        !            33:        return(c);
        !            34: }
        !            35: 
        !            36: copen(f, m)
        !            37: char m;
        !            38: {
        !            39:        register struct _iobuf *iop;
        !            40: 
        !            41:        if ((iop = fopen(f, &m)) == NULL)
        !            42:                return(-1);
        !            43:        return(fileno(iop));
        !            44: }
        !            45: 
        !            46: cputc(c, n)
        !            47: {
        !            48:        putc(c, ntof(n));
        !            49: }
        !            50: 
        !            51: cread(a, b, c, n)
        !            52: {
        !            53:        return(fread(a, b, c, ntof(n)));
        !            54: }
        !            55: 
        !            56: cwrite(a, b, c, n)
        !            57: {
        !            58:        return(fwrite(a, b, c, ntof(n)));
        !            59: }
        !            60: getcharz()
        !            61: {
        !            62:        register c;
        !            63: 
        !            64:        if ((c = getc(ntof(cin))) < 0)
        !            65:                return(0);
        !            66:        return(c);
        !            67: }
        !            68: 
        !            69: printf(a, b, c, d)
        !            70: {
        !            71:        struct _iobuf _strbuf;
        !            72:        if (a==-1) {
        !            73:                _strbuf._flag = _IOWRT+_IOSTRG;
        !            74:                _strbuf._ptr = b;
        !            75:                _strbuf._cnt = 32767;
        !            76:                _doprnt(c, &d, &_strbuf);
        !            77:                putc('\0', &_strbuf);
        !            78:        } else if (a<=10) {
        !            79:                _doprnt(b, &c, ntof(a));
        !            80:        } else
        !            81:                _doprnt(a, &b, ntof(cout));
        !            82: }
        !            83: 
        !            84: putcharz(c)
        !            85: {
        !            86:        return(putc(c, ntof(cout)));
        !            87: }
        !            88: 
        !            89: gets(s)
        !            90: char *s;
        !            91: {
        !            92:        register c;
        !            93:        register char *cs;
        !            94: 
        !            95:        cs = s;
        !            96:        while ((c = getc(ntof(cin))) != '\n' && c>=0)
        !            97:                *cs++ = c;
        !            98:        if (c<0 && cs==s)
        !            99:                return(NULL);
        !           100:        *cs++ = '\0';
        !           101:        return(s);
        !           102: }
        !           103: 
        !           104: puts(s)
        !           105: char *s;
        !           106: {
        !           107:        register c;
        !           108: 
        !           109:        while (c = *s++)
        !           110:                putc(c, ntof(cout));
        !           111:        putc('\n', ntof(cout));
        !           112: }
        !           113: 
        !           114: rew(n)
        !           115: {
        !           116:        rewind(ntof(n));
        !           117: }
        !           118: 
        !           119: scanf(a, b, c, d)
        !           120: {
        !           121:        struct _iobuf strbuf;
        !           122:        register char *s;
        !           123: 
        !           124:        if (a == -1) {
        !           125:                strbuf._flag = _IOREAD|_IOSTRG;
        !           126:                strbuf._ptr = strbuf._base = b;
        !           127:                strbuf._cnt = 0;
        !           128:                s = b;
        !           129:                while (*s++)
        !           130:                        strbuf._cnt++;
        !           131:                return(_doscan(&strbuf, c, &d));
        !           132:        } else if (a<=10)
        !           133:                return(_doscan(ntof(a), b, &c));
        !           134:        else
        !           135:                return(_doscan(ntof(cin), a, &b));
        !           136: }

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