include/wipal/tool/hexdump.hxx

/*
 * WiPal - A library and a set of tools to manipulate wireless traces.
 * Copyright (C) 2007, 2009  Universite Pierre et Marie Curie - Paris 6
 *
 * 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., 51 Franklin Street, Fifth Floor, Boston,
 * MA  02110-1301  USA
 *
 * Author: Thomas Claveirole <thomas.claveirole@lip6.fr>
 */

#ifndef WIPAL_TOOL_HEXDUMP_HXX_
# define WIPAL_TOOL_HEXDUMP_HXX_

#include <string>
#include <sstream>
#include <iomanip>
#include <locale>
#include <stdexcept>
#include <cassert>

#include <wipal/tool/hexdump.hh>

namespace wpl
{

  namespace tool
  {

    namespace fmt
    {

      /*---------.
      | fmt::raw |
      `---------*/

      inline
      std::ostream&
      raw::begin(std::ostream& os) const
      {
        return os;
      }

      inline
      std::ostream&
      raw::end(std::ostream& os) const
      {
        return os;
      }

      inline
      std::ostream&
      raw::bold_begin(std::ostream& os) const
      {
        return os;
      }

      inline
      std::ostream&
      raw::bold_end(std::ostream& os) const
      {
        return os;
      }

      inline
      std::ostream&
      raw::encode(std::ostream& os, char c) const
      {
        return os << c;
      }

      /*---------------.
      | fmt::printable |
      `---------------*/

      inline
      std::ostream&
      printable::encode(std::ostream& os, char c) const
      {
        return os << (std::isprint(c)? c: '.');
      }

      /*----------.
      | fmt::html |
      `----------*/

      inline
      std::ostream&
      html::begin(std::ostream& os) const
      {
        return os << "<pre>";
      }

      inline
      std::ostream&
      html::end(std::ostream& os) const
      {
        return os << "</pre>";
      }

      inline
      std::ostream&
      html::bold_begin(std::ostream& os) const
      {
        return os << "<b>";
      }

      inline
      std::ostream&
      html::bold_end(std::ostream& os) const
      {
        return os << "</b>";
      }

      inline
      std::ostream&
      html::encode(std::ostream& os, char c) const
      {
        if (std::isprint(c))
          switch (c)
            {
            case '<':
              return os << "&lt;";
            case '>':
              return os << "&gt;";
            default:
              return os << c;
            }
        else
          return os << '.';
      }

    } // End of namespace fmt.

    namespace hex
    {

      template <class Params, class Format>
      std::string
      dump(const void* data, size_t len, const Format& f)
      {
        const unsigned char* const      b = static_cast<const unsigned char*>
          (data);
        const unsigned char* const      e = b + len;

        std::ostringstream              os;

        f.begin(os) << std::hex << std::uppercase;
        for (const unsigned char* c = b; c < e; c += Params::lwidth)
          {
            if (Params::p_addr)
              f.bold_end(f.bold_begin(os)
                         << std::setfill ('0') << std::setw (8) << (c - b));
            if (Params::p_hex)
              for (unsigned i = 0; i < Params::lwidth; i += Params::bwidth)
                {
                  if (Params::p_addr or i)
                    os << Params::bigsep;
                  for (unsigned j = 0;
                       j < Params::bwidth and c + i + j < e;
                       ++j)
                    {
                      if (j)
                        os << Params::smallsep;
                      os << std::setfill ('0') << std::setw (2)
                         << unsigned (c[i + j]);
                    }
                  if (Params::p_char)
                    for (int j = Params::bwidth - 1;
                         j >= 0 and c + i + j >= e;
                         --j)
                      {
                        if (j)
                          os << Params::smallsep;
                        os << "  ";
                      }
                }
            if (Params::p_char)
              {
                f.bold_end(f.bold_begin(os << Params::bigsep)
                           << Params::colsep);
                for (unsigned i = 0; i < Params::lwidth; ++i)
                  f.encode(os, c + i < e ? c[i] : ' ');
                f.bold_end(f.bold_begin(os) << Params::colsep);
              }
            if (Params::endl)
              os << '\n';
          }
        f.end(os);
        return os.str();
      }

      inline
      std::vector<uint8_t>
      read(const std::string& s)
      {
        typedef std::vector<uint8_t> vector;

        if (s.size() % 2)
          throw std::invalid_argument ("Hexadecimal strings must have an even "
                                       "number of digits");

        const size_t            size = s.size() / 2;

        vector                  res (size);
        std::string::const_iterator     cur = s.begin();

        for (size_t i = 0; i < size; ++i)
          {
            uint8_t     t = 0;

            for (size_t j = 0; j < 2; ++j, ++cur)
              {
                assert(cur != s.end());
                t = t << 4;
                if ('0' <= *cur and *cur <= '9')
                  t |= *cur - '0';
                else if ('a' <= *cur and *cur <= 'f')
                  t |= *cur - 'a' + 10;
                else if ('A' <= *cur and *cur <= 'F')
                  t |= *cur - 'A' + 10;
                else
                  throw std::invalid_argument ("Not an hexadecimal string");
              }
            res[i] = t;
          }
        assert(cur == s.end());
        return res;
      }

    } // End of namespace wpl::tool::hex.

  } // End of namespace wpl::tool.

} // End of namespace wpl.

#endif // ! WIPAL_TOOL_HEXDUMP_HXX_

---