arguments.cpp

Go to the documentation of this file.

/**************************************************************************

   begin                : Sat Sep 09 2007
   copyright            : (C) 2007 by Ewald Arnold
   email                : log4sendpp at ewald-arnold dot de

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser 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 Lesser General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

 **/


#define LOG4SENDPP_NEED_EXPORTS
#include <log4sendpp/log4sendpp.h>  // always first header

#include <cstdio>
#include <cctype>
#include <limits>

#include <log4sendpp/arguments.h>
#include <log4sendpp/exception.h>


LOG4SENDPP_NS_START

LOG4SENDPP_ANON_NS_START

template <typename T, typename uT>
LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string) number_stpl( T n, unsigned base )
{
  if ( base < 2 || base > 36 )
  {
    LOG4SENDPP_STD_NS::string fmt = "Conversion of T to String: base %1 not allowed";
    fmt << number( ( uT ) base, 10 );
    LOG4SENDPP_THROW(LOG4SENDPP_NS::Exception( __LINE__, __FILE__, fmt ));
#ifdef LOG4SENDPP_NO_EXCEPTIONS
    return "";
#endif
  }

  char charbuf[ sizeof(T) * 65 * sizeof( char ) ];
  char *buf = ( char* ) charbuf;
  char *p = &buf[ sizeof(T) * 64 ];
  *p = '\0' ;
  int len = 0;
  bool neg;
  if ( n < 0 )
  {
    neg = true;
#ifdef HAVE_LIMITS
    if ( n == LOG4SENDPP_STD_NS::numeric_limits<T>::min() )
#else
    if ( n == INT_MIN )
#endif
    {
      LOG4SENDPP_STD_NS::string s1, s2;
      s1 = number( n / ( T ) base, base );
#if defined(_MSC_VER) && (_MSC_VER <= 1200)
      s2 = number( ( unsigned T ) ( -( n + ( T ) base ) ) % base, base );
#else
      s2 = number( ( -( n + ( T ) base ) ) % base, base );
#endif
      return s1 + s2;
    }
    n = -n;
  }
  else
  {
    neg = false;
  }

  do
  {
    *--p = "0123456789abcdefghijklmnopqrstuvwxyz"[ ( ( int ) ( n % base ) ) ];
    n /= base;
    len++;
  }
  while ( n );

  if ( neg )
  {
    *--p =  '-';
    len++;
  }
  return p;
}

LOG4SENDPP_NS_END


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string) number( long n, unsigned base )
{
  return number_stpl<long, unsigned long>(n, base);
}


#ifndef UPS_NO_LONG_LONG

LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string) number( long long n, unsigned base )
{
  return number_stpl<long long, unsigned long long>(n, base);
}

#endif

LOG4SENDPP_ANON_NS_START

template <typename T>
LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string) number_utpl(T n, unsigned base )
{
  if ( base < 2 || base > 36 )
  {
    LOG4SENDPP_STD_NS::string fmt = "Conversion of unsigned T to String: base %1 not allowed";
    fmt << number( ( T ) base, 10 );
    LOG4SENDPP_THROW(LOG4SENDPP_NS::Exception( __LINE__, __FILE__, fmt ));
#ifdef LOG4SENDPP_NO_EXCEPTIONS
    return "";
#endif
  }

  char charbuf[ sizeof(T) * 65 * sizeof( char ) ];
  char *buf = ( char* ) charbuf;
  char *p = &buf[ sizeof(T) * 64 ];
  int len = 0;
  *p =  '\0';
  do
  {
    *--p = "0123456789abcdefghijklmnopqrstuvwxyz" [ ( ( int ) ( n % base ) ) ];
    n /= base;
    len++;
  }
  while ( n );

  return p;
}

LOG4SENDPP_NS_END


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string) number( unsigned long n, unsigned base )
{
  return number_utpl<unsigned long>(n, base);
}


#ifndef UPS_NO_LONG_LONG

LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string) number( unsigned long long n, unsigned base )
{
  return number_utpl<unsigned long long>(n, base);
}

#endif

LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string) number( double n, unsigned prec )
{
  if ( prec > 99 )
    prec = 99;

  char format[ 20 ];
  char buf[ 120 ];
  char *fs = format;

  *fs++ = '%';
  if ( prec != 0 )
  {
    *fs++ = '.';
    if ( prec >= 10 )
    {
      *fs++ = prec / 10 + '0';
      *fs++ = prec % 10 + '0';
    }
    else
      *fs++ = prec + '0';      //   "%.<prec>lg"
    *fs++ = 'l';
  }
  *fs++ = 'g';
  *fs = '\0';
#if defined HAVE_SPRINTF_S
  sprintf_s( buf, format, n );
#else
  LOG4SENDPP_STD_NS::sprintf( buf, format, n );
#endif

#ifdef LOG4SENDPP_UNICODE
  return LOG4SENDPP_NS::getUnicode( buf );
#else
  return LOG4SENDPP_STD_NS::string( buf );
#endif
}


