Return to printf.c CVS log

Up to [Research Unix] / researchv10no / games / trek

Annotation of researchv10no/games/trek/printf.c, revision 1.1

1.1     ! root        1: #include "/usr/lib/a68defs"
        !             2: 
        !             3: int    mkfault;
        !             4: int    stdout 1;
        !             5: char printbuf[255]; char *printptr printbuf, *digitptr;
        !             6: 
        !             7: long itol(x,y)
        !             8: {
        !             9:        return((((long)x)<<16)|y);
        !            10: }
        !            11: 
        !            12: 
        !            13: printc(c)
        !            14: char c;
        !            15: {
        !            16: 
        !            17:        IF (*printptr++ = c)==NL ORF c==0
        !            18:        THEN IF mkfault==0 THEN write(stdout,printbuf,printptr-printbuf); FI
        !            19:             printptr=printbuf;
        !            20:        FI
        !            21: }
        !            22: 
        !            23: charpos()
        !            24: {      return(printptr-printbuf);
        !            25: }
        !            26: 
        !            27: flushout()
        !            28: {      IF printptr!=printbuf
        !            29:        THEN printc(0);
        !            30:        FI
        !            31: }
        !            32: 
        !            33: printf(fmat,a1)
        !            34: char *fmat, **a1;
        !            35: {
        !            36:        char *fptr, *s; int *vptr; long *dptr; double *rptr;
        !            37:        double real, rnd;
        !            38:        int x, decpt, n; long lx;
        !            39:        int width, prec; char c, adj; char flush;
        !            40:        char digits[64];
        !            41: 
        !            42:        fptr=fmat; vptr = &a1;
        !            43: 
        !            44:        WHILE c = *fptr++
        !            45:        DO  IF c!='%'
        !            46:            THEN printc(c);
        !            47:            ELSE IF *fptr=='-' THEN adj='l'; fptr++; ELSE adj='r'; FI
        !            48:                 width=convert(&fptr);
        !            49:                 IF *fptr=='.' THEN fptr++; prec=convert(&fptr); ELSE prec = -1; FI
        !            50:                 digitptr=digits;
        !            51:                 dptr=rptr=vptr; lx = *dptr; x = *vptr++;
        !            52:                 s=0; flush=0;
        !            53:                 switch (c = *fptr++) {
        !            54: 
        !            55:                    case 'n':
        !            56:                        flush++; break;
        !            57:                    case 'd':
        !            58:                    case 'u':
        !            59:                        printnum(x,c,10); break;
        !            60:                    case 'o':
        !            61:                        printoct(0,x,0); break;
        !            62:                    case 'q':
        !            63:                        lx=x; printoct(lx,-1); break;
        !            64:                    case 'x':
        !            65:                        printdbl(0,x,c,16); break;
        !            66:                    case 'Y':
        !            67:                        printdate(lx); vptr++; break;
        !            68:                    case 'D':
        !            69:                    case 'U':
        !            70:                        printdbl(lx,c,10); vptr++; break;
        !            71:                    case 'O':
        !            72:                        printoct(lx,0); vptr++; break;
        !            73:                    case 'Q':
        !            74:                        printoct(lx,-1); vptr++; break;
        !            75:                    case 'X':
        !            76:                        printdbl(lx,'x',16); vptr++; break;
        !            77:                    case 'c':
        !            78:                        printc(x); break;
        !            79:                    case 's':
        !            80:                        s=x; break;
        !            81:                    case 'f':
        !            82:                    case 'F':
        !            83:                        vptr =+ 3;
        !            84:                        rnd=1.0;
        !            85:                        for(n=prec;n>=0;n--)
        !            86:                                rnd =* 10;
        !            87:                        real = *rptr + (5 / rnd);
        !            88:                        s=ecvt(real, 8, &decpt, &n);
        !            89:                        IF n THEN *digitptr++='-'; FI
        !            90:                        *digitptr++ = (decpt<=0 ? '0' : *s++);
        !            91:                        WHILE *s ANDF --decpt>0 DO *digitptr++ = *s++; OD
        !            92:                        *digitptr++ = '.';
        !            93:                        WHILE *s ANDF prec-- DO *digitptr++ = (++decpt<0?'0':*s++); OD
        !            94:                        *digitptr++=0;
        !            95:                        s=0; prec = -1; break;
        !            96:                    case 'm':
        !            97:                        vptr--; break;
        !            98:                    case 'M':
        !            99:                        width=x; break;
        !           100:                    case 'T':
        !           101:                    case 't':
        !           102:                        IF c=='T'
        !           103:                        THEN width=x;
        !           104:                        ELSE vptr--;
        !           105:                        FI
        !           106:                        IF width
        !           107:                        THEN width =- charpos()%width;
        !           108:                        FI
        !           109:                        break;
        !           110:                    default:
        !           111:                        printc(c); vptr--;
        !           112:                }
        !           113: 
        !           114:                IF s==0
        !           115:                THEN *digitptr=0; s=digits;
        !           116:                FI
        !           117:                n=length(s);
        !           118:                n=(prec<n ANDF prec>=0 ? prec : n);
        !           119:                width =- n;
        !           120:                IF adj=='r'
        !           121:                THEN WHILE width-- > 0
        !           122:                     DO printc(SP); OD
        !           123:                FI
        !           124:                WHILE n-- DO printc(*s++); OD
        !           125:                WHILE width-- > 0 DO printc(SP); OD
        !           126:                digitptr=digits;
        !           127:                IF flush THEN flushout(); FI
        !           128:            FI
        !           129:        OD
        !           130: }
        !           131: 
        !           132: printdate(tvec)
        !           133: long tvec;
        !           134: {
        !           135:        STRING timeptr; REG INT i;
        !           136:        timeptr = ctime(&tvec);
        !           137:        FOR i=20; i<24; i++ DO *digitptr++ = *(timeptr+i); OD
        !           138:        FOR i=3; i<19; i++ DO *digitptr++ = *(timeptr+i); OD
        !           139: } /*printdate*/
        !           140: 
        !           141: prints(s)
        !           142: char *s;
        !           143: {      printf("%s",s);
        !           144: }
        !           145: 
        !           146: convert(cp)
        !           147: char **cp;
        !           148: {      char c; int n;
        !           149:        n=0;
        !           150:        WHILE ((c = *(*cp)++)>='0') ANDF (c<='9') DO n=n*10+c-'0'; OD
        !           151:        (*cp)--;
        !           152:        return(n);
        !           153: }
        !           154: 
        !           155: printnum(n,fmat,base)
        !           156: {      char k; int digs[15]; int *dptr;
        !           157:        long    N;
        !           158:        dptr=digs;
        !           159:        IF n<0 ANDF fmat=='d' THEN n = -n; *digitptr++ = '-'; FI
        !           160:        N= (unsigned)n;
        !           161:        WHILE N
        !           162:        DO  *dptr++ = N%base;
        !           163:            N /= base;
        !           164:        OD
        !           165:        IF dptr==digs THEN *dptr++=0; FI
        !           166:        WHILE dptr!=digs
        !           167:        DO  k = *--dptr;
        !           168:            *digitptr++ = (k+(k<=9 ? '0' : 'a'-10));
        !           169:        OD
        !           170: }
        !           171: 
        !           172: printoct(o,s) long o; int s;
        !           173: {
        !           174:        int i;
        !           175:        long po;
        !           176:        char digs[12];
        !           177:        po = o;
        !           178:        IF s
        !           179:        THEN IF po<0
        !           180:             THEN po = -po; *digitptr++='-';
        !           181:             ELSE IF s>0 THEN *digitptr++='+'; FI
        !           182:             FI
        !           183:        FI
        !           184:        FOR i=0;i<=11;i++
        !           185:        DO digs[i] = po&7; po =>> 3; OD
        !           186:        digs[10] =& 03; digs[11]=0;
        !           187:        FOR i=11;i>=0;i--
        !           188:        DO IF digs[i] THEN EXITFOR; FI OD
        !           189:        FOR i++;i>=0;i--
        !           190:        DO *digitptr++=digs[i]+'0'; OD
        !           191: }
        !           192: 
        !           193: printdbl(lx,ly,fmat,base)
        !           194: unsigned lx, ly; char fmat; int base;
        !           195: {      int digs[20]; int *dptr; char k;
        !           196:        double f ,g; long q;
        !           197:        dptr=digs;
        !           198:        IF fmat!='D'
        !           199:        THEN    f=(lx); f =* itol(1,0); f =+ (ly);
        !           200:                IF fmat=='x' THEN *digitptr++='#'; FI
        !           201:        ELSE    f=itol(lx,ly);
        !           202:                IF f<0 THEN *digitptr++='-'; f = -f; FI
        !           203:        FI
        !           204:        WHILE f
        !           205:        DO  q=f/base; g=q;
        !           206:            *dptr++ = f-g*base;
        !           207:            f=q;
        !           208:        OD
        !           209:        IF dptr==digs THEN *dptr++=0; FI
        !           210:        WHILE dptr!=digs
        !           211:        DO  k = *--dptr;
        !           212:            *digitptr++ = (k+(k<=9 ? '0' : 'a'-10));
        !           213:        OD
        !           214: }
        !           215: 
        !           216: length(s)
        !           217: char *s;
        !           218: {
        !           219:        REG CHAR *t;
        !           220: 
        !           221:        t=s;
        !           222:        WHILE *t++ DONE
        !           223:        return(t-s-1);
        !           224: }

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