Subversion Repositories libSmallPrintf

Rev

Rev 3 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.         Copyright 2001, 2002 Georges Menie (www.menie.org)
  3.         stdarg version contributed by Christian Ettinger
  4.  
  5.         This program is free software; you can redistribute it and/or modify
  6.         it under the terms of the GNU Lesser General Public License as published by
  7.         the Free Software Foundation; either version 2 of the License, or
  8.         (at your option) any later version.
  9.  
  10.         This program is distributed in the hope that it will be useful,
  11.         but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.         GNU Lesser General Public License for more details.
  14.  
  15.         You should have received a copy of the GNU Lesser General Public License
  16.         along with this program; if not, write to the Free Software
  17.         Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18. */
  19.  
  20. /* Includes */
  21.  
  22. #include "libSmallPrintf/small_printf.h"
  23.  
  24. #include <stdarg.h>
  25. #include <stdio.h>
  26. #include <string.h>
  27.  
  28. /*
  29.         putchar is the only external dependency for this file,
  30.         if you have a working putchar, leave it commented out.
  31.         If not, uncomment the define below and
  32.         replace outbyte(c) by your own function call.
  33. */
  34.  
  35. static void printchar(char **str, int c)
  36. {
  37.  
  38.         if (str)
  39.         {
  40.                 **str = c;
  41.                 ++(*str);
  42.         }
  43. #if defined SERIAL_UART1 || defined SERIAL_UART2 || defined SERIAL_UART3 || defined SERIAL_UART4
  44.         else
  45.                 (void)PutCharSerial(c);
  46. #endif
  47. }
  48.  
  49. #define PAD_RIGHT 1
  50. #define PAD_ZERO 2
  51.  
  52. static int prints(char **out, const char *string, int width, int pad)
  53. {
  54.         register int pc = 0, padchar = ' ';
  55.  
  56.         if (width > 0)
  57.         {
  58.                 register int len = 0;
  59.                 register const char *ptr;
  60.                 for (ptr = string; *ptr; ++ptr)
  61.                         ++len;
  62.                 if (len >= width)
  63.                         width = 0;
  64.                 else
  65.                         width -= len;
  66.                 if (pad & PAD_ZERO)
  67.                         padchar = '0';
  68.         }
  69.         if (!(pad & PAD_RIGHT))
  70.         {
  71.                 for (; width > 0; --width)
  72.                 {
  73.                         printchar(out, padchar);
  74.                         ++pc;
  75.                 }
  76.         }
  77.         for (; *string; ++string)
  78.         {
  79.                 printchar(out, *string);
  80.                 ++pc;
  81.         }
  82.         for (; width > 0; --width)
  83.         {
  84.                 printchar(out, padchar);
  85.                 ++pc;
  86.         }
  87.  
  88.         return pc;
  89. }
  90.  
  91. /* the following should be enough for 32 bit int */
  92. #define PRINT_BUF_LEN 12
  93.  
  94. static int printi(char **out, int i, int b, int sg, int width, int pad, int letbase)
  95. {
  96.         char print_buf[PRINT_BUF_LEN];
  97.         register char *s;
  98.         register int t, neg = 0, pc = 0;
  99.         register unsigned int u = i;
  100.  
  101.         if (i == 0)
  102.         {
  103.                 print_buf[0] = '0';
  104.                 print_buf[1] = '\0';
  105.                 return prints(out, print_buf, width, pad);
  106.         }
  107.  
  108.         if (sg && b == 10 && i < 0)
  109.         {
  110.                 neg = 1;
  111.                 u = -i;
  112.         }
  113.  
  114.         s = print_buf + PRINT_BUF_LEN - 1;
  115.         *s = '\0';
  116.  
  117.         while (u)
  118.         {
  119.                 t = u % b;
  120.                 if (t >= 10)
  121.                         t += letbase - '0' - 10;
  122.                 *--s = t + '0';
  123.                 u /= b;
  124.         }
  125.  
  126.         if (neg)
  127.         {
  128.                 if (width && (pad & PAD_ZERO))
  129.                 {
  130.                         printchar(out, '-');
  131.                         ++pc;
  132.                         --width;
  133.                 }
  134.                 else
  135.                 {
  136.                         *--s = '-';
  137.                 }
  138.         }
  139.  
  140.         return pc + prints(out, s, width, pad);
  141. }
  142.  
  143. static int small_print(char **out, const char *format, va_list args)
  144. {
  145.         register int width, pad;
  146.         register int pc = 0;
  147.         char scr[2];
  148.  
  149.         for (; *format != 0; ++format)
  150.         {
  151.                 if (*format == '%')
  152.                 {
  153.                         ++format;
  154.                         width = pad = 0;
  155.                         if (*format == '\0')
  156.                                 break;
  157.                         if (*format == '%')
  158.                                 goto out;
  159.                         if (*format == '-')
  160.                         {
  161.                                 ++format;
  162.                                 pad = PAD_RIGHT;
  163.                         }
  164.                         while (*format == '0')
  165.                         {
  166.                                 ++format;
  167.                                 pad |= PAD_ZERO;
  168.                         }
  169.                         if ('*' == *format)
  170.                         {
  171.                                 width = va_arg(args, int); // get width from next argument
  172.                                 format++;
  173.                         }
  174.                         else
  175.                         {
  176.                                 for (; *format >= '0' && *format <= '9'; ++format)
  177.                                 {
  178.                                         width *= 10;
  179.                                         width += *format - '0';
  180.                                 }
  181.                         }
  182.                         if (*format == 'l')
  183.                         { /* skip l in ld etc */
  184.                                 format++;
  185.                         }
  186.                         if (*format == 's')
  187.                         {
  188.                                 register char *s = (char *)va_arg(args, int);
  189.                                 pc += prints(out, s ? s : "(null)", width, pad);
  190.                                 continue;
  191.                         }
  192.                         if (*format == 'd')
  193.                         {
  194.                                 pc += printi(out, va_arg(args, int), 10, 1, width, pad, 'a');
  195.                                 continue;
  196.                         }
  197.                         if (*format == 'x')
  198.                         {
  199.                                 pc += printi(out, va_arg(args, int), 16, 0, width, pad, 'a');
  200.                                 continue;
  201.                         }
  202.                         if (*format == 'X')
  203.                         {
  204.                                 pc += printi(out, va_arg(args, int), 16, 0, width, pad, 'A');
  205.                                 continue;
  206.                         }
  207.                         if (*format == 'u')
  208.                         {
  209.                                 pc += printi(out, va_arg(args, int), 10, 0, width, pad, 'a');
  210.                                 continue;
  211.                         }
  212.                         if (*format == 'c')
  213.                         {
  214.                                 /* char are converted to int then pushed on the stack */
  215.                                 scr[0] = (char)va_arg(args, int);
  216.                                 scr[1] = '\0';
  217.                                 pc += prints(out, scr, width, pad);
  218.                                 continue;
  219.                         }
  220.                         if (*format == 'n')
  221.                         { /* convert number printed so far and store in *va_arg( args, int)... */
  222.                                 int *dp = va_arg(args, int);
  223.                                 *dp = pc;
  224.                                 continue;
  225.                         }
  226.                 }
  227.                 else
  228.                 {
  229.                 out:
  230.                         /* deal with LF -> CRLF mapping */
  231.                         if (*format == '\n')
  232.                         {
  233.                                 printchar(out, '\r');
  234.                                 ++pc; // extra char
  235.                         }
  236.                         printchar(out, *format);
  237.                         ++pc;
  238.                 }
  239.         }
  240.         if (out)
  241.                 **out = '\0';
  242.         return pc;
  243. }
  244.  
  245. int small_printf(const char *format, ...)
  246. {
  247.         int result = 0;
  248.         va_list args;
  249.  
  250.         va_start(args, format);
  251.         result = small_print(0, format, args);
  252.         va_end(args);
  253.         return result;
  254. }
  255.  
  256. int small_sprintf(char *out, const char *format, ...)
  257. {
  258.         int result = 0;
  259.         va_list args;
  260.         va_start(args, format);
  261.         result = small_print(&out, format, args);
  262.         va_end(args);
  263.         return result;
  264. }
  265.