Return to putchar.c CVS log

Up to [Research Unix] / researchv8dc / cmd / qed

Annotation of researchv8dc/cmd/qed/putchar.c, revision 1.1

1.1     ! root        1: /*% cc -c -O %
        !             2:  */
        !             3: #include "vars.h"
        !             4: #ifdef PDP11
        !             5: typedef        long ulong;
        !             6: #else
        !             7: typedef        unsigned long ulong;
        !             8: #endif
        !             9: int    col;
        !            10: putdn(i)
        !            11: {
        !            12:        putlong((ulong)i);
        !            13:        putchar('\n');
        !            14: }
        !            15: #ifdef PDP11
        !            16: /*
        !            17:  *     In version 6, ldiv() is in the library. In version 7, it is separate:
        !            18:        .globl  _ldiv, _ldivr
        !            19:        _ldiv:
        !            20:                mov     2(sp), r0
        !            21:                mov     4(sp), r1
        !            22:                div     6(sp), r0
        !            23:                mov     r1,_ldivr
        !            24:                rts     pc
        !            25:        .bss
        !            26:        _ldivr: .=.+2
        !            27:  */
        !            28: putlong(i)
        !            29:        long i;
        !            30: {
        !            31:        register char r;
        !            32:        extern int ldiv(), ldivr;
        !            33: 
        !            34:        /* the following pornography saves bundles of memory */
        !            35:        i = ldiv(i,10);
        !            36:        r = ldivr + '0';
        !            37:        if (i)
        !            38:                putlong(i);
        !            39:        putchar(r);
        !            40: }
        !            41: #endif
        !            42: #ifndef        PDP11
        !            43: putlong(i)
        !            44:        ulong i;
        !            45: {
        !            46:        register r;
        !            47:        r = i%10;
        !            48:        i /= 10;
        !            49:        if(i)
        !            50:                putlong(i);
        !            51:        putchar('0'+r);
        !            52: }
        !            53: #endif
        !            54: putl(sp)
        !            55:        register char *sp;
        !            56: {
        !            57:        listf++;
        !            58:        puts(sp);
        !            59:        listf = FALSE;
        !            60: }
        !            61: puts(sp)
        !            62:        register char *sp;
        !            63: {
        !            64:        col = 0;
        !            65:        while (*sp)
        !            66:                putchar(*sp++);
        !            67:        putchar('\n');
        !            68: }
        !            69: display(lf)
        !            70: {
        !            71:        register int *a1;
        !            72:        register int r;
        !            73:        register char *p;
        !            74:        register i;
        !            75:        int nf;
        !            76:        listf = (lf == 'l' || lf == 'L');
        !            77:        nf = (lf == 'P' || lf == 'L');
        !            78:        lf = listf;
        !            79:        setdot();
        !            80:        nonzero();
        !            81:        a1 = addr1;
        !            82:        r = (a1 - zero) & 077777;
        !            83:        do{
        !            84:                col = 0;
        !            85:                if(nf){
        !            86:                        putlong((ulong)r++);
        !            87:                        for(i=0; i<NBUFS; i++)
        !            88:                                if((*a1|01) == names[i]){
        !            89:                                        putchar('\'');
        !            90:                                        putchar(bname[i]);
        !            91:                                }
        !            92:                        listf = 0;
        !            93:                        putchar('\t');
        !            94:                        col = 8;
        !            95:                        listf = lf;
        !            96:                }
        !            97:                for(p = getline(*a1++,linebuf);*p;putchar(*p++));
        !            98:                putchar('\n');
        !            99:        }while (a1 <= addr2);
        !           100:        dot = addr2;
        !           101:        listf = FALSE;
        !           102: }
        !           103: putct(c){
        !           104:        putchar(c);
        !           105:        putchar('\t');
        !           106: }
        !           107: putchar(c)
        !           108: register char c;
        !           109: {
        !           110:        register char *lp;
        !           111: 
        !           112:        lp = linp;
        !           113:        if (listf) {
        !           114:                if (c=='\n') {
        !           115:                        if(linp!=line && linp[-1]==' ') {
        !           116:                                *lp++ = '\\';
        !           117:                                *lp++ = 'n';
        !           118:                        }
        !           119:                } else {
        !           120:                        if (col >= (72-4-2)) {
        !           121:                                *lp++ = '\\';
        !           122:                                *lp++ = '\n';
        !           123:                                *lp++ = '\t';
        !           124:                                col = 8;
        !           125:                        }
        !           126:                        col++;
        !           127:                        if (c=='\b' || c=='\\' || c=='\t') {
        !           128:                                *lp++ = '\\';
        !           129:                                c = c=='\b'? 'b' : c=='\t'? 't' : '\\';
        !           130:                                col++;
        !           131:                        } else if ((c&0200) || c<' ' || c=='\177') {
        !           132:                                *lp++ = '\\';
        !           133:                                *lp++ = ((c>>6)&03)+'0';
        !           134:                                *lp++ = ((c>>3)&07)+'0';
        !           135:                                c     = ( c    &07)+'0';
        !           136:                                col += 3;
        !           137:                        }
        !           138:                }
        !           139:        }
        !           140:        *lp++ = c;
        !           141:        if(c == '\n' || lp >= &line[(sizeof line)-2-4]) {
        !           142:                linp = lp;
        !           143:                flush();
        !           144:                lp = linp;
        !           145:        }
        !           146:        linp = lp;
        !           147: }
        !           148: flush()
        !           149: {
        !           150:        if(linp != line){
        !           151:                write(1, line, linp-line);
        !           152:                linp = line;
        !           153:        }
        !           154: }

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