#include "hexdumper.h"

#define iteratorptr(v)  (&(*(v)))

inline unsigned char bytefromvptr(const unsigned char *p)
{
    return *p;
}
inline unsigned short wordfromvptr(const unsigned char *p)
{
    return (bytefromvptr(p)<<8) | bytefromvptr(p+1);
}
inline unsigned long dwordfromvptr(const unsigned char *p)
{
    return (wordfromvptr(p)<<16) | wordfromvptr(p+2);
}
void hexdumpbytes(char sep, std::string &str, const unsigned char *buf, size_t n)
{
    str.resize(str.size()+n*(sizeof(char)*2+1)-1);
    std::string::iterator sp= str.end()-n*(sizeof(char)*2+1)+1;

    for (size_t i=0 ; i<n ; i++)
    {
        if (sep && i) *sp++ = sep;
        sp += sprintf(iteratorptr(sp), "%02x", bytefromvptr(buf+sizeof(char)*i));
    }
}
void hexdumpwords(char sep, std::string &str, const unsigned char *buf, size_t n)
{
    str.resize(str.size()+n*(sizeof(short)*2+1)-1);
    std::string::iterator sp= str.end()-n*(sizeof(short)*2+1)+1;

    for (size_t i=0 ; i<n ; i++)
    {
        if (sep && i) *sp++ = sep;
        sp += sprintf(iteratorptr(sp), "%04x", wordfromvptr(buf+sizeof(short)*i));
    }
}
void hexdumpdwords(char sep, std::string &str, const unsigned char *buf, size_t n)
{
    str.resize(str.size()+n*(sizeof(long)*2+1)-1);
    std::string::iterator sp= str.end()-n*(sizeof(long)*2+1)+1;

    for (size_t i=0 ; i<n ; i++)
    {
        if (sep && i) *sp++ = sep;
        sp += sprintf(iteratorptr(sp), "%08x", wordfromvptr(buf+sizeof(long)*i));
    }
}
void dumpascii(std::string &str, const unsigned char *buf, size_t n)
{
    str.resize(str.size()+n);
    std::string::iterator sp= str.end()-n;
    for (size_t i=0 ; i<n ; i++)
    {
        char c= (char)bytefromvptr(buf+i);
        *sp++ = (c>=' ' && c<='~')?c:'.';
    }
}
void writespaces(std::string &str, size_t n)
{
    str.resize(str.size()+n);
    std::string::iterator sp= str.end()-n;
    memset(iteratorptr(sp), ' ', n);
}

// returns nr of bytes used from buffer
// updates m_offset
size_t HexDumper::dumpline(const unsigned char*buf, size_t len)
{
    size_t n_used = 0;
    m_out.resize(m_out.size()+1);
    line_item_t& item= m_out.back();
    item.first= m_offset;
    // todo: handle DUMP_STRINGS, RAW
    if (m_dumpformat==DUMP_HEX || m_dumpformat==DUMP_HEX_ASCII)
        switch(m_dumpunit)
        {
            case DUMPUNIT_BYTE:  n_used= std::min(m_width, len/1); hexdumpbytes(m_separator, item.second, buf,  n_used);  break;
            case DUMPUNIT_WORD:  n_used= std::min(m_width, len/2); hexdumpwords(m_separator, item.second, buf,  n_used);  break;
            case DUMPUNIT_DWORD: n_used= std::min(m_width, len/4); hexdumpdwords(m_separator, item.second, buf, n_used); break;
        }
    // todo: add space padding for incomplete lines
    if (m_dumpformat==DUMP_HEX_ASCII)
        item.second += "  ";
    if (m_dumpformat==DUMP_ASCII || m_dumpformat==DUMP_HEX_ASCII)
    {
        simpleascdump(item.second, buf, m_width);
    }
    return n_used;
}
std::string HexDumper::getstring()
{
    // todo
}
void HexDumper::end()
{
    // todo
}