root/trunk/tango/scrapple/util/Hex.d

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

        Copyright:      Copyright (c) 2008 Tango.Scrapple. All rights reserved.

        License:        BSD style: $(LICENSE)

        Version:        Aug 29 2007: Initial release
            Feb 15 2007: add toHexString
            Feb 25 2007: remove toHexString

        Authors:        Moritz Warning
        
        Handy routines for working in base 16

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

module  tango.scrapple.util.Hex;

import  tango.io.Stdout;

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

 Print a hex dump:

 Length: 27 bytes
 0       54 68 69 73 20 69 73 20  61 20 73 61 6d 70 6c 65   |This.is. a.sample|
 16      20 73 74 72 69 6e 67 20  31 32 33                  |.string. 123     |

 mark_pos: marker '|' appears before position in hex field

  Author:                   Moritz Warning

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

void hexDump(ubyte[] data, uint mark_pos = 0)
{
        alias Stdout o;
        o("Length: ")(data.length)(" bytes");
        if(mark_pos)
        {
                o("; Mark Position: ");
                if(mark_pos < data.length)
                {
                        o(mark_pos)(", Line ")(mark_pos/16);
                }
                else
                {
                        o("[out of range]");
                }
        } 
        else
        {
                mark_pos = data.length;
        }
        o('\n');
        
        char[2] hex;
        
        //convert byte to hex
        void putHex(ubyte x)
        {
                static const char char_array[16]  = "0123456789abcdef";
                hex[0] = char_array[(x >> 4)];
                hex[1] = char_array[(x & 0xF)];
                o(hex);
        };
        
        void putChar(char c)
        {
                o((c > 32 && c < 127) ? c : '.');
        };
        
        //print all full lines
        uint pos = 0;
        for(ushort line = 0; line < data.length/16; line++)
        {
                //print current position
                o(pos);
                o('\t');
                
                for (ubyte i = 0; i < 8; i++, pos++)
                {
                        o((mark_pos == pos) ? '|' : ' ');
                        putHex(data[pos]);
                }
                o(' ');
                for (ubyte i = 0; i < 8; i++, pos++)
                {
                        o((mark_pos == pos) ? '|' : ' ');
                        putHex(data[pos]);
                }
                
                o("  |"c);
                pos -= 16;
                
                for (ubyte i = 0; i < 8; i++, pos++)
                {
                        putChar(data[pos]);
                }
                o(' ');
                for (ubyte i = 0; i < 8; i++, pos++)
                {
                        putChar(data[pos]);
                }
                o("|\n"c);
                o.flush(); //TODO: neccessary?
        }
        
        uint lpos = data.length - pos;
        if(lpos == 0) return;

        o(pos);
        o('\t');
        
        if(lpos < 9) //print lines with less then 9 hex values
        {
                for (ubyte i = 0; i < lpos; i++, pos++)
                {
                        o((mark_pos == pos) ? '|' : ' ');
                        putHex(data[pos]);
                }
                
                //padding for hex field
                for (ubyte i = 0; i < (3 * 16) - (3 * lpos) + 1; i++)
                {
                        o(' ');
                }
                
                o("  |"c);
                pos -= lpos;
                
                for (ubyte i = 0; i < lpos; i++, pos++)
                {
                        putChar(data[pos]);
                }
                o(' ');
                
                //padding for text field
                for (ubyte i = 0; i < 16 - lpos; i++)
                {
                        o(' ');
                }
                o("|\n"c);
        }
        else //print lines with less then 16 hex values
        {
                for (ubyte i = 0; i < 8; i++, pos++)
                {
                        o((mark_pos == pos) ? '|' : ' ');
                        putHex(data[pos]);
                }
                o(' ');
                for (ubyte i = 0; i < lpos - 8; i++, pos++)
                {
                        o((mark_pos == pos) ? '|' : ' ');
                        putHex(data[pos]);
                }
                //padding for hex field
                for (ubyte i = 0; i < (3 * 16) - (3 * lpos); i++)
                {
                        o(' ');
                }
                
                o("  |"c);
                pos -= lpos;
                
                for (ubyte i = 0; i < 8; i++, pos++)
                {
                        putChar(data[pos]);
                }
                o(' ');
                for (ubyte i = 0; i < lpos - 8; i++, pos++)
                {
                        putChar(data[pos]);
                }
                
                //padding for text field
                for (ubyte i = 0; i < 16 - lpos; i++)
                {
                        o(' ');
                }
                o("|\n"c);
        }
        o.flush();
}

/*******************************************************************************
  
  Convert a hex string to a ubyte
  
  Params:       hex =           The hext string to convert
                ub =            The return value
  Returns                       True on success

  Author:                   Moritz Warning

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

bool hexToUbyte(char[] hex, out ubyte ub)
{
    if (hex.length != 2)
        return false;

    char c1 = hex[0];
    char c2 = hex[1];

    if (c1 >= 'A' && c1 <='F')
        c1 += 32;
    if (c2 >= 'A' && c2 <='F')
        c2 += 32;

    int cCount;

    foreach (i, d; DIGITS)
    {
        if (d == c1)
        {
            ub = ub | i << 4;
            cCount++;
        }

        if (d == c2)
        {
            ub |= i;
            cCount++;
        }

        if (cCount == 2)
            break;
    }

    return cCount == 2;
}

/*******************************************************************************
  
  Convert a ubyte to a hex string
  
  Params:       hex =           The hex string to convert
                ub =            The return value

  Author:                   Moritz Warning

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

void ubyteToHex(inout ubyte ub, char[] hex)
{
    assert (hex.length == 2);

    hex[0] = DIGITS[ub >> 4];
    hex[1] = DIGITS[ub & 0x0F];
}

private
{
    const char[] INVALID_UUID_STRING = "Invalid UUID string format";
    const char[] DIGITS = "0123456789abcdef";
}