Return to out.c CVS log

Up to [Research Unix] / researchv8dc / cmd / cfront / libC / stream

Annotation of researchv8dc/cmd/cfront/libC/stream/out.c, revision 1.1

1.1     ! root        1: /*
        !             2:        C++ stream i/o source
        !             3: 
        !             4:        out.c
        !             5: */
        !             6: sprintf(char*,char* ...);
        !             7: strlen(char*);
        !             8: #include "stream.h"
        !             9: #include <common.h>
        !            10: 
        !            11: 
        !            12: #define MAXOSTREAMS 20
        !            13: 
        !            14: char cout_buf[BUFSIZE];
        !            15: filebuf cout_file(1,cout_buf,BUFSIZE); // UNIX output stream 1
        !            16: ostream cout(&cout_file);
        !            17: 
        !            18: char cerr_buf[1];
        !            19: filebuf cerr_file(2,cerr_buf,0);       // UNIX output stream 2
        !            20:                                        // 0-length to ensure unbuffered output
        !            21: ostream cerr(&cerr_file);
        !            22: 
        !            23: const  cb_size = 512;
        !            24: const  fld_size = 128;
        !            25: 
        !            26: /* a circular formating buffer */
        !            27: static char    formbuf[cb_size];
        !            28: static char*   bfree=formbuf;
        !            29: static char*   max = &formbuf[cb_size-1];
        !            30: 
        !            31: char* chr(register i, register int w)  /* note: chr(0) is "" */
        !            32: {
        !            33:        register char* buf = bfree;
        !            34: 
        !            35:        if (w<=0 || fld_size<w) w = 1;
        !            36:        w++;                            /* space for trailing 0 */
        !            37:        if (max < buf+w) buf = formbuf;
        !            38:        bfree = buf+w;
        !            39:        char * res = buf;
        !            40: 
        !            41:        w -= 2;                         /* pad */
        !            42:        while (w--) *buf++ = ' ';
        !            43:        if (i<0 || 127<i) i = ' ';
        !            44:        *buf++ = i;
        !            45:        *buf = 0;
        !            46:        return res;
        !            47: }
        !            48: 
        !            49: char* str(char* s, register int w)
        !            50: {
        !            51:        register char* buf = bfree;
        !            52:        int ll = strlen(s);
        !            53:        if (w<=0 || fld_size<w) w = ll;
        !            54:        if (w < ll) ll = w;
        !            55:        w++;                            /* space for traling 0 */
        !            56:        if (max < buf+w) buf = formbuf;
        !            57:        bfree = buf+w;
        !            58:        char* res = buf;
        !            59: 
        !            60:        w -= (ll+1);                    /* pad */
        !            61:        while (w--) *buf++ = ' ';
        !            62:        while (*s) *buf++ = *s++;
        !            63:        *buf = 0;
        !            64:        return res;
        !            65: }
        !            66: 
        !            67: char* form(char* format ...)
        !            68: {
        !            69:        register* ap = (int*)&format;
        !            70:        register char* buf = bfree;
        !            71:        if (max < buf+fld_size) buf = formbuf;
        !            72: 
        !            73:        register ll = sprintf(buf,format,ap[1],ap[2],ap[3],ap[4],ap[5],ap[6],ap[7],ap[8]);
        !            74:        if (0<ll && ll<1024)                            /* length */
        !            75:                ;
        !            76:        else if (buf<(char*)ll && (char*)ll<buf+1024)   /* pointer to trailing 0 */
        !            77:                ll = (char*)ll - buf;
        !            78:        else
        !            79:                ll = strlen(buf);
        !            80:        if (fld_size < ll) exit(10);
        !            81:        bfree += (ll+1);
        !            82:        return buf;
        !            83: }
        !            84: 
        !            85: const char a10 = 'a'-10;
        !            86: 
        !            87: char* hex(long i, register w)
        !            88: {
        !            89:        int m = sizeof(long)*2;         /* maximum hex digits for a long */
        !            90:        if (w<0 || fld_size<w) w = 0;
        !            91:        int sz = (w?w:m)+1;
        !            92:        register char* buf = bfree;
        !            93:        if (max < buf+sz) buf = formbuf;
        !            94:        register char* p = buf+sz;
        !            95:        bfree = p+1;
        !            96:        *p-- = 0;                       /* trailing 0 */
        !            97: 
        !            98:        if (w) {
        !            99:                do {
        !           100:                        register h = i&0xf;
        !           101:                        *p-- = (h < 10) ? h+'0' : h+a10;
        !           102:                } while (w-- && (i>>=4));
        !           103:                while (w--) *p-- = ' ';
        !           104:        }
        !           105:        else {
        !           106:                do {
        !           107:                        register h = i&0xf;
        !           108:                        *p-- = (h < 10) ? h+'0' : h+a10;
        !           109:                } while (i>>=4);
        !           110:        }
        !           111:        return p+1;
        !           112: }
        !           113: 
        !           114: char* oct(long i, int w)
        !           115: {
        !           116:        int m = sizeof(long)*3;         /* maximum oct digits for a long */
        !           117:        if (w<0 || fld_size<w) w = 0;
        !           118:        int sz = (w?w:m)+1;
        !           119:        register char* buf = bfree;
        !           120:        if (max < buf+sz) buf = formbuf;
        !           121:        register char* p = buf+sz;
        !           122:        bfree = p+1;
        !           123:        *p-- = 0;                       /* trailing 0 */
        !           124: 
        !           125:        if (w) {
        !           126:                do {
        !           127:                        register h = i&07;
        !           128:                        *p-- = h+'0';
        !           129:                } while (w-- && (i>>=3));
        !           130:                while (w--) *p-- = ' ';
        !           131:        }
        !           132:        else {
        !           133:                do {
        !           134:                        register h = i&07;
        !           135:                        *p-- = h+'0';
        !           136:                } while (i>>=3);
        !           137:        }
        !           138: 
        !           139:        return p+1;
        !           140: }
        !           141: 
        !           142: char* dec(long i, int w)
        !           143: {
        !           144:        int m = sizeof(long)*3;         /* maximum dec digits for a long */
        !           145:        if (w<0 || fld_size<w) w = 0;
        !           146:        int sz = (w?w:m)+1;
        !           147:        register char* buf = bfree;
        !           148:        if (max < buf+sz) buf = formbuf;
        !           149:        register char* p = buf+sz;
        !           150:        bfree = p+1;
        !           151:        *p-- = 0;                       /* trailing 0 */
        !           152: 
        !           153:        if (w) {
        !           154:                do {
        !           155:                        register h = i%10;
        !           156:                        *p-- = h + '0';
        !           157:                } while (w-- && (i/=10));
        !           158:                while (w--) *p-- = ' ';
        !           159:        }
        !           160:        else {
        !           161:                do {
        !           162:                        register h = i%10;
        !           163:                        *p-- = h + '0';
        !           164:                } while (i/=10);
        !           165:        }
        !           166: 
        !           167:        return p+1;
        !           168: }
        !           169: 
        !           170: 
        !           171: ostream& ostream.operator<<(char* s)
        !           172: {
        !           173:        register streambuf* nbp = bp;
        !           174:        if (state) return *this;
        !           175:        if (*s == 0) return *this;
        !           176:        do
        !           177:                if (nbp->sputc(*s++) == EOF) {
        !           178:                        state |= _eof|_fail;
        !           179:                        break;
        !           180:                }
        !           181:        while (*s);
        !           182: //     if (*(s-1)=='\n') flush(); /* fudge due to lack of  destructors for static*/
        !           183:        return *this;
        !           184: }
        !           185: 
        !           186: ostream& ostream.operator<<(long i)
        !           187: {
        !           188:        register streambuf* nbp = bp;
        !           189:        register long j;
        !           190:        char buf[32];
        !           191:        register char *p = buf;
        !           192: 
        !           193:        if (state) return *this;
        !           194: 
        !           195:        if (i < 0) {
        !           196:                nbp->sputc('-');
        !           197:                j = -i;
        !           198:        } else
        !           199:                j = i;
        !           200:        do {
        !           201:                *p++ = '0' + j%10;
        !           202:                j = j/10;
        !           203:        } while (j > 0);
        !           204:        do {
        !           205:                if (nbp->sputc(*--p) == EOF) {
        !           206:                        state |= _fail | _eof;
        !           207:                        break;
        !           208:                }
        !           209:        } while (p != buf);
        !           210:        return *this;
        !           211: }
        !           212: 
        !           213: ostream& ostream.put(char c)
        !           214: {
        !           215:        if (state) return *this;
        !           216: 
        !           217:        if (bp->sputc(c) == EOF) state |= _eof|_fail;
        !           218: 
        !           219:        return *this;
        !           220: }
        !           221: 
        !           222: ostream& ostream.operator<<(double d)
        !           223: {
        !           224:        register streambuf* nbp = bp;
        !           225:        char buf[32];
        !           226:        register char *p = buf;
        !           227: 
        !           228:        if (state) return *this;
        !           229: 
        !           230:        sprintf(buf,"%g",d);
        !           231:        while (*p != '\0')
        !           232:                if (nbp->sputc(*p++) == EOF) {
        !           233:                        state |= _eof|_fail;
        !           234:                        break;
        !           235:                }
        !           236:        return *this;
        !           237: }
        !           238: 
        !           239: ostream& ostream.operator<<(streambuf& b)
        !           240: {
        !           241:        register streambuf* nbp = bp;
        !           242:        register int c;
        !           243: 
        !           244:        if (state) return *this;
        !           245: 
        !           246:        c = b.sgetc();
        !           247:        while (c != EOF) {
        !           248:                if (nbp->sputc(c) == EOF) {
        !           249:                        state |= _eof|_fail;
        !           250:                        break;
        !           251:                }
        !           252:                c = b.snextc();
        !           253:        }
        !           254:                
        !           255:        return *this;
        !           256: }
        !           257: 
        !           258: 

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