Logo Search packages:      
Sourcecode: yencode version File versions

string.c

/**************************************************************************************************
      $Header: /pub/cvsroot/yencode/lib/string.c,v 1.10 2002/03/12 02:01:43 bboy Exp $

      Copyright (C) 2002  Don Moore <bboy@bboy.net>

      This program is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published by
      the Free Software Foundation; either version 2 of the License, or
      (at Your option) any later version.

      This program is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      GNU General Public License for more details.

      You should have received a copy of the GNU General Public License
      along with this program; if not, write to the Free Software
      Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
**************************************************************************************************/

#include "misc.h"


/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      BYTESTR
      Given a number, returns a textual, abbreviated string describing the number of bytes it
      represents.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
char *
bytestr(u_int64_t number)
{
      char numbuf[80];

      if (number > 99999)
      {
            number = (number + 500) / 1000;
            if (number > 9999)
            {
                  number = (number + 500) / 1000;
                  if (number > 9999)
                  {
                        number = (number + 500) / 1000;
                        if (number > 9999)
                        {
                              number = (number + 500) / 1000;
                                      snprintf(numbuf, sizeof(numbuf), "%lluT", number);
                        }     else snprintf(numbuf, sizeof(numbuf), "%lluG", number);
                  } else snprintf(numbuf, sizeof(numbuf), "%lluM", number);
            } else snprintf(numbuf, sizeof(numbuf), "%lluk", number);
      } else snprintf(numbuf, sizeof(numbuf), "%llu", number);
      return (xstrdup(numbuf));
}
/*--- bytestr() ---------------------------------------------------------------------------------*/


/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      Given a string such as "10MB" returns the size represented, in bytes.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
size_t
human_file_size(const char *str)
{
      size_t numeric = 0;                                                                 /* Numeric part of `str' */
      register char *c;                                                                   /* Ptr to first nonalpha char */

      numeric = (size_t)strtoul(str, (char **)NULL, 10);

      for (c = (char *)str; *c && isdigit(*c); c++)
            /* DONOTHING */;

      if (!*c)
            return (numeric);

      /* I am using values like 1000 instead of 1024, since that's what most people expect */
      switch (tolower(*c))
      {
            case 'k': return (numeric * 1000);
            case 'm': return (numeric * 1000000);
            case 'g': return (numeric * 1000000000);
            default:    /* Silently ignore unknown quantifiers */
                  break;
      }
      return (numeric);
}
/*--- human_file_size() -------------------------------------------------------------------------*/


/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      Removes leading and trailing whitespace from a string.  Converts tabs and newlines to spaces.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
char *
strtrim(char *str)
{
      if (!str)
            return (str);

      while (isspace(str[0]) || iscntrl(str[0]))
            memmove(str, str+1, strlen(str));

      while (isspace(str[strlen(str)-1]) || iscntrl(str[strlen(str)-1]))
            str[strlen(str)-1] = '\0';

      return (str);
}
/*--- strtrim() ---------------------------------------------------------------------------------*/


/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      CONFTRIM
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
char *
conftrim(char *str)
{
      register char *ibuf, *obuf;

      if (!str)
            return (NULL);

      /* Strip comments */
      for (ibuf = obuf = str; *ibuf; )
      {
            if (*ibuf == '#')
            {
                  if (obuf > str && obuf[-1] == '\\')
                        obuf[-1] = '#';
                  else
                        *(obuf++) = '\0';
                  ibuf++;
            }
            else
                  *(obuf++) = *(ibuf++);
      }

      for (ibuf = obuf = str; *ibuf; )
      {
            while (*ibuf && (isspace(*ibuf) || iscntrl(*ibuf)))
                  ibuf++;

            if (*ibuf && (obuf != str))
                  *(obuf++) = ' ';

            while (*ibuf && (!isspace(*ibuf) && !iscntrl(*ibuf)))
                  *(obuf++) = *(ibuf++);
      }
      *obuf = '\0';

      return (str);
}
/*--- conftrim() --------------------------------------------------------------------------------*/