static bool findArg( LOG4SENDPP_STD_NS::string &fmt, int& pos, int& len )
{
  char lowest = 0;
  for ( unsigned int i = 0; i < fmt.length(); i++ )
  {
    if ( fmt[ i ] ==  '%' && i + 1 < fmt.length() )
    {
      char dig = fmt[ i + 1 ];
      if ( dig >=  '0' && dig <=  '9' )
      {
        if ( !lowest || dig < lowest )
        {
          lowest = dig;
          pos = i;
          len = 2;
        }
      }
    }
  }
  return lowest != 0;
}


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) replaceFormatterString(LOG4SENDPP_STD_NS::string &formatter, const LOG4SENDPP_STD_NS::string &repdata)
{
  int pos, len;

  if ( !findArg(formatter, pos, len ) )
  {
    LOG4SENDPP_THROW(LOG4SENDPP_NS::Exception(__LINE__, __FILE__, "No %-placeholder found to insert \'"
                                                             + repdata
                                                             + "\' into \'"
                                                             + formatter
                                                             + "\'"));
#ifdef LOG4SENDPP_NO_EXCEPTIONS
    return formatter;
#endif
  }

  else
    formatter.replace( pos, len, repdata);

  return formatter;
}


static LOG4SENDPP_STD_NS::string charToReadable(unsigned x)
{
  LOG4SENDPP_STD_NS::string text;
#ifndef LOG4SENDPP_MAKE_CHAR_READABLE
  text += x;
#else
#if (defined (_MSC_VER) && (_MSC_VER <= 1300)) || (defined (__GNUC__) && (__GNUC__ < 3))
  if (!isalnum(x))
#else
  if (!LOG4SENDPP_STD_NS::isalnum(x))
#endif
  {
    text += "0x" + number((unsigned long)x, 16);
  }
  else
  {
    text += "{\"";
    text += x;
    text += "\", ";
    text += "0x" + number((unsigned long)x, 16);
    text += "}";
  }
#endif
  return text;
}


LOG4SENDPP_NS_END


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) operator << ( LOG4SENDPP_STD_NS::string &formatter, const int &repdata )
{
  formatter << LOG4SENDPP_NS::number( ( long ) repdata );
  return formatter;
}


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) operator << ( LOG4SENDPP_STD_NS::string &formatter, const bool &repdata )
{
  formatter << (repdata ? "true"
                        : "false" );
  return formatter;
}


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) operator << ( LOG4SENDPP_STD_NS::string &formatter, const unsigned int &repdata )
{
  formatter << LOG4SENDPP_NS::number( ( unsigned long ) repdata );
  return formatter;
}


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) operator << ( LOG4SENDPP_STD_NS::string &formatter, const unsigned long &repdata )
{
  formatter << LOG4SENDPP_NS::number( repdata );
  return formatter;
}


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) operator << ( LOG4SENDPP_STD_NS::string &formatter, const signed char &repdata )
{
  formatter << LOG4SENDPP_NS::charToReadable(repdata);
  return formatter;
}


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) operator << ( LOG4SENDPP_STD_NS::string &formatter, const char &repdata )
{
  formatter << LOG4SENDPP_NS::charToReadable(repdata);
  return formatter;
}


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) operator << ( LOG4SENDPP_STD_NS::string &formatter, const unsigned char &repdata )
{
  formatter << LOG4SENDPP_NS::charToReadable(repdata);
  return formatter;
}


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) operator << ( LOG4SENDPP_STD_NS::string &formatter, const char *repdata )
{
  formatter << LOG4SENDPP_STD_NS::string(repdata);
  return formatter;
}


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) operator << ( LOG4SENDPP_STD_NS::string &formatter, const float &repdata )
{
  formatter << LOG4SENDPP_NS::number( repdata );
  return formatter;
}


#ifdef LOG4SENDPP_UNICODE

LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) operator << ( LOG4SENDPP_STD_NS::string &formatter, const wchar_t &repdata )
{
  formatter << LOG4SENDPP_NS::charToReadable(repdata);
  return formatter;
}


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) operator << ( LOG4SENDPP_STD_NS::string &formatter, const wchar_t * repdata )
{
  formatter << LOG4SENDPP_STD_NS::string(repdata);
  return formatter;
}

#endif


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) operator << ( LOG4SENDPP_STD_NS::string &formatter, const long &repdata )
{
  formatter << LOG4SENDPP_NS::number( repdata );
  return formatter;
}


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) operator << ( LOG4SENDPP_STD_NS::string &formatter, const double &repdata )
{
  formatter << LOG4SENDPP_NS::number( repdata );
  return formatter;
}


#ifdef LOG4SENDPP_UNICODE

LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) operator << ( LOG4SENDPP_STD_NS::string &formatter, const LOG4SENDPP_STD_NS::string &str )
{
  formatter << LOG4SENDPP_NS::getUnicode( str );
  return formatter;
}

#else

// LOG4SENDPP_STD_NS::string & operator << (LOG4SENDPP_STD_NS::string &formatter, const LOG4SENDPP_STL::basic_string<wchar_t> &str)
// {
//   formatter << LOG4SENDPP_NS::getLatin1(str);
//   return formatter;
// }

#endif


LOG4SENDPP_API_IMPL(LOG4SENDPP_STD_NS::string &) operator << (LOG4SENDPP_STD_NS::string &formatter, const LOG4SENDPP_STD_NS::string &repdata)
{
  return LOG4SENDPP_NS::replaceFormatterString(formatter, repdata);
}

---