
/*
 *      abbreviated printf routine
 *
 *      embedded system version
 *      11/30/90
 */



/* ltob -- convert an long integer to a string in any
   base (2-36) */
static char *ltob(n, s, base)
long n;
char *s;
{
        unsigned long u;
        register char *p, *q;
        register negative, c;

        if (n < 0 && base == -10)
        {
                negative = 1;
                u = -n;
        }
        else
        {
                negative = 0;
                u = n;
        }
        if (base == -10)                /* signals signed
                                           conversion */
                base = 10;
        p = q = s;
        do
        {                               /* generate digits in reverse
                                           order */
                *p++ = "0123456789abcdef"[u % base];
        } while ((u /= base) > 0);
        if (negative)
                *p++ = '-';
        *p = '\0';                      /* terminate the string */
        while (q < --p)
        {                               /* reverse the digits */
                c = *q;
                *q++ = *p;
                *p = c;
        }
        return s;
}

#define NONE    0
#define LEFT    1
#define RIGHT   2

/* printf -- short version of printf to conserve
   space */
int printf(fmt, args)
const char *fmt;
char *args;
{
        register base;
        register char **arg;
        char s[11], *p, *ltob();
        char c, slen, flag, size, fill;

        arg = &args;
        flag = NONE;
        size = 0;
        while ((c = *fmt++) != '\0')
        {
                if (size == 0 && flag == NONE && c != '%')
                {
                        write(1, &c, 1);
                        continue;
                }
                switch(*fmt)
                {
                case '-':
                        flag = RIGHT;
                        fill = *(fmt + 1) == '0' ? '0' : ' ';
                        continue;

                case '0':
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                        if(flag == NONE)
                                flag = LEFT;
                        size = *fmt++ - '0';
                        while((c = *fmt++) != '\0')
                        {
                                switch(c)
                                {
                                case '0':
                                case '1':
                                case '2':
                                case '3':
                                case '4':
                                case '5':
                                case '6':
                                case '7':
                                case '8':
                                case '9':
                                        size = size * 10 + (c - '0');
                                        continue;

                                default:
                                        --fmt;
                                        break;
                                }
                                break;
                        }
                        break;
                }
                switch (c = *fmt++)
                {
                case 'c':
                        write(1, (char *)arg++, 1);
                        continue;

                case 'd':
                        base = -10;
                        goto prt;

                case 'o':
                        base = 8;
                        goto prt;

                case 'u':
                        base = 10;
                        goto prt;

                case 'x':
                        base = 16;

                prt:
                        ltob((long)(*((int *)arg)++), s, base);
                        if(flag == RIGHT || flag == LEFT)
                        {
                                for(slen = 0, p = s; *p != '\0'; p++)
                                        ++slen;
                        }
                        if(flag == RIGHT && slen < size)
                        {
                                int i;

                                for(i = size - slen; i > 0; i--)
                                        write(1, &fill, 1);
                        }
                        for(p = s; *p != '\0'; p++)
                                write(1, p, 1);
                        if(flag == LEFT)
                        {
                                int i;
                                char sp = ' ';

                                for(i = size - slen; i > 0; i--)
                                        write(1, &sp, 1);
                        }
                        size = 0;
                        flag = NONE;
                        continue;

                case 'l':
                        switch(c = *fmt++)
                        {
                        case 'd':
                                base = -10;
                                goto lprt;

                        case 'o':
                                base = 8;
                                goto lprt;

                        case 'u':
                                base = 10;
                                goto lprt;

                        case 'x':
                                base = 16;

                        lprt:
                                ltob(*((long *)arg)++, s, base);
                                if(flag == RIGHT || flag == LEFT)
                                {
                                        for(slen = 0, p = s; *p != '\0'; p++)
                                                ++slen;
                                }
                                if(flag == RIGHT && slen < size)
                                {
                                        int i;

                                        for(i = size - slen; i > 0; i--)
                                                write(1, &fill, 1);
                                }
                                for(p = s; *p != '\0'; p++)
                                        write(1, p, 1);
                                if(flag == LEFT)
                                {
                                        int i;
                                        char sp = ' ';

                                        for(i = size - slen; i > 0; i--)
                                                write(1, &sp, 1);
                                }
                                size = 0;
                                flag = NONE;
                                continue;

                        default:
                                write(1, &c, 1);
                        }

                case 's':
                        for(p = *arg; *p != '\0'; p++)
                                write(1, p, 1);
                        ++arg;
                        continue;

                default:
                        write(1, &c, 1);
                        continue;
                }
        }
}


