Return to printf.c CVS log

Up to [MW Coherent from dump] / coherent / d / conf / tboot

Annotation of coherent/d/conf/tboot/printf.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * printf.c
                      3:  */
                      4: 
                      5: /*
                      6:  * For indirecting and incrementing argument pointer.
                      7:  */
                      8: #define ind(p, t)      (*((t *) p))
                      9: #define inc(t1, t2)    ((sizeof(t2 *)+sizeof(t1)-1) / sizeof(t1))
                     10: 
                     11: /*
                     12:  * Table for printing out digits.
                     13:  */
                     14: char digtab[] ={
                     15:        '0',    '1',    '2',    '3',    '4',    '5',    '6',    '7',
                     16:        '8',    '9',    'A',    'B',    'C',    'D',    'E',    'F'
                     17: };
                     18: 
                     19: /*
                     20:  * A simple printf.
                     21:  */
                     22: printf(fp, a1)
                     23: register char *fp;
                     24: {
                     25:        char * cp;
                     26:        register int c;
                     27:        register unsigned *ap;
                     28:        int lflag;
                     29: 
                     30:        ap = (char *)&a1;
                     31:        for (;;) {
                     32:                while ((c=*fp++) != '%') {
                     33:                        if (c == '\0')
                     34:                                return;
                     35:                        putchar(c);
                     36:                }
                     37: 
                     38:                lflag = 0;
                     39:                if ( *fp == 'l' ) {
                     40:                        lflag = 1;
                     41:                        fp++;
                     42:                }
                     43: 
                     44:                switch ( c = *fp++ ) {
                     45: 
                     46:                case 'c':
                     47:                        putchar(*ap++);
                     48:                        continue;
                     49: 
                     50:                case 'd':
                     51:                        if ( lflag == 0 ) {
                     52:                                if ( ((int)(*ap)) < 0 ) {
                     53:                                        putchar('-');
                     54:                                        printn( -((long) ((int)(*ap))), 10 );
                     55:                                }
                     56:                                else
                     57:                                        printn( ((long)(*ap)), 10 );
                     58:                                ap++;
                     59:                                continue;
                     60:                        }
                     61:                        /* fall through */
                     62:                case 'D':
                     63:                        if ( *((long *)(ap)) < 0 ) {
                     64:                                putchar('-');
                     65:                                printn( - *((long *)(ap)), 10 );
                     66:                        }
                     67:                        else
                     68:                                printn(   *((long *)(ap)), 10 );
                     69: 
                     70:                        ((long *)(ap))++;
                     71:                        continue;
                     72: 
                     73:                case 'o':
                     74:                        if ( lflag == 0 ) {
                     75:                                printn( ((long)(*ap)), 8);
                     76:                                ap++;
                     77:                                continue;
                     78:                        }
                     79:                        /* fall through */
                     80:                case 'O':
                     81:                        printf( *((long *)(ap)), 8 );
                     82:                        ((long *)(ap))++;
                     83:                        continue;
                     84: 
                     85:                case 'r':
                     86:                        ap = *((int **) ap);
                     87:                        fp = ind(ap, char *);
                     88:                        ap += inc(int, char *);
                     89:                        continue;
                     90: 
                     91:                case 's':
                     92:                        cp = ind(ap, char *);
                     93:                        ap += inc(int, char *);
                     94:                        while ((c=*cp++) != '\0')
                     95:                                putchar(c);
                     96:                        continue;
                     97: 
                     98:                case 'x':
                     99:                        if ( lflag == 0 ) {
                    100:                                printn( ((long)(*ap)), 16 );
                    101:                                ap++;
                    102:                                continue;
                    103:                        }
                    104:                        /* fall through */
                    105:                case 'X':
                    106:                        printn( *((long *)(ap)), 16 );
                    107:                        ((long *)(ap))++;
                    108:                        continue;
                    109: 
                    110:                case 'u':
                    111:                        if ( lflag == 0 ) {
                    112:                                printn( ((long)(*ap)), 10);
                    113:                                ap++;
                    114:                                continue;
                    115:                        }
                    116:                        /* fall through */
                    117:                case 'U':
                    118:                        printn( *((long *)(ap)), 10 );
                    119:                        ((long *)(ap))++;
                    120:                        continue;
                    121: 
                    122:                case 'p':
                    123:                        if (sizeof(char *) > sizeof(int)) {
                    124:                                printn( ((long)(*ap)), 16);
                    125:                                putchar(':');
                    126:                                ap++;
                    127:                        }
                    128:                        printn( ((long)(*ap)), 16);
                    129:                        ap++;
                    130:                        continue;
                    131: 
                    132:                default:
                    133:                        putchar(c);
                    134:                        continue;
                    135:                }
                    136:        }
                    137: }
                    138: 
                    139: /*
                    140:  * Print out the unsigned long `v' in the base `b'.
                    141:  */
                    142: printn( v, b )
                    143: unsigned long v;
                    144: {
                    145:        unsigned long n;
                    146: 
                    147:        if (n=v/b)
                    148:                printn(n, b);
                    149: 
                    150:        putchar(digtab[v%b]);
                    151: }

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