Annotation of researchv10no/games/trek/printf.c, revision 1.1.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: }

unix.superglobalmegacorp.com

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