Return to prf.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / demo / pacman

Annotation of researchv9/jtools/src/demo/pacman/prf.c, revision 1.1

1.1     ! root        1: #include "style.h"
        !             2: #include "pacman.h"
        !             3: 
        !             4: /*     PIECES COMMENTED OUT TO SAVE SPACE */
        !             5: #ifdef BLIT
        !             6: 
        !             7: Code textmode;
        !             8: Point curloc;
        !             9: 
        !            10: showchar(c)
        !            11: char c;
        !            12: {
        !            13:        static char str[] = "x";
        !            14: 
        !            15:        str[0] = c;
        !            16:        curloc = string(&defont,str,&display,curloc,textmode);
        !            17: }
        !            18: 
        !            19: movexy(x,y)
        !            20: int    x,y;
        !            21: {
        !            22:        curloc.x = x*9+8;
        !            23:        curloc.y = y*16+12;
        !            24: }
        !            25: #endif
        !            26: 
        !            27: /*VARARGS1*/
        !            28: printf(fmt, x1)
        !            29: char *fmt;
        !            30: unsigned x1;
        !            31: {
        !            32:     extern int showchar();
        !            33: 
        !            34:     prf(fmt, &x1, showchar);
        !            35: }
        !            36: 
        !            37: 
        !            38: /*
        !            39:  * Scaled down version of C Library printf.
        !            40:  */
        !            41: 
        !            42: prf(fmt, adx, pfunc)
        !            43: register char *fmt;
        !            44: register int  *adx;
        !            45: int          (*pfunc)();
        !            46: {
        !            47:        register int b, c, i, len;
        !            48:        char *s;
        !            49:        int zfill;
        !            50:        int any;
        !            51: 
        !            52: loop:
        !            53:        while ((c = *fmt++) != '%') {
        !            54:                if(c == '\0')
        !            55:                        return;
        !            56:                (*pfunc)(c);
        !            57:        }
        !            58:        len = 0;
        !            59:        zfill = 0;
        !            60: 
        !            61: again:
        !            62:        c = *fmt++;
        !            63: 
        !            64:        switch (c) {
        !            65: 
        !            66: /*
        !            67:        case 'x': case 'X':
        !            68:                b = 16;
        !            69:                goto number;
        !            70:        case 'o': case 'O':
        !            71:                b = 8;
        !            72:                goto number;
        !            73:        case 'D':
        !            74:        case 'u':
        !            75: */
        !            76:        case 'd':
        !            77:                b = 10;
        !            78: number:
        !            79:                printn((long)*adx, b, len, zfill, pfunc);
        !            80:                break;
        !            81:        case 'l':
        !            82:                b = 10;
        !            83:                printn(*((long *)(adx++)), b, len, zfill, pfunc);
        !            84:                break;
        !            85: /*
        !            86:        case 'c':
        !            87:                b = *adx;
        !            88:                for (i = 24; i >= 0; i -= 8)
        !            89:                        if (c = (b >> i) & 0x7f)
        !            90:                                (*pfunc)(c);
        !            91:                break;
        !            92:        case 'b':
        !            93:                b = *adx++;
        !            94:                s = (char *)*adx;
        !            95:                printn((long)b, *s++,0,0, pfunc);
        !            96:                any = 0;
        !            97:                if (b) {
        !            98:                        (*pfunc)('<');
        !            99:                        while (i = *s++) {
        !           100:                                if (b & (1 << (i-1))) {
        !           101:                                        if (any)
        !           102:                                                (*pfunc)(',');
        !           103:                                        any = 1;
        !           104:                                        for (; (c = *s) > 32; s++)
        !           105:                                                (*pfunc)(c);
        !           106:                                } else
        !           107:                                        for (; *s > 32; s++)
        !           108:                                                ;
        !           109:                        }
        !           110:                        if (any)
        !           111:                                (*pfunc)('>');
        !           112:                }
        !           113:                break;
        !           114: */
        !           115:        case 's':
        !           116:                s = (char *)*adx;
        !           117:                while (c = *s++)
        !           118:                        (*pfunc)(c);
        !           119:                break;
        !           120: 
        !           121:        case '0':
        !           122:                if ( len==0 ) zfill = 1;
        !           123:        case '1': case '2': case '3': case '4':
        !           124:        case '5': case '6': case '7': case '8': case '9':
        !           125:                len = len*10 + (c-'0');
        !           126:                goto again;
        !           127: 
        !           128: 
        !           129: 
        !           130: 
        !           131:        case '%':
        !           132:                (*pfunc)('%');
        !           133:                break;
        !           134:        }
        !           135:        adx++;
        !           136:        goto loop;
        !           137: }
        !           138: 
        !           139: /*
        !           140:  * Printn prints a number n in base b.
        !           141:  * We don't use recursion to avoid deep kernel stacks.
        !           142:  */
        !           143: printn(n, b, len, zfill, pfunc)
        !           144: register long n;
        !           145: register int len;
        !           146: int (*pfunc)();
        !           147: {
        !           148:        char prbuf[11];
        !           149:        register char *cp;
        !           150: 
        !           151:        if (b == 10 && n < 0) {
        !           152:                (*pfunc)('-');
        !           153:                n = (unsigned)(-n);
        !           154:        }
        !           155:        cp = prbuf;
        !           156:        do {
        !           157:                *cp++ = "0123456789abcdef"[n%b];
        !           158:                n /= b;
        !           159:        } while (n);
        !           160:        while ( len-- > cp-prbuf )
        !           161:                if ( zfill )
        !           162:                        (*pfunc)('0');
        !           163:                else
        !           164:                        (*pfunc)(' ');
        !           165: 
        !           166:        do
        !           167:                (*pfunc)(*--cp);
        !           168:        while (cp > prbuf);
        !           169: }
        !           170: 
        !           171: 

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