xdump.c File Reference

Print Hex Dump: Implementation More...

#include "..\includes.h"

Macros
#define	INC_XDUMP
#define	EOS   '\0'

Functions
void	xd_config_output (void *output)
void	outline (char *dat, int16_t len)
void	xd (void *mem, uint32_t bufl, int16_t dochar, uint32_t address, size_t size)

Variables
static int16_t	bytesperline = 16
static int16_t	doublechar = 0
static int16_t	dflen = 2
static uint32_t	fileaddr
static char	lineecho [32]
static tpOutputFunc	_out_stream =NULL

Detailed Description

                          _         _             _
                       __| |    ___(_) ____ _ __ | |_
                      / _` |   / __| |/ _` | '_ \| __|
                     | (_| | _ \__ \ | (_| | | | | |_
                      \__,_|(_) ___/_|\__, |_| |_|\__|
                     Signalprocessing |___/ Technology

Author

D.SignT GmbH & Co. KG, Claus Hermbusche

Version

2.91

Date

2019-04-17

Macro Definition Documentation

#define INC_XDUMP

include hex dump module: xdump.h

#define EOS   '\0'

Function Documentation

void xd_config_output

(

void *

output

)

{
    _out_stream = (tpOutputFunc)(uint32_t)output;
}

void outline	(	char *	dat,
		int16_t	len
	)

{
    /***************************************************************************
     locals
    ***************************************************************************/
    char oline[132];
    char outedit[80];
    int16_t i;
    char oc[2];
    int16_t shortfall;
    char b;

    /***************************************************************************
     start line with address
    ***************************************************************************/
    sprintf (oline, " %08"PRIx32, fileaddr);
    strcat (oline, ":");

    /***************************************************************************
     hex dump
    ***************************************************************************/
    for (i = 0; i < len; i++)
    {
        sprintf (outedit, "%02X", (unsigned char)dat[i]);
        strcat (oline, (i == (bytesperline / 2)) ? "  " : " ");
        strcat (oline, outedit);
    }

    /***************************************************************************
     ascii output
    ***************************************************************************/
    if (doublechar)
    {
        /***********************************************************************
         add blanks if necessary
        ***********************************************************************/
        shortfall = ((bytesperline - len) * (dflen + 1)) +   (len <= (bytesperline / 2) ? 1 : 0);

        while (shortfall-- > 0)
        {
            strcat (oline, " ");
        }
        oc[1] = EOS;

        /***********************************************************************
         add hex - ASCII separator
        ***********************************************************************/
        strcat (oline, " | ");

        /***********************************************************************
         copy ASCII chars
        ***********************************************************************/
        for (i = 0; i < len; i++)
        {
            b = dat[i];

            /*******************************************************************
             Map non-printing characters to "." according to the
            definitions for ISO 8859/1 Latin-1.
            *******************************************************************/
            // if ( (b == '\%') || (b < ' ') || ((b > '~') && (b < 145)) || ((b > 146) && (b < 160)) )
            if ( !isprint(b))
            {
                b = '.';
            }
            oc[0] = b;
            strcat (oline, (const char *)oc);
        }
    }

    /***************************************************************************
     add CR LF
    ***************************************************************************/
    strcat (oline, CRLF);

    /***************************************************************************
     print line
    ***************************************************************************/
    if (_out_stream) _out_stream(oline);
}

void xd	(	void *	mem,
		uint32_t	bufl,
		int16_t	dochar,
		uint32_t	address,
		size_t	size
	)

function xd (void *mem, unsigned int bufl, short dochar) Dump a buffer.

Parameter mem - Address of buffer to dump. bufl - Buffer length in bytes. dochar - If nonzero, show ASCII/ISO characters as well as hexadecimal. address - address-offset size - size of buffer element Returns - Calls -

{
    /***************************************************************************
     locals
    ***************************************************************************/
    int16_t bp;
    uint32_t len = bufl;
    char b;
#if (UCHAR_MAX==USHRT_MAX)
    char *buf = (char *) mem;
    uint16_t *buf16 = (uint16_t *) mem;
    uint32_t *buf32 = (uint32_t *) mem;
    uint32_t  temp;
#else
    char *buf = (char *) mem;
    len = bufl * size;
#endif
    bp = 0;
    doublechar = dochar;                         /* do ASCII output           */

    if ( fileaddr != address )
    {
        if (_out_stream) _out_stream("\r\n");

        fileaddr = address;                      /* for printing purpose only */
    }

    while (len-- > UINT32_C(0))
    {
#if (UCHAR_MAX==USHRT_MAX)
        switch ( size )
        {
            case (size_t)1:
#endif
                b = *buf++;
                if (bp >= bytesperline)
                {
                    outline (lineecho, bp);
                    bp = 0;
                    fileaddr += bytesperline;
                }
                lineecho[bp++] = b;
#if (UCHAR_MAX==USHRT_MAX)
                break;

            case (size_t)2:
                b = (char)*buf16 & 0xff;
                lineecho[bp++] = b;
                b = (char)(*buf16++>>8) & 0xff;
                lineecho[bp++] = b;
                if (bp >= bytesperline)
                {
                    outline (lineecho, bp);
                    bp = 0;
                    fileaddr += bytesperline;
                }
                break;

            case (size_t)4:
                temp = *buf32++;
                b = (char)(temp & 0xff);
                lineecho[bp++] = b;
                temp>>=8;
                b = (char)(temp & 0xff);
                lineecho[bp++] = b;
                temp>>=8;
                b = (char)(temp & 0xff);
                lineecho[bp++] = b;
                temp>>=8;
                b = (char)(temp & 0xff);
                lineecho[bp++] = b;
                if (bp >= bytesperline)
                {
                    outline (lineecho, bp);
                    bp = 0;
                    fileaddr += bytesperline;
                }
                break;

            default :
                len = UINT32_C(1);  // error
                break;

        }  // switch
#endif
    }

    /***************************************************************************
     data left to print?
    ***************************************************************************/
    if (bp > 0)
    {
        outline (lineecho, bp);
    }

    /***************************************************************************
     add CRLF
    ***************************************************************************/
    // if (_out_stream) _out_stream(CRLF);
}

Variable Documentation

int16_t bytesperline = 16

static

int16_t doublechar = 0

static

int16_t dflen = 2

static

uint32_t fileaddr

static

char lineecho[32]

static

tpOutputFunc _out_stream =NULL

static