/* ------  functions open for use:  (i.e. non-static) ------------------ 
 *
 * r_sprintf_long_to_hex  - convert a long to a hex digit string
 *
 * r_hex_str_to_long      - convert a hex digit string to a long
 *
 * ---------------------------------------------------------------------
*/


#include <stdio.h>
#include "r_misc.h"

/* -- locals */
static int ulong_size ( unsigned long l );
/* -- end locals */


/*----------------------------------------------------------------------
 * r_hex_str_to_long    - convert hex_digits hex digits to a long
 *
 * Conver up to 8 hex digits into a single unsigned long integer.
 * The input string must consist of hex type characters, without
 * a leading 0x.  i.e. '0'->'9', 'a'->'f' and 'A'->'F'.
 *
 * return the unsigned long integer, or 0 on failure
 *----------------------------------------------------------------------
*/
unsigned long
r_hex_str_to_long ( char * src, int hex_digits )
{
    unsigned long   res = 0;
    char          * cp;
    int             nib, digs;

    if ( hex_digits <= 0 || hex_digits > 8 )
	return 0;

    for ( digs = hex_digits, cp = src; digs > 0; digs--, cp++ )
    {
	if ( (*cp >= '0') && (*cp <= '9') )
	    nib = *cp - '0';
	else if ( (*cp >= 'a') && (*cp <= 'f') )
	    nib = *cp - 'a' + 10;
	else if ( (*cp >= 'A') && (*cp <= 'F') )
	    nib = *cp - 'A' + 10;
	else
	{
	    fprintf( stderr, "r_hex_str_to_long: invalid input string <%8s>\n",
		     src );
	    return 0;
	}

	res = (res << 4) + (nib & 0xf);
    }

    return res;
}


/*----------------------------------------------------------------------
 * r_sprintf_long_to_hex    - write hex chars to a string
 *
 * Convert the low-order number of bytes from the unsigned long into
 * a null-terminated string hex characters (strlen() is twice the
 * number of converted bytes).
 *
 * We input the option to pad the string with zeros if the number
 * is too small for the requested number of bytes.
 *
 * return number of hex pairs written (if padding, should equal bytes)
 *----------------------------------------------------------------------
*/
int
r_sprintf_long_to_hex
    (
	char          * dest,           /* location of output string     */
	unsigned long   lsrc,		/* number to translate           */
	int             bytes, 		/* total bytes (hex pairs)       */
	int		pad		/* pad the result with zeros?    */
    )
{
    static char hexstring[] = "0123456789ABCDEF";

    unsigned char   ub;
    char          * cp = dest;
    int             posn, size, ret;

    if ( (bytes <= 0) || (bytes > 4) )
    {
	*cp = '\0';
	return 0;
    }

    size = ulong_size( lsrc );

    if ( (size < bytes) && !pad )	/* use size if we avoid padding  */
	ret = size;
    else
	ret = bytes;

    for ( posn = ret-1; posn >= 0; posn-- )
    {
	/* write one hex pair for this byte */
	ub = ( lsrc >> (posn << 3) ) & 0xff;		/* current ubyte */
	*cp++ = hexstring[(ub>>4) & 0xf];		/* upper nibble  */
	*cp++ = hexstring[ ub     & 0xf];		/* lower nibble  */
    }

    *cp = '\0';

    return ret;
}

/* return number of bytes needed to represent a long - return at least 1 */
static int
ulong_size ( unsigned long l )
{
    if ( l & 0xff000000 )
	return 4;

    if ( l & 0xff0000 )
	return 3;

    if ( l & 0xff00 )
	return 2;

    return 1;
}