/**************************************************************************************************
      COMMAFMT
      Copies the numeric value of N into buffer 'buf' of size 'bufsiz', inserting commas where
      appropriate.
**************************************************************************************************/
static size_t
commafmt(char *buf, size_t bufsiz, unsigned long N)
{
      int len = 1, posn = 1, sign = 1;
      char *ptr = buf + bufsiz - 1;

      if (2 > bufsiz)
      {
ABORT:*buf = '\0';
            return 0;
      }

      *ptr-- = '\0';
      --bufsiz;

      if (0L > N)
      {
            sign = -1;
            N = -N;
      }

      for ( ; len <= bufsiz; ++len, ++posn)
      {
            *ptr-- = (char)((N % 10L) + '0');
            if (0L == (N /= 10L))
                  break;
            if (0 == (posn % 3))
            {
                  *ptr-- = ',';
                  ++len;
            }
            if (len >= bufsiz)
                  goto ABORT;
      }
      if (0 > sign)
      {
            if (0 == bufsiz)
                  goto ABORT;
            *ptr-- = '-';
            ++len;
      }
      strcpy(buf, ++ptr);

      return (size_t)len;
}
/*--- commafmt() --------------------------------------------------------------------------------*/


/**************************************************************************************************
      COMMA1-3
      Making printf life easy for Don at the expense of repetition and a few hundred bytes of RAM.
**************************************************************************************************/
char *comma(u_int64_t num)  { static char cbuf[81];  commafmt(cbuf, 80, num); return (cbuf); }
char *comma1(u_int64_t num) { static char cbuf[81];  commafmt(cbuf, 80, num); return (cbuf); }
char *comma2(u_int64_t num) { static char cbuf[81];  commafmt(cbuf, 80, num); return (cbuf); }
char *comma3(u_int64_t num) { static char cbuf[81];  commafmt(cbuf, 80, num); return (cbuf); }
/*--- comma1-3() --------------------------------------------------------------------------------*/


/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      NUMERIC_WIDTH
      Given a number, returns the maximum numeric width.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
int
numeric_width(unsigned long num)
{
      char  numbuf[80];

      snprintf(numbuf, sizeof(numbuf), "%lu", num);
      return (strlen(numbuf));
}
/*--- numeric_width() ---------------------------------------------------------------------------*/


/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      SDPRINTF
      A dynamic sprintf; grows the buffer as it adds lines.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
void
sdprintf(unsigned char **dest, const char *fmt, ...)
{
      char                    msg[BUFSIZ];
      va_list                 ap;
      unsigned char     *d = *dest;
      register int      msglen, destlen;

      va_start(ap, fmt);
      msglen = vsnprintf(msg, sizeof(msg), fmt, ap);
      va_end(ap);

      destlen = (d) ? strlen(d) : 0;

   d = xrealloc(d, destlen + msglen + 1);

   memcpy(d + destlen, msg, msglen);
   d[destlen + msglen] = '\0';

   *dest = d;
}
/*--- sdprintf() --------------------------------------------------------------------------------*/


/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      ESCDUMP
      For debugging, dumps a buffer with characters escaped.
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
void
escdump(const unsigned char *buf, size_t len)
{
      register size_t ct;

      for (ct = 0; ct < len; ct++)
      {
            switch (buf[ct])
            {
                  case '\r':
                        printf("\033[1m\\r\033[0m");
                        break;
                  case '\n':
                        printf("\033[1m\\n\033[0m\n");
                        break;
                  case '\t':
                        printf("\033[1m\\t\033[0m");
                        break;
                  default:
                        if (isprint(buf[ct]))
                              putc(buf[ct], stdout);
                        else
                              printf("\033[1m\\%03o[0m", buf[ct]);
                        break;
            }
      }
      fflush(stdout);
}
/*--- escdump() ---------------------------------------------------------------------------------*/

/* vi:set ts=3: */

Generated by  Doxygen 1.6.0   Back to index