xxdev

/* Darren Smith, 2009  (www.xxdev.com) */
 
#include <bitset>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <sstream>
 
/*
List of types extracted from system header file include/c++/limits :
 
    bool
    char
    double
    float
    int
    long
    long double
    long long
    short
    signed char
    unsigned char
    unsigned int
    unsigned long
    unsigned long long
    unsigned short
    wchar_t
*/
 
/*
 * Template function for getting the name of a type
 */
template <typename T> std::string name_of_type();
 
/* Specialisations */
#define SPECIALSE_name_of_type( X ) \
template <> std::string name_of_type< X >() { return #X; }
SPECIALSE_name_of_type( bool );
SPECIALSE_name_of_type( char );
SPECIALSE_name_of_type( double );
SPECIALSE_name_of_type( float );
SPECIALSE_name_of_type( int );
SPECIALSE_name_of_type( long );
SPECIALSE_name_of_type( long double );
SPECIALSE_name_of_type( long long );
SPECIALSE_name_of_type( short );
SPECIALSE_name_of_type( signed char );
SPECIALSE_name_of_type( unsigned char );
SPECIALSE_name_of_type( unsigned int );
SPECIALSE_name_of_type( unsigned long );
SPECIALSE_name_of_type( unsigned long long );
SPECIALSE_name_of_type( unsigned short );
SPECIALSE_name_of_type( wchar_t );
 
/*
 * Get hex representation of a value
 */
template<typename T>
void to_hex(T _v , std::ostream& s)
{
  union
  {
      T value;
      unsigned char bytes[sizeof(T)];
  };
  memset(&bytes, 0, sizeof(T));
  value = _v;
 
  s << std::setfill('0');
  s << std::hex;
  s << std::uppercase;
  s << std::right;
 
#if BYTE_ORDER == BIG_ENDIAN
  size_t i = 0;
  size_t const e = sizeof(T)-1;
#else
  size_t i = sizeof(T)-1;
  size_t const e = 0;
#endif
 
  for (;;)
  {
    s << std::setw(2) << (unsigned int) bytes[i];
    if (i == e) break;
    s << " ";
 
#if BYTE_ORDER == BIG_ENDIAN
    ++i;
#else
    --i;
#endif
  }
}
 
/*
 * Get binary representation of a value.  We use std::bitset to generate
 * the actual binary for each byte.
 */
template <typename T>
void to_bin(T _v, std::ostream& os)
{
  std::bitset< std::numeric_limits<unsigned char>::digits > bs;
  union
  {
      T value;
      unsigned char bytes[sizeof(T)];
  };
  memset(&bytes, 0, sizeof(T));
  value = _v;
 
#if BYTE_ORDER == BIG_ENDIAN
  size_t i = 0;
  size_t const e = sizeof(T)-1;
#else
  size_t i = sizeof(T)-1;
  size_t const e = 0;
#endif
  for (;;)
  {
    bs = bytes[i]; os << bs;
    if (i == e) break;
    os << " ";
 
#if BYTE_ORDER == BIG_ENDIAN
        ++i;
#else
        --i;
#endif
  }
}
 
/*
 * Utility methods for a primitive type.
 */
template <typename T>
class typeutil
{
  public:
 
    typedef T io_type;
 
    static std::string name() { return ::name_of_type<T>; }
 
    static T from_string(const char* s,
                         std::ios_base& (*base)(std::ios_base&))
    {
      T retval;
 
      std::istringstream iss(s);
 
      if ((iss >> base >> retval).fail())
      {
        std::ostringstream oss;
        oss << "failed to convert \"" << s << "\" to "
            << ::name_of_type<T>() << " at "
          __FILE__ << ":" << __LINE__;
        throw std::ios_base::failure(oss.str());
      }
 
      return retval;
    }
};
 
/*
 * Generic method to use when the conversion from a string to a type
 * needs to go via an intermediate ordinal type.
 */
template <typename S, typename I>
S convert_via_int(const char* s,
                     std::ios_base& (*base)(std::ios_base&))
{
  std::istringstream iss(s);
 
  I intermediate;
 
  if ((iss >> base >> intermediate).fail())
  {
    std::ostringstream oss;
    oss << "failed to convert \"" << s << "\" to "
        << ::name_of_type<S>() << " at "
      __FILE__ << ":" << __LINE__;
    throw std::ios_base::failure(oss.str());
  }
 
  return intermediate;
}
 
/* Specialisation for char types */
 
template <>
class typeutil<char>
{
  public:
    typedef int io_type;
    static std::string name() { return ::name_of_type<char>(); }
    static char from_string(const char* s,
                            std::ios_base& (*base)(std::ios_base&)) {
      return ::convert_via_int<char, io_type>(s, base);
    }
};
template <>
class typeutil<unsigned char>
{
  public:
    typedef unsigned int io_type;
    static std::string name() { return ::name_of_type<unsigned char>(); }
    static unsigned char from_string(const char* s,
                                     std::ios_base& (*base)(std::ios_base&)) {
      return ::convert_via_int<unsigned char, io_type>(s, base);
    }
};
template <>
class typeutil<signed char>
{
  public:
    typedef signed int io_type;
    static std::string name() { return ::name_of_type<signed char>(); }
    static signed char from_string(const char* s,
                                   std::ios_base& (*base)(std::ios_base&)) {
      return ::convert_via_int<signed char, io_type>(s, base);
    }
};
 
/* Formatted output of a floating point type value */
template <typename T>
void pr_float(T v, std::ostream& os, int p, int e, bool pad)
{
  os << std::dec;
  if (pad) os << std::setw(2+p+2+e);
  os << std::right
     << std::setfill(' ')
     << std::setprecision(p)
     << v;
}
 
/* Formatted output of a value.  This function is specialised (below)
 * for floating point types. */
template <typename T>
void pr_raw(T v, std::ostream& os, bool pad)
{
  typename typeutil<T>::io_type o = v;
 
  if (pad)
  {
    // add 1 for most-sig. position, and add 1 for minus sign
    os << std::setw( 1+std::numeric_limits<T>::digits10 +
                    std::numeric_limits<T>::is_signed);
  }
  os << std::dec << std::right << std::setfill(' ') << o;
}
template<> void pr_raw(float v, std::ostream& os, bool pad) { pr_float(v, os,
20, 5, pad); }
template<> void pr_raw(double v, std::ostream& os, bool pad){ pr_float(v, os,
20, 5, pad); }
template<> void pr_raw(long double v, std::ostream& os, bool pad){ pr_float(v,
os, 25, 6, pad); }
 
 
/* For a type T, and a set of values starting at argv[argoffset],
 * display a summary of the type and the hex and binary
 * representations of the set of values. */
template <typename T>
void dump(int argc, const char** argv, int argoffset, std::ostream& os)
{
  // summary line
  os << name_of_type<T>()
     << ", sizeof " << sizeof(T)
     << ", non-sign-bits " << std::numeric_limits<T>::digits
     << ", digits10 " << std::numeric_limits<T>::digits10
     << ", min "; pr_raw<T>(std::numeric_limits<T>::min(), os, false);
  os << ", max "; pr_raw<T>(std::numeric_limits<T>::max(), os, false);
  os << std::endl;
 
  // display the bin & hex representations of the values
  for (int i = argoffset; i < argc; ++i)
  {
    T f = typeutil<T>::from_string(argv[i], std::dec);
    pr_raw<T>(f, os, true);
    os << " | ";
    ::to_hex<T>(f, os);
    os << " | ";
    to_bin<T>(f, os);
    os << std::endl;
  }
}
 
 
#define LOAD_DUMP_FUNC( X ) dump_funs[ ::name_of_type< X >() ] = dump< X >;
 
int main(int argc, const char** argv)
{
  // Build a map of dump functions, one for each type
  typedef void (*dump_funptr)(int, const char**, int, std::ostream&);
  std::map<std::string, dump_funptr> dump_funs;
  LOAD_DUMP_FUNC( bool );
  LOAD_DUMP_FUNC( char );
  LOAD_DUMP_FUNC( double );
  LOAD_DUMP_FUNC( float );
  LOAD_DUMP_FUNC( int );
  LOAD_DUMP_FUNC( long );
  LOAD_DUMP_FUNC( long double );
  LOAD_DUMP_FUNC( long long );
  LOAD_DUMP_FUNC( short );
  LOAD_DUMP_FUNC( signed char );
  LOAD_DUMP_FUNC( unsigned char );
  LOAD_DUMP_FUNC( unsigned int );
  LOAD_DUMP_FUNC( unsigned long );
  LOAD_DUMP_FUNC( unsigned long long );
  LOAD_DUMP_FUNC( unsigned short );
//  LOAD_DUMP_FUNC( wchar_t );
 
  if (argc > 1)
  {
    dump_funptr fptr = NULL;
    int argoffset;
 
    if (not fptr and argc > 3)
    {
      // eg "unsigned long long" in separate argv[] cells
      std::ostringstream concat;
      concat <<  argv[1] << " " << argv[2] << " " << argv[3];
      fptr = dump_funs[ concat.str() ];
      argoffset = 4;
    }
 
    if (not fptr and argc > 2)
    {
      // eg "unsigned long" in separate argv[] cells
      std::ostringstream concat;
      concat <<  argv[1] << " " << argv[2];
      fptr = dump_funs[ concat.str() ];
      argoffset = 3;
    }
 
    if (not fptr and argc > 1)
    {
      // eg "long" in separate argv[] cells
      fptr = dump_funs[ argv[1] ];
      argoffset = 2;
    }
 
    if (fptr)
    {
      try
      {
        fptr(argc, argv, argoffset, std::cout);
      }
      catch (std::ios_base::failure& ex)
      {
        std::cerr << "caught exception: " << ex.what() << "\n";
        return 1;
      }
    }
    else
    {
      std::cerr << "not a supported type\n";
      return 1;
    }
  }
  else
  {
    // if no args, display all supported types
    for (std::map<std::string, dump_funptr>::iterator i = dump_funs.begin();
         i != dump_funs.end(); ++i)
    {
      std::cout << i->first << "\n";
    }
  }
 
  return 0;
}