home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / listings / v_09_03 / 9n03076c < prev    next >
Text File  |  1991-01-17  |  7KB  |  235 lines
  1.  
  2. /*
  3.  *      abbreviated printf routine
  4.  *
  5.  *      embedded system version
  6.  *      11/30/90
  7.  */
  8.  
  9.  
  10.  
  11. /* ltob -- convert an long integer to a string in any
  12.    base (2-36) */
  13. static char *ltob(n, s, base)
  14. long n;
  15. char *s;
  16. {
  17.         unsigned long u;
  18.         register char *p, *q;
  19.         register negative, c;
  20.  
  21.         if (n < 0 && base == -10)
  22.         {
  23.                 negative = 1;
  24.                 u = -n;
  25.         }
  26.         else
  27.         {
  28.                 negative = 0;
  29.                 u = n;
  30.         }
  31.         if (base == -10)                /* signals signed
  32.                                            conversion */
  33.                 base = 10;
  34.         p = q = s;
  35.         do
  36.         {                               /* generate digits in reverse
  37.                                            order */
  38.                 *p++ = "0123456789abcdef"[u % base];
  39.         } while ((u /= base) > 0);
  40.         if (negative)
  41.                 *p++ = '-';
  42.         *p = '\0';                      /* terminate the string */
  43.         while (q < --p)
  44.         {                               /* reverse the digits */
  45.                 c = *q;
  46.                 *q++ = *p;
  47.                 *p = c;
  48.         }
  49.         return s;
  50. }
  51.  
  52. #define NONE    0
  53. #define LEFT    1
  54. #define RIGHT   2
  55.  
  56. /* printf -- short version of printf to conserve
  57.    space */
  58. int printf(fmt, args)
  59. const char *fmt;
  60. char *args;
  61. {
  62.         register base;
  63.         register char **arg;
  64.         char s[11], *p, *ltob();
  65.         char c, slen, flag, size, fill;
  66.  
  67.         arg = &args;
  68.         flag = NONE;
  69.         size = 0;
  70.         while ((c = *fmt++) != '\0')
  71.         {
  72.                 if (size == 0 && flag == NONE && c != '%')
  73.                 {
  74.                         write(1, &c, 1);
  75.                         continue;
  76.                 }
  77.                 switch(*fmt)
  78.                 {
  79.                 case '-':
  80.                         flag = RIGHT;
  81.                         fill = *(fmt + 1) == '0' ? '0' : ' ';
  82.                         continue;
  83.  
  84.                 case '0':
  85.                 case '1':
  86.                 case '2':
  87.                 case '3':
  88.                 case '4':
  89.                 case '5':
  90.                 case '6':
  91.                 case '7':
  92.                 case '8':
  93.                 case '9':
  94.                         if(flag == NONE)
  95.                                 flag = LEFT;
  96.                         size = *fmt++ - '0';
  97.                         while((c = *fmt++) != '\0')
  98.                         {
  99.                                 switch(c)
  100.                                 {
  101.                                 case '0':
  102.                                 case '1':
  103.                                 case '2':
  104.                                 case '3':
  105.                                 case '4':
  106.                                 case '5':
  107.                                 case '6':
  108.                                 case '7':
  109.                                 case '8':
  110.                                 case '9':
  111.                                         size = size * 10 + (c - '0');
  112.                                         continue;
  113.  
  114.                                 default:
  115.                                         --fmt;
  116.                                         break;
  117.                                 }
  118.                                 break;
  119.                         }
  120.                         break;
  121.                 }
  122.                 switch (c = *fmt++)
  123.                 {
  124.                 case 'c':
  125.                         write(1, (char *)arg++, 1);
  126.                         continue;
  127.  
  128.                 case 'd':
  129.                         base = -10;
  130.                         goto prt;
  131.  
  132.                 case 'o':
  133.                         base = 8;
  134.                         goto prt;
  135.  
  136.                 case 'u':
  137.                         base = 10;
  138.                         goto prt;
  139.  
  140.                 case 'x':
  141.                         base = 16;
  142.  
  143.                 prt:
  144.                         ltob((long)(*((int *)arg)++), s, base);
  145.                         if(flag == RIGHT || flag == LEFT)
  146.                         {
  147.                                 for(slen = 0, p = s; *p != '\0'; p++)
  148.                                         ++slen;
  149.                         }
  150.                         if(flag == RIGHT && slen < size)
  151.                         {
  152.                                 int i;
  153.  
  154.                                 for(i = size - slen; i > 0; i--)
  155.                                         write(1, &fill, 1);
  156.                         }
  157.                         for(p = s; *p != '\0'; p++)
  158.                                 write(1, p, 1);
  159.                         if(flag == LEFT)
  160.                         {
  161.                                 int i;
  162.                                 char sp = ' ';
  163.  
  164.                                 for(i = size - slen; i > 0; i--)
  165.                                         write(1, &sp, 1);
  166.                         }
  167.                         size = 0;
  168.                         flag = NONE;
  169.                         continue;
  170.  
  171.                 case 'l':
  172.                         switch(c = *fmt++)
  173.                         {
  174.                         case 'd':
  175.                                 base = -10;
  176.                                 goto lprt;
  177.  
  178.                         case 'o':
  179.                                 base = 8;
  180.                                 goto lprt;
  181.  
  182.                         case 'u':
  183.                                 base = 10;
  184.                                 goto lprt;
  185.  
  186.                         case 'x':
  187.                                 base = 16;
  188.  
  189.                         lprt:
  190.                                 ltob(*((long *)arg)++, s, base);
  191.                                 if(flag == RIGHT || flag == LEFT)
  192.                                 {
  193.                                         for(slen = 0, p = s; *p != '\0'; p++)
  194.                                                 ++slen;
  195.                                 }
  196.                                 if(flag == RIGHT && slen < size)
  197.                                 {
  198.                                         int i;
  199.  
  200.                                         for(i = size - slen; i > 0; i--)
  201.                                                 write(1, &fill, 1);
  202.                                 }
  203.                                 for(p = s; *p != '\0'; p++)
  204.                                         write(1, p, 1);
  205.                                 if(flag == LEFT)
  206.                                 {
  207.                                         int i;
  208.                                         char sp = ' ';
  209.  
  210.                                         for(i = size - slen; i > 0; i--)
  211.                                                 write(1, &sp, 1);
  212.                                 }
  213.                                 size = 0;
  214.                                 flag = NONE;
  215.                                 continue;
  216.  
  217.                         default:
  218.                                 write(1, &c, 1);
  219.                         }
  220.  
  221.                 case 's':
  222.                         for(p = *arg; *p != '\0'; p++)
  223.                                 write(1, p, 1);
  224.                         ++arg;
  225.                         continue;
  226.  
  227.                 default:
  228.                         write(1, &c, 1);
  229.                         continue;
  230.                 }
  231.         }
  232. }
  233.  
  234.  
  235.