Return to printf.c CVS log

Up to [Research Unix] / researchv9 / jerq / src / lib / j / drek

Annotation of researchv9/jerq/src/lib/j/drek/printf.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Scaled down version of C Library printf.
                      3:  * Only %s %u %d (==%u) %o %x %D are recognized.
                      4:  */
                      5: #include <jerq.h>
                      6: #include <jerqio.h>
                      7: char *_doprnt();
                      8: 
                      9: printf(fmt, x1)
                     10:        char *fmt;
                     11:        unsigned x1;
                     12: {
                     13:        _doprnt(stdout, fmt, &x1);
                     14: }
                     15: 
                     16: fprintf(f, fmt, x1)
                     17:        FILE *f;
                     18:        char *fmt;
                     19:        unsigned x1;
                     20: {
                     21:        _doprnt(f, fmt, &x1);
                     22: }
                     23: 
                     24: char *
                     25: sprintf(buf, fmt, x1)
                     26:        char *buf, *fmt;
                     27:        unsigned x1;
                     28: {
                     29:        FILE fake;
                     30:        register FILE *f;
                     31:        f = &fake;
                     32:        f->cp = f->base = buf;
                     33:        f->flag = f->count = 0;
                     34:        _doprnt(f, fmt, &x1);
                     35:        putc('\0',f);
                     36:        return(f->cp);
                     37: }
                     38: 
                     39: char *
                     40: _doprnt(f, fmt, x1)
                     41:        register FILE *f;
                     42:        register char *fmt;
                     43:        unsigned *x1;
                     44: {
                     45:        register c;
                     46:        register unsigned int *adx;
                     47:        register long l;
                     48:        char *s;
                     49: 
                     50:        adx = x1;
                     51:        for(;;){
                     52:                while((c = *fmt++) != '%') {
                     53:                        if(c == '\0')
                     54:                                return(f->cp);
                     55:                        putc(c,f);
                     56:                }
                     57:                c = *fmt++;
                     58:                if(c=='o' || c=='u' || c=='x')
                     59:                        sprintn(*(unsigned long *)adx, c=='o'? 8: (c=='x'? 16:10), f);
                     60:                else if(c=='d'){        /* Signed, please */
                     61:                        l= *(int *)adx;
                     62:                        if(l<0){
                     63:                                putc('-',f);
                     64:                                l= -l;
                     65:                        }
                     66:                        sprintn(l, 10, f);
                     67:                }else if(c == 's') {
                     68:                        s = *(char **)adx;
                     69:                        while(c = *s++)
                     70:                                putc(c,f);
                     71:                        adx += (sizeof (char *)/sizeof(int)) -1;
                     72:                } else if (c == 'D') {
                     73:                        sprintn(*(unsigned long *)adx, 10, f);
                     74:                        adx += (sizeof(long) / sizeof(int)) - 1;
                     75:                } else if (c == 'c') {
                     76:                        putc(*adx,f);
                     77:                } else
                     78:                        putc(c, f);
                     79:                adx++;
                     80:        }
                     81: }
                     82: 
                     83: /*
                     84:  * Print an unsigned integer in base b.
                     85:  */
                     86: sprintn(n, b, f)
                     87:        unsigned long n;
                     88:        FILE *f;
                     89: {
                     90:        register unsigned long a;
                     91: 
                     92:        if(a = n/b)
                     93:                sprintn(a, b, f);
                     94:        putc("0123456789ABCDEF"[(int)(n%b)],f);
                     95: }

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