Listing 7

/*
*      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;
                     }
              }
       }