nmLibPack.c File Reference

Field value packing/unpacking definitions. More...

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <libgen.h>
#include <string.h>
#include <ctype.h>
#include <endian.h>
#include <ieee754.h>
#include "rnr/rnrconfig.h"
#include "rnr/log.h"
#include "rnr/netmsgs.h"
#include "nmLibInternal.h"

Go to the source code of this file.

Macros
#define	HOST_BIG_ENDIAN
	big-endian byte order
#define	HOST_WORD_SIZE   32
	32-bit architecture
#define	PACKNATIVE(val, buf)   packbig((byte_t *)&(val), sizeof(val), buf)
	Pack an element into the message buffer in native byte order. More...
#define	UNPACKNATIVE(buf, pval)   unpackbig(buf, (byte_t *)pval, sizeof(*pval))
	Unpack an element from the message buffer in native byte order. More...
#define	PACK64NATIVE(uMSB, uLSB, buf)   PACK64BIG(uMSB, uLSB, buf)
	Pack two 4-btye unsigned integers into the message buffer in native byte order. More...
#define	UNPACK64NATIVE(buf, puMSB, puLSB)   UNPACK64BIG(buf, puMSB, puLSB)
	Unpack two 4-byte unsigned integers from the message buffer in native byte order. More...
#define	PACKBIG(val, buf)   packbig((byte_t *)&(val), sizeof(val), buf)
	Pack an element into the message buffer in big-endian byte order. More...
#define	UNPACKBIG(buf, pval)   unpackbig(buf, (byte_t *)pval, sizeof(*pval));
	Unpack an element from the message buffer in big-endian byte order. More...
#define	PACKLITTLE(val, buf)   packlittle((byte_t *)&(val), sizeof(val), buf)
	Pack an element into the message buffer in little-endian byte order. More...
#define	UNPACKLITTLE(buf, pval)   unpacklittle(buf, (byte_t *)pval, sizeof(*pval))
	Unpack an element from the message buffer in little-endian byte order. More...
#define	PACK64BIG(uMSB, uLSB, buf)
	Pack two 4-btye unsigned integers into the message buffer in big-endian byte order. More...
#define	UNPACK64BIG(buf, puMSB, puLSB)
	Unpack two 4-byte unsigned integers from the message buffer in big-endian byte order. More...
#define	PACK64LITTLE(uMSB, uLSB, buf)
	Pack two 4-btye unsigned integers into the message buffer in little-endian byte order. More...
#define	UNPACK64LITTLE(buf, puMSB, puLSB)
	Unpack two 4-byte unsigned integers from the message buffer in little-endian byte order. More...
#define	IEEE754_F32_SIGN_SHIFT   31
	f32 sign shift
#define	IEEE754_F32_SIGN_MASK   0x00000001
	f32 sign mask
#define	IEEE754_F32_EXPONENT_SHIFT   23
	f32 exponent shift
#define	IEEE754_F32_EXPONENT_MASK   0x000000ff
	f32 exponent mask
#define	IEEE754_F32_MANTISSA_SHIFT   0
	f32 mantissa shift
#define	IEEE754_F32_MANTISSA_MASK   0x007fffff
	f32 mantissa mask
#define	IEEE754_F64_SIGN_SHIFT   31
	f64 sign shift
#define	IEEE754_F64_SIGN_MASK   0x00000001
	f64 sign mask
#define	IEEE754_F64_EXPONENT_SHIFT   20
	f64 exponent shift
#define	IEEE754_F64_EXPONENT_MASK   0x000007ff
	f64 exponent mask
#define	IEEE754_F64_MANTISSA0_SHIFT   0
	f64 msb mantissa shift
#define	IEEE754_F64_MANTISSA0_MASK   0x000fffff
	f64 msb mantissa mask
#define	IEEE754_F64_MANTISSA1_SHIFT   0
	f64 lsb mantissa shift
#define	IEEE754_F64_MANTISSA1_MASK   0xffffffff
	f64 lsb mantissa mask
#define	IEEE754_F32_F64_MANTISSA0_SHIFT   3
	msb mantissa shift
#define	IEEE754_F32_F64_MANTISSA1_SHIFT   29
	lsb mantissa shift
#define	IEEE754_F32_F64_MANTISSA1_MASK   0x00000007
	lsb mantissa mask
#define	IEEE754_F32_EXP_MAX   127
	maximum power of 2 exponent
#define	IEEE754_F32_EXP_MIN   (-126)
	minimum power of 2 exponent
#define	IEEE754_F64_EXP_MAX   1023
	maximum power of 2 exponent
#define	IEEE754_F64_EXP_MIN   (-1022)
	minimum power of 2 exponent
#define	IEEE754_F32_POS_INF   HUGE_VALF
	f32 positive infinity
#define	IEEE754_F32_NEG_INF   (-HUGE_VALF)
	f32 negative infinity
#define	IEEE754_F64_POS_INF   HUGE_VAL
	f64 positive infinity
#define	IEEE754_F64_NEG_INF   (-HUGE_VAL)
	f64 negative infinity
#define	_NM_CHK_MEM(size, count)
	Check if memory is available. More...
#define	_NM_CHK_ARCH(val, size)
	Check if host architecture supports basic element sizes. More...

Functions
static void	packbig (byte_t *p, size_t size, byte_t buf[])
	Pack an element into the message buffer in big-endian byte order. More...
static void	unpackbig (byte_t buf[], byte_t *p, size_t size)
	Unpack an element from the message buffer in big-endian byte order. More...
static void	packlittle (byte_t *p, size_t size, byte_t buf[])
	Pack an element into the message buffer in little-endian byte order. More...
static void	unpacklittle (byte_t buf[], byte_t *p, size_t size)
	Unpack an element from the message buffer in little-endian byte order. More...
static bool_t	ieee754_f32_is_nan (union ieee754_float f)
	Test if 32-bit floating-point number is a NaN. More...
static bool_t	ieee754_f64_is_nan (union ieee754_double d)
	Test if 64-bit floating-point number is a NaN. More...
static bool_t	ieee754_f32_is_inf (union ieee754_float f)
	Test if 32-bit floating-point number is ± infinity. More...
static bool_t	ieee754_f64_is_inf (union ieee754_double d)
	Test if 64-bit floating-point number is ± infinity. More...
static bool_t	ieee754_f32_is_zero (union ieee754_float f)
	Test if 32-bit floating-point number is ± 0.0. More...
static bool_t	ieee754_f64_is_zero (union ieee754_double d)
	Test if 64-bit floating-point number is ± 0.0. More...
int	nmPackU8 (byte_t val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an unsigned 8-bit byte into the message buffer. More...
int	nmPackU16 (ushort_t val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an unsigned 16-bit integer into the message buffer. More...
int	nmPackU32 (uint_t val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an unsigned 32-bit integer into the message buffer. More...
int	nmPackU64 (ulonglong_t val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an unsigned 64-bit integer into the message buffer. More...
int	nmPackS64 (long long val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack an signed 64-bit integer into the message buffer. More...
int	nmPackF32 (float val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a 32-bit float into the message buffer. More...
int	nmPackF64 (double val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a 64-bit float into the message buffer. More...
int	nmPackP32 (void *val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a 32-bit pointer into the message buffer. More...
int	nmPackP64 (void *val, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a 64-bit pointer into the message buffer. More...
int	nmPackBuf (byte_t bufSrc[], size_t uCount, byte_t buf[], size_t bufSize, NMEndian_T eEndian)
	Pack a byte buffer into the message buffer. More...
int	nmUnpackU8 (byte_t buf[], size_t bufSize, byte_t *pVal, NMEndian_T eEndian)
	Unpack an unsigned 8-bit byte from the message buffer. More...
int	nmUnpackU16 (byte_t buf[], size_t bufSize, ushort_t *pVal, NMEndian_T eEndian)
	Unpack an unsigned 16-bit integer from the message buffer. More...
int	nmUnpackU32 (byte_t buf[], size_t bufSize, uint_t *pVal, NMEndian_T eEndian)
	Unpack an unsigned 32-bit integer from the message buffer. More...
int	nmUnpackU64 (byte_t buf[], size_t bufSize, ulonglong_t *pVal, NMEndian_T eEndian)
	Unpack an unsigned 64-bit integer from the message buffer. More...
int	nmUnpackS64 (byte_t buf[], size_t bufSize, long long *pVal, NMEndian_T eEndian)
	Unpack an signed 64-bit integer from the message buffer. More...
int	nmUnpackF32 (byte_t buf[], size_t bufSize, float *pVal, NMEndian_T eEndian)
	Unpack a 32-bit float from the message buffer. More...
int	nmUnpackF64 (byte_t buf[], size_t bufSize, double *pVal, NMEndian_T eEndian)
	Unpack a 64-bit float from the message buffer. More...
int	nmUnpackP32 (byte_t buf[], size_t bufSize, void *pVal, NMEndian_T eEndian)
	Unpack a 32-bit pointer from the message buffer. More...
int	nmUnpackP64 (byte_t buf[], size_t bufSize, void *pVal, NMEndian_T eEndian)
	Unpack a 64-bit pointer from the message buffer. More...
int	nmUnpackBuf (byte_t buf[], size_t bufSize, byte_t bufDst[], size_t uCount, NMEndian_T eEndian)
	Unpack a byte buffer from the message buffer. More...

Variables
static const union ieee754_float	IEEE754_F32_NaN
static const union ieee754_double	IEEE754_F64_NaN
static const union ieee754_float	IEEE754_F32_Inf
static const union ieee754_double	IEEE754_F64_Inf
static const union ieee754_float	IEEE754_F32_Zero
static const union ieee754_double	IEEE754_F64_Zero

Detailed Description

Field value packing/unpacking definitions.

LastChangedDate

2011-11-18 13:32:30 -0700 (Fri, 18 Nov 2011)

Rev

1578

The host may be either a big-endian or little-endian architecture. Currenly, any exotic architectures are not supported. It is assumed that 1, 2, and 4 byte (unsigned) integers and 4 byte floats are supported. For systems that do not support 8 byte (unsigned) integers or 8 byte doubles, promotion will be done in software. However, on unpacking, rounding or truncation will occur if the unpacked element exceeds the 4 byte limits.

Floats are expected to be in IEEE 754 format.

Author

Robin Knight (robin.nosp@m..kni.nosp@m.ght@r.nosp@m.oadn.nosp@m.arrow.nosp@m.s.co.nosp@m.m)

Copyright

© 2009-2017. RoadNarrows LLC.
http://www.roadnarrows.com
All Rights Reserved

Definition in file nmLibPack.c.

Macro Definition Documentation

#define _NM_CHK_ARCH	(		val,
			size
	)

Value:

do \
  { \
    if( sizeof(val) != (size) ) \
    { \
      return -NM_ECODE_ARCH_NOTSUP; \
    } \
  } \
  while(0)

Check if host architecture supports basic element sizes.

On check failure, returns from calling function with NM_ECODE_ARCH_NOTSUP.

Parameters

val	Element to check
size	Required byte size.

Definition at line 724 of file nmLibPack.c.

Referenced by nmPackF32(), nmPackF64(), nmPackP64(), nmPackS64(), nmPackU64(), nmUnpackF32(), nmUnpackF64(), nmUnpackP64(), nmUnpackS64(), and nmUnpackU64().

#define _NM_CHK_MEM	(		size,
			count
	)

Value:

do \
  { \
    if( (size) < (count) ) \
    { \
      return -NM_ECODE_NOMEM; \
    } \
  } \
  while(0)

Check if memory is available.

On check failure, returns from calling function with NM_ECODE_NOMEM.

Parameters

size	Available memory in bytes.
count	Required memory.

Definition at line 705 of file nmLibPack.c.

Referenced by nmPackBuf(), nmPackF32(), nmPackF64(), nmPackP32(), nmPackP64(), nmPackS64(), nmPackU16(), nmPackU32(), nmPackU64(), nmPackU8(), nmUnpackBuf(), nmUnpackF32(), nmUnpackF64(), nmUnpackP32(), nmUnpackP64(), nmUnpackS64(), nmUnpackU16(), nmUnpackU32(), nmUnpackU64(), and nmUnpackU8().

#define PACK64BIG	(		uMSB,
			uLSB,
			buf
	)

Value:

do \
  { \
    PACKBIG(uMSB, buf); \
    PACKBIG(uLSB, &(buf)[4]); \
  } while(0)

Pack two 4-btye unsigned integers into the message buffer in big-endian byte order.

Safe 8-byte packing.

Note

The netmsgs package requires the host to have 4-byte integers available, but not 8-byte versions.

Parameters

[in]	uMSB	Most Significant Bytes.
[in]	uLSB	Least Significant Bytes.
[out]	buf	Output message buffer.

Definition at line 436 of file nmLibPack.c.

Referenced by nmPackF64(), nmPackS64(), and nmPackU64().

#define PACK64LITTLE	(		uMSB,
			uLSB,
			buf
	)

Value:

do \
  { \
    PACKLITTLE(uLSB, buf); \
    PACKLITTLE(uMSB, &(buf)[4]); \
  } while(0)

Pack two 4-btye unsigned integers into the message buffer in little-endian byte order.

Safe 8-byte packing.

Note

The netmsgs package requires the host to have 4-byte integers available, but not 8-byte versions.

Parameters

[in]	uMSB	Most Significant Bytes.
[in]	uLSB	Least Significant Bytes.
[out]	buf	Output message buffer.

Definition at line 477 of file nmLibPack.c.

Referenced by nmPackF64(), nmPackS64(), and nmPackU64().

#define PACK64NATIVE	(		uMSB,
			uLSB,
			buf
	)		PACK64BIG(uMSB, uLSB, buf)

Pack two 4-btye unsigned integers into the message buffer in native byte order.

Big-Endian Host Version

Parameters

[in]	uMSB	Most Significant Bytes.
[in]	uLSB	Least Significant Bytes.
[out]	buf	Output message buffer.

Definition at line 238 of file nmLibPack.c.

Referenced by nmPackF64(), nmPackP64(), nmPackS64(), and nmPackU64().

#define PACKBIG	(		val,
			buf
	)		packbig((byte_t *)&(val), sizeof(val), buf)

Pack an element into the message buffer in big-endian byte order.

Parameters

[in]	val	Type T element to be packed.
[out]	buf	Output message buffer.

Definition at line 397 of file nmLibPack.c.

Referenced by nmPackF32(), nmPackS64(), nmPackU16(), nmPackU32(), and nmPackU64().

#define PACKLITTLE	(		val,
			buf
	)		packlittle((byte_t *)&(val), sizeof(val), buf)

Pack an element into the message buffer in little-endian byte order.

Parameters

[in]	val	Type T element to be packed.
[out]	buf	Output message buffer.

Definition at line 413 of file nmLibPack.c.

Referenced by nmPackF32(), nmPackS64(), nmPackU16(), nmPackU32(), and nmPackU64().

#define PACKNATIVE	(		val,
			buf
	)		packbig((byte_t *)&(val), sizeof(val), buf)

Pack an element into the message buffer in native byte order.

Big-Endian Host Version

Parameters

[in]	val	Type T element to be packed.
[out]	buf	Output message buffer.

Definition at line 216 of file nmLibPack.c.

Referenced by nmPackF32(), nmPackP32(), nmPackS64(), nmPackU16(), nmPackU32(), and nmPackU64().

#define UNPACK64BIG	(		buf,
			puMSB,
			puLSB
	)

Value:

do \
  { \
    UNPACKBIG(buf, puMSB); \
    UNPACKBIG(&(buf)[4], puLSB); \
  } while(0)

Unpack two 4-byte unsigned integers from the message buffer in big-endian byte order.

Safe 8-byte packing.

Note

The netmsgs package requires the host to have 4-byte integers available, but not 8-byte versions.

Parameters

[in]	buf	Output message buffer.
[out]	puMSB	Pointer to Most Significant Bytes.
[out]	puLSB	Pointer to Least Significant Bytes.

Definition at line 457 of file nmLibPack.c.

Referenced by nmUnpackF64(), nmUnpackS64(), and nmUnpackU64().

#define UNPACK64LITTLE	(		buf,
			puMSB,
			puLSB
	)

Value:

do \
  { \
    UNPACKLITTLE(buf, puLSB); \
    UNPACKLITTLE(&(buf)[4], puMSB); \
  } while(0)

Unpack two 4-byte unsigned integers from the message buffer in little-endian byte order.

Safe 8-byte packing.

Note

The netmsgs package requires the host to have 4-byte integers available, but not 8-byte versions.

Parameters

[in]	buf	Output message buffer.
[out]	puMSB	Pointer to Most Significant Bytes.
[out]	puLSB	Pointer to Least Significant Bytes.

Definition at line 498 of file nmLibPack.c.

Referenced by nmUnpackF64(), nmUnpackS64(), and nmUnpackU64().

#define UNPACK64NATIVE	(		buf,
			puMSB,
			puLSB
	)		UNPACK64BIG(buf, puMSB, puLSB)

Unpack two 4-byte unsigned integers from the message buffer in native byte order.

Big-Endian Host Version

Parameters

[in]	buf	Output message buffer.
[out]	puMSB	Most Significant Bytes.
[out]	puLSB	Least Significant Bytes.

Definition at line 250 of file nmLibPack.c.

Referenced by nmUnpackF64(), nmUnpackP64(), nmUnpackS64(), and nmUnpackU64().

#define UNPACKBIG	(		buf,
			pval
	)		unpackbig(buf, (byte_t *)pval, sizeof(*pval));

Unpack an element from the message buffer in big-endian byte order.

Parameters

[in]	buf	Output message buffer.
[out]	pval	Type T* element to be unpacked (set).

Definition at line 405 of file nmLibPack.c.

Referenced by nmUnpackF32(), nmUnpackF64(), nmUnpackS64(), nmUnpackU16(), nmUnpackU32(), and nmUnpackU64().

#define UNPACKLITTLE	(		buf,
			pval
	)		unpacklittle(buf, (byte_t *)pval, sizeof(*pval))

Unpack an element from the message buffer in little-endian byte order.

Parameters

[in]	buf	Output message buffer.
[out]	pval	Type T* element to be unpacked (set).

Definition at line 421 of file nmLibPack.c.

Referenced by nmUnpackF32(), nmUnpackF64(), nmUnpackS64(), nmUnpackU16(), nmUnpackU32(), and nmUnpackU64().

#define UNPACKNATIVE	(		buf,
			pval
	)		unpackbig(buf, (byte_t *)pval, sizeof(*pval))

Unpack an element from the message buffer in native byte order.

Big-Endian Host Version

Parameters

[in]	buf	Output message buffer.
[out]	pval	Type T* element to be unpacked (set).

Definition at line 226 of file nmLibPack.c.

Referenced by nmUnpackF32(), nmUnpackF64(), nmUnpackP32(), nmUnpackS64(), nmUnpackU16(), nmUnpackU32(), and nmUnpackU64().

Function Documentation

static bool_t ieee754_f32_is_inf ( union ieee754_float  f )

inlinestatic

Test if 32-bit floating-point number is ± infinity.

Parameters

f	32-bit float with bit overlay.

Returns

Returns true or false.

Definition at line 653 of file nmLibPack.c.

Referenced by nmPackF64().

{
  return (f.ieee.exponent == IEEE754_F32_Inf.ieee.exponent)
         && (f.ieee.mantissa == 0)? true: false;
}

static bool_t ieee754_f32_is_nan ( union ieee754_float  f )

inlinestatic

Test if 32-bit floating-point number is a NaN.

Parameters

f	32-bit float with bit overlay.

Returns

Returns true or false.

Definition at line 631 of file nmLibPack.c.

Referenced by nmPackF64().

{
  return (f.ieee.exponent == IEEE754_F32_NaN.ieee.exponent)
         && (f.ieee.mantissa != 0)? true: false;
}

static bool_t ieee754_f32_is_zero ( union ieee754_float  f )

inlinestatic

Test if 32-bit floating-point number is ± 0.0.

Parameters

f	32-bit float with bit overlay.

Returns

Returns true or false.

Definition at line 675 of file nmLibPack.c.

Referenced by nmPackF64().

{
  return (f.ieee.exponent == IEEE754_F32_Zero.ieee.exponent)
         && (f.ieee.mantissa == 0)? true: false;
}

static bool_t ieee754_f64_is_inf ( union ieee754_double  d )

inlinestatic

Test if 64-bit floating-point number is ± infinity.

Parameters

d	64-bit float with bit overlay.

Returns

Returns true or false.

Definition at line 664 of file nmLibPack.c.

Referenced by nmUnpackF64().

{
  return (d.ieee.exponent == IEEE754_F64_Inf.ieee.exponent)
         && ((d.ieee.mantissa0 == 0) || (d.ieee.mantissa1 == 0))? true: false;
}

static bool_t ieee754_f64_is_nan ( union ieee754_double  d )

inlinestatic

Test if 64-bit floating-point number is a NaN.

Parameters

d	64-bit float with bit overlay.

Returns

Returns true or false.

Definition at line 642 of file nmLibPack.c.

Referenced by nmUnpackF64().

{
  return (d.ieee.exponent == IEEE754_F64_NaN.ieee.exponent)
         && ((d.ieee.mantissa0 != 0) || (d.ieee.mantissa1 != 0))? true: false;
}

static bool_t ieee754_f64_is_zero ( union ieee754_double  d )

inlinestatic

Test if 64-bit floating-point number is ± 0.0.

Parameters

d	64-bit float with bit overlay.

Returns

Returns true or false.

Definition at line 686 of file nmLibPack.c.

Referenced by nmUnpackF64().

{
  return (d.ieee.exponent == IEEE754_F64_Zero.ieee.exponent)
         && ((d.ieee.mantissa0 == 0) || (d.ieee.mantissa1 == 0))? true: false;
}

int nmPackBuf	(	byte_t	bufSrc[],
		size_t	uCount,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a byte buffer into the message buffer.

The source and message buffer memory areas can overlap.

Note

The buffer is always packed in sequential order ignoring the byte order parameter.

Parameters

[in]	bufSrc	Source buffer.
	uCount	Number of bytes to copy.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1215 of file nmLibPack.c.

References _NM_CHK_MEM.

{
  _NM_CHK_MEM(bufSize, uCount);

  // safe copy 
  memmove(buf, bufSrc, uCount);

  return (int)uCount;
}

int nmPackF32	(	float	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a 32-bit float into the message buffer.

The IEEE 754 32-bit format is used with both the big and little endian byte orders.

Note

On some machines, while integers were represented in little-endian form, floating point numbers were represented in big-endian form. Because there are many floating point formats, and a lack of a standard network representation, no standard for transferring floating point values has been made - Wikipedia.

Todo:

Detect non-IEEE 754 formats and convert to IEEE 754 prior to packing.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 957 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, IEEE754_F32_EXPONENT_MASK, IEEE754_F32_EXPONENT_SHIFT, IEEE754_F32_MANTISSA_MASK, IEEE754_F32_MANTISSA_SHIFT, IEEE754_F32_SIGN_MASK, IEEE754_F32_SIGN_SHIFT, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_F32, PACKBIG, PACKLITTLE, and PACKNATIVE.

Referenced by nmPackFlatF32(), and nmPackITVF32().

{
  static size_t fvalLen = NMFVAL_LEN_F32;     // message field value length

  union ieee754_float f;      // 4 byte floating-point number
  uint_t              uBits;  // bits

  _NM_CHK_MEM(bufSize, fvalLen);
  _NM_CHK_ARCH(val, fvalLen);

  f.f = val;

  uBits  = (uint_t)((f.ieee.negative & IEEE754_F32_SIGN_MASK)
                      << IEEE754_F32_SIGN_SHIFT);
  uBits |= (uint_t)((f.ieee.exponent & IEEE754_F32_EXPONENT_MASK)
                      << IEEE754_F32_EXPONENT_SHIFT);
  uBits |= (uint_t)((f.ieee.mantissa & IEEE754_F32_MANTISSA_MASK)
                      << IEEE754_F32_MANTISSA_SHIFT);

  switch( eEndian )
  {
    case NMEndianLittle:
      PACKLITTLE(uBits, buf);
      break;
    case NMEndianNative:
      PACKNATIVE(f.f, buf);
      break;
    case NMEndianBig:
    default:
      PACKBIG(uBits, buf);
      break;
  }

  return (int)fvalLen;
}

int nmPackF64	(	double	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a 64-bit float into the message buffer.

The IEEE 754 64-bit format is used with both the big and little endian byte orders. If the machine architecture only supports 32-bit doubles, then a conversion to 64-bit representation is performed first.

Note

On some machines, while integers were represented in little-endian form, floating point numbers were represented in big-endian form. Because there are many floating point formats, and a lack of a standard network representation, no standard for transferring floating point values has been made - Wikipedia.

Todo:

Detect non-IEEE 754 formats and convert to IEEE 754 prior to packing.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1013 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, IEEE754_F32_F64_MANTISSA0_SHIFT, IEEE754_F32_F64_MANTISSA1_MASK, IEEE754_F32_F64_MANTISSA1_SHIFT, ieee754_f32_is_inf(), ieee754_f32_is_nan(), ieee754_f32_is_zero(), IEEE754_F64_EXPONENT_MASK, IEEE754_F64_EXPONENT_SHIFT, IEEE754_F64_Inf, IEEE754_F64_MANTISSA0_MASK, IEEE754_F64_MANTISSA0_SHIFT, IEEE754_F64_MANTISSA1_MASK, IEEE754_F64_MANTISSA1_SHIFT, IEEE754_F64_NaN, IEEE754_F64_SIGN_MASK, IEEE754_F64_SIGN_SHIFT, IEEE754_F64_Zero, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_F32, NMFVAL_LEN_F64, PACK64BIG, PACK64LITTLE, and PACK64NATIVE.

Referenced by nmPackFlatF64(), and nmPackITVF64().

{
  static size_t fvalLen = NMFVAL_LEN_F64;     // message field value length

  union ieee754_float   f;        // 4-byte floating-point number
  union ieee754_double  d;        // 8-byte floating-point number
  uint_t                uMSB;     // Most Signifcant Bytes
  uint_t                uLSB;     // Least Signifcant Bytes

  _NM_CHK_MEM(bufSize, fvalLen);

  // 8-byte double
  if( sizeof(double) == fvalLen )
  {
    d.d = val;
  }

  // 4-byte double
  else
  {
    _NM_CHK_ARCH(val, (size_t)NMFVAL_LEN_F32);

    f.f = (float)val;

    // special infinity cases
    if( ieee754_f32_is_inf(f) )
    {
      d = IEEE754_F64_Inf;
    }

    // special zero cases
    else if( ieee754_f32_is_zero(f) )
    {
      d = IEEE754_F64_Zero;
    }

    // special Not-a-Number case
    else if( ieee754_f32_is_nan(f) )
    {
      d = IEEE754_F64_NaN;
    }
    
    // "normal" floating-point numbers
    else
    {
      d.ieee.exponent   = (f.ieee.exponent  + (uint_t)IEEE754_DOUBLE_BIAS
                                            - (uint_t)IEEE754_FLOAT_BIAS)
                            & IEEE754_F64_EXPONENT_MASK;
      d.ieee.mantissa0  = ((uint_t)(f.ieee.mantissa 
                                  >> (uint_t)IEEE754_F32_F64_MANTISSA0_SHIFT))
                            & IEEE754_F64_MANTISSA0_MASK;
      d.ieee.mantissa1  = (((uint_t)(f.ieee.mantissa)) 
                                  & (uint_t)IEEE754_F32_F64_MANTISSA1_MASK)
                            << IEEE754_F32_F64_MANTISSA1_SHIFT;
    }

    // preserve the sign
    d.ieee.negative = f.ieee.negative;
  }

  //
  // Stuff the bits into two 4-byte unsigned integers.
  //
  uMSB  = (uint_t)((d.ieee.negative & IEEE754_F64_SIGN_MASK)
                        << IEEE754_F64_SIGN_SHIFT);
  uMSB |= (uint_t)((d.ieee.exponent & IEEE754_F64_EXPONENT_MASK)
                        << IEEE754_F64_EXPONENT_SHIFT);
  uMSB |= (uint_t)((d.ieee.mantissa0 & IEEE754_F64_MANTISSA0_MASK)
                        << IEEE754_F64_MANTISSA0_SHIFT);
  uLSB  = (uint_t)((d.ieee.mantissa1 & IEEE754_F64_MANTISSA1_MASK)
                        << IEEE754_F64_MANTISSA1_SHIFT);

  switch( eEndian )
  {
    case NMEndianLittle:
      PACK64LITTLE(uMSB, uLSB, buf);
      break;
    case NMEndianNative:
      PACK64NATIVE(uMSB, uLSB, buf);
      break;
    case NMEndianBig:
    default:
      PACK64BIG(uMSB, uLSB, buf);
      break;
  }

  return (int)fvalLen;
}

int nmPackP32	(	void *	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a 32-bit pointer into the message buffer.

If the machine architecture has 64-bit pointers, then only the LSB 4 bytes are packed.

Note

Pointer is always packed in native byte order.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1113 of file nmLibPack.c.

References _NM_CHK_MEM, NMFVAL_LEN_P32, NMFVAL_LEN_P64, NMLIB_WARNING, and PACKNATIVE.

Referenced by nmPackFlatP32(), nmPackITVP32(), and nmPackPointer().

{
  static size_t fvalLen = NMFVAL_LEN_P32;     // message field value length
  ulong_t       luVal;
  uint_t        uVal;

  _NM_CHK_MEM(bufSize, fvalLen);

  // long's are same size as void *'s. exceptions?
  luVal = *((ulong_t *)val);

  // 4-byte natvie pointer
  if( sizeof(void *) == fvalLen )
  {
    PACKNATIVE(luVal, buf);
  }

  // 8-byte native pointer - "convert"
  if( sizeof(void *) == NMFVAL_LEN_P64 )
  {
#if HOST_WORD_SIZE == 64
    //if( luVal & 0xffffffff00000000 )
    if( (luVal) & 0xffffffff00000000 )
    {
      NMLIB_WARNING("%p: Packing 64-bit pointer in 32 bits lost non-zero "
                    "significance.", (void *)luVal);
    }
#endif // HOST_WORD_SIZE
    uVal = (uint_t)(luVal & 0xffffffff);
    PACKNATIVE(uVal, buf);
  }


  return (int)fvalLen;
}

int nmPackP64	(	void *	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack a 64-bit pointer into the message buffer.

If the machine architecture only supports 32-bit pointers, then the 4 MSBs are padded with 0's.

Note

Pointer is always packed in native byte order.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1160 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, NMFVAL_LEN_P32, NMFVAL_LEN_P64, and PACK64NATIVE.

Referenced by nmPackFlatP64(), nmPackITVP64(), and nmPackPointer().

{
  static size_t fvalLen = NMFVAL_LEN_P64;     // message field value length

  ulong_t               luVal;
  uint_t                uMSB;     // Most Signifcant Bytes
  uint_t                uLSB;     // Least Signifcant Bytes

  _NM_CHK_MEM(bufSize, fvalLen);

  // long's are same size as void *'s. exceptions?
  luVal = *((ulong_t *)val);

  // 8-byte pointer
  if( sizeof(void *) == fvalLen )
  {
#if HOST_WORD_SIZE == 64
    uMSB  = (uint_t)(luVal >> 32);
    uLSB  = (uint_t)(luVal & 0xffffffff);
#else
    uMSB  = 0;
    uLSB  = (uint_t)luVal;
#endif // HOST_WORD_SIZE
  }

  // 4-byte pointer
  else
  {
    _NM_CHK_ARCH(val, (size_t)NMFVAL_LEN_P32);

    uMSB  = 0;
    uLSB  = (uint_t)luVal;
  }

  PACK64NATIVE(uMSB, uLSB, buf);

  return (int)fvalLen;
}

int nmPackS64	(	long long	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an signed 64-bit integer into the message buffer.

If the machine architecture only supports 32-bit long longs, then the 4 MSBs are signed extended.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 885 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_S32, NMFVAL_LEN_S64, PACK64BIG, PACK64LITTLE, PACK64NATIVE, PACKBIG, PACKLITTLE, and PACKNATIVE.

Referenced by nmPackFlatS64(), nmPackITVS64(), nmPackLong(), and nmPackLongLong().

{
  static size_t fvalLen = NMFVAL_LEN_S64;     // message field value length

  uint_t        uMSB;     // most significant bytes
  uint_t        uLSB;     // least signifcant bytes

  _NM_CHK_MEM(bufSize, fvalLen);

  // 8-byte signed long long
  if( sizeof(long long) == fvalLen )
  {
    switch( eEndian )
    {
      case NMEndianLittle:
        PACKLITTLE(val, buf);
        break;
      case NMEndianNative:
        PACKNATIVE(val, buf);
        break;
      case NMEndianBig:
      default:
        PACKBIG(val, buf);
        break;
    }
  }

  // 4-byte signed long long
  else
  {
    _NM_CHK_ARCH(val, (size_t)NMFVAL_LEN_S32);

    uMSB = val & 0x80000000? 0xffffffff: 0x00000000;  // extend sign
    uLSB = (uint_t)val;

    switch( eEndian )
    {
      case NMEndianLittle:
        PACK64LITTLE(uMSB, uLSB, buf);
        break;
      case NMEndianNative:
        PACK64NATIVE(uMSB, uLSB, buf);
        break;
      case NMEndianBig:
      default:
        PACK64BIG(uMSB, uLSB, buf);
        break;
    }
  }

  return (int)fvalLen;
}

int nmPackU16	(	ushort_t	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an unsigned 16-bit integer into the message buffer.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 762 of file nmLibPack.c.

References _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_U16, PACKBIG, PACKLITTLE, and PACKNATIVE.

Referenced by nmPackFlatU16(), nmPackITVMsg(), nmPackITVMsgDebug(), nmPackITVU16(), nmPackS16(), nmPackShort(), and nmPackUShort().

{
  static size_t fvalLen = NMFVAL_LEN_U16;     // message field value length

  _NM_CHK_MEM(bufSize, fvalLen);

  switch( eEndian )
  {
    case NMEndianLittle:
      PACKLITTLE(val, buf);
      break;
    case NMEndianNative:
      PACKNATIVE(val, buf);
      break;
    case NMEndianBig:
    default:
      PACKBIG(val, buf);
      break;
  }

  return (int)fvalLen;
}

int nmPackU32	(	uint_t	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an unsigned 32-bit integer into the message buffer.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 791 of file nmLibPack.c.

References _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_U32, PACKBIG, PACKLITTLE, and PACKNATIVE.

Referenced by nmPackFlatU32(), nmPackInt(), nmPackITVU32(), nmPackS32(), nmPackUInt(), and nmPackULong().

{
  static size_t fvalLen = NMFVAL_LEN_U32;     // message field value length

  _NM_CHK_MEM(bufSize, fvalLen);

  switch( eEndian )
  {
    case NMEndianLittle:
      PACKLITTLE(val, buf);
      break;
    case NMEndianNative:
      PACKNATIVE(val, buf);
      break;
    case NMEndianBig:
    default:
      PACKBIG(val, buf);
      break;
  }

  return (int)fvalLen;
}

int nmPackU64	(	ulonglong_t	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an unsigned 64-bit integer into the message buffer.

If the machine architecture only supports 32-bit long longs, then the 4 MSBs are padded with zero's.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 823 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_U32, NMFVAL_LEN_U64, PACK64BIG, PACK64LITTLE, PACK64NATIVE, PACKBIG, PACKLITTLE, and PACKNATIVE.

Referenced by nmPackFlatU64(), nmPackITVU64(), nmPackULong(), and nmPackULongLong().

{
  static size_t fvalLen = NMFVAL_LEN_U64;     // message field value length

  uint_t        uMSB;     // most significant bytes
  uint_t        uLSB;     // least signifcant bytes

  _NM_CHK_MEM(bufSize, fvalLen);

  // 8-byte unsigned long long
  if( sizeof(ulonglong_t) == fvalLen )
  {
    switch( eEndian )
    {
      case NMEndianLittle:
        PACKLITTLE(val, buf);
        break;
      case NMEndianNative:
        PACKNATIVE(val, buf);
        break;
      case NMEndianBig:
      default:
        PACKBIG(val, buf);
        break;
    }
  }

  // 4-byte unsigned long long
  else
  {
    _NM_CHK_ARCH(val, (size_t)NMFVAL_LEN_U32);

    uMSB = 0;
    uLSB = (uint_t)val;

    switch( eEndian )
    {
      case NMEndianLittle:
        PACK64LITTLE(uMSB, uLSB, buf);
        break;
      case NMEndianNative:
        PACK64NATIVE(uMSB, uLSB, buf);
        break;
      case NMEndianBig:
      default:
        PACK64BIG(uMSB, uLSB, buf);
        break;
    }
  }

  return (int)fvalLen;
}

int nmPackU8	(	byte_t	val,
		byte_t	buf[],
		size_t	bufSize,
		NMEndian_T	eEndian
	)

Pack an unsigned 8-bit byte into the message buffer.

Parameters

[in]	val	Value to pack.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.
	eEndian	Packing order. See NMEndian_T.

Returns

On success, returns the number of bytes packed. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 745 of file nmLibPack.c.

References _NM_CHK_MEM, and NMFVAL_LEN_U8.

Referenced by nmPackBool(), nmPackByte(), nmPackChar(), nmPackFlatU8(), nmPackITVU8(), nmPackS8(), and nmPackSChar().

{
  static size_t fvalLen = NMFVAL_LEN_U8;      // message field value length

  _NM_CHK_MEM(bufSize, fvalLen);

  buf[0] = val & 0xff;

  return (int)fvalLen;
}

int nmUnpackBuf	(	byte_t	buf[],
		size_t	bufSize,
		byte_t	bufDst[],
		size_t	uCount,
		NMEndian_T	eEndian
	)

Unpack a byte buffer from the message buffer.

The source and message buffer memory areas can overlap.

Note

The buffer is always packed in sequential order ignoring the byte order parameter.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	bufDst	Destination output buffer.
	uCount	Number of bytes to copy.
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1735 of file nmLibPack.c.

References _NM_CHK_MEM.

Referenced by nmPackPointer().

{
  _NM_CHK_MEM(bufSize, uCount);

  // safe copy 
  memmove(bufDst, buf, uCount);

  return (int)uCount;
}

int nmUnpackF32	(	byte_t	buf[],
		size_t	bufSize,
		float *	pVal,
		NMEndian_T	eEndian
	)

Unpack a 32-bit float from the message buffer.

The IEEE 754 32-bit format is used with both the big and little endian byte orders.

Note

On some machines, while integers were represented in little-endian form, floating point numbers were represented in big-endian form. Because there are many floating point formats, and a lack of a standard network representation, no standard for transferring floating point values has been made - Wikipedia.

Todo:

Detect non-IEEE 754 formats and convert to IEEE 754 prior to packing.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1472 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_F32, UNPACKBIG, UNPACKLITTLE, and UNPACKNATIVE.

Referenced by nmPackPointer(), nmUnpackFlatF32(), and nmUnpackITVF32().

{
  static size_t fvalLen = NMFVAL_LEN_F32;     // message field value length

  _NM_CHK_MEM(bufSize, fvalLen);
  _NM_CHK_ARCH(*pVal, fvalLen);

  switch( eEndian )
  {
    case NMEndianLittle:
      UNPACKLITTLE(buf, pVal);
      break;
    case NMEndianNative:
      UNPACKNATIVE(buf, pVal);
      break;
    case NMEndianBig:
    default:
      UNPACKBIG(buf, pVal);
      break;
  }


  return (int)fvalLen;
}

int nmUnpackF64	(	byte_t	buf[],
		size_t	bufSize,
		double *	pVal,
		NMEndian_T	eEndian
	)

Unpack a 64-bit float from the message buffer.

The IEEE 754 64-bit format is used with both the big and little endian byte orders. If the machine architecture only supports 32-bit doubles, then mantissa truncation will occur.

Note

On some machines, while integers were represented in little-endian form, floating point numbers were represented in big-endian form. Because there are many floating point formats, and a lack of a standard network representation, no standard for transferring floating point values has been made - Wikipedia.

Todo:

Detect non-IEEE 754 formats and convert to IEEE 754 prior to packing.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1517 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, IEEE754_F32_EXP_MAX, IEEE754_F32_EXP_MIN, IEEE754_F32_F64_MANTISSA0_SHIFT, IEEE754_F32_F64_MANTISSA1_MASK, IEEE754_F32_F64_MANTISSA1_SHIFT, IEEE754_F32_Inf, IEEE754_F32_MANTISSA_MASK, IEEE754_F32_NaN, IEEE754_F32_Zero, IEEE754_F64_EXPONENT_MASK, IEEE754_F64_EXPONENT_SHIFT, ieee754_f64_is_inf(), ieee754_f64_is_nan(), ieee754_f64_is_zero(), IEEE754_F64_MANTISSA0_MASK, IEEE754_F64_MANTISSA0_SHIFT, IEEE754_F64_MANTISSA1_MASK, IEEE754_F64_MANTISSA1_SHIFT, IEEE754_F64_SIGN_MASK, IEEE754_F64_SIGN_SHIFT, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_F32, NMFVAL_LEN_F64, NMLIB_WARNING, UNPACK64BIG, UNPACK64LITTLE, UNPACK64NATIVE, UNPACKBIG, UNPACKLITTLE, and UNPACKNATIVE.

Referenced by nmPackPointer(), nmUnpackFlatF64(), and nmUnpackITVF64().

{
  static size_t fvalLen = NMFVAL_LEN_F64;     // message field value length

  uint_t                uMSB;       // Most Signifcant Bytes
  uint_t                uLSB;       // Least Signifcant Bytes
  int                   exponent;   // ieee754 unbiased exponent
  union ieee754_float   f;          // 4-byte floating-point number
  union ieee754_double  d;          // 8-byte floating-point number

  _NM_CHK_MEM(bufSize, fvalLen);

  // 8-byte doubles
  if( sizeof(double) == (size_t)NMFVAL_LEN_F64 )
  {
    switch( eEndian )
    {
      case NMEndianLittle:
        UNPACKLITTLE(buf, &d.d);
        break;
      case NMEndianNative:
        UNPACKNATIVE(buf, &d.d);
        break;
      case NMEndianBig:
      default:
        UNPACKBIG(buf, &d.d);
        break;
    }

    *pVal = d.d;
  }

  else // 4-byte doubles
  {
    _NM_CHK_ARCH(*pVal, (size_t)NMFVAL_LEN_F32);

    switch( eEndian )
    {
      case NMEndianLittle:
        UNPACK64LITTLE(buf, &uMSB, &uLSB);
        break;
      case NMEndianNative:
        UNPACK64NATIVE(buf, &uMSB, &uLSB);
        break;
      case NMEndianBig:
      default:
        UNPACK64BIG(buf, &uMSB, &uLSB);
        break;
    }

    d.ieee.negative   = ((uMSB >> IEEE754_F64_SIGN_SHIFT)
                            & IEEE754_F64_SIGN_MASK)? 1: 0;
    d.ieee.exponent   = (uMSB >> IEEE754_F64_EXPONENT_SHIFT)
                            & IEEE754_F64_EXPONENT_MASK;
    d.ieee.mantissa0  = (uMSB >> IEEE754_F64_MANTISSA0_SHIFT)
                            & IEEE754_F64_MANTISSA0_MASK;
    d.ieee.mantissa1  = (uLSB >> IEEE754_F64_MANTISSA1_SHIFT)
                            & IEEE754_F64_MANTISSA1_MASK;

    // unbias the exponent
    exponent  = (int)d.ieee.exponent - IEEE754_DOUBLE_BIAS;

    // special Not-a-Number case
    if( ieee754_f64_is_nan(d) )
    {
      f = IEEE754_F32_NaN;
    }

    // special infinity cases
    else if( ieee754_f64_is_inf(d) )
    {
      f = IEEE754_F32_Inf;
    }

    // exponent overflow
    else if( exponent > IEEE754_F32_EXP_MAX )
    {
      f = IEEE754_F32_Inf;
      NMLIB_WARNING("floating-point number overflow.");
    }

    // exponent overflow
    else if( exponent < IEEE754_F32_EXP_MIN )
    {
      f = IEEE754_F32_Zero;
      NMLIB_WARNING("floating-point number underflow.");
    }

    // special zero cases
    else if( ieee754_f64_is_zero(d) )
    {
      f = IEEE754_F32_Zero;
    }

    // "normal" floating-point numbers
    else
    {
      f.ieee.exponent   = (byte_t)(exponent + IEEE754_FLOAT_BIAS);
      f.ieee.mantissa = ( (uint_t)((d.ieee.mantissa0
                                    & IEEE754_F64_MANTISSA0_MASK)
                                << IEEE754_F32_F64_MANTISSA0_SHIFT)
                        | (uint_t)((d.ieee.mantissa1
                                    >> IEEE754_F32_F64_MANTISSA1_SHIFT)
                                & IEEE754_F32_F64_MANTISSA1_MASK) )
                        & IEEE754_F32_MANTISSA_MASK;
      if( (d.ieee.mantissa1 & (uint_t)~IEEE754_F32_F64_MANTISSA1_MASK) != 0 )
      {
        NMLIB_WARNING("floating-point number mantissa truncation.");
      }
    }

    // preserve the sign
    f.ieee.negative   = d.ieee.negative;

    *pVal = (double)f.f;
  }

  return (int)fvalLen;
}

int nmUnpackP32	(	byte_t	buf[],
		size_t	bufSize,
		void *	pVal,
		NMEndian_T	eEndian
	)

Unpack a 32-bit pointer from the message buffer.

If the machine architecture has 64-bit pointers, then only the LSB 4 bytes are packed.

Note

Pointer is always unpacked in native byte order.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1648 of file nmLibPack.c.

References _NM_CHK_MEM, NMFVAL_LEN_P32, and UNPACKNATIVE.

Referenced by nmPackPointer(), nmUnpackFlatP32(), nmUnpackITVP32(), and nmUnpackPointer().

{
  static size_t fvalLen = NMFVAL_LEN_P32;     // message field value length

  ulong_t  *pluVal;   // longs are same size as pointers on 32/64 bit machines
  uint_t    uP32;

  _NM_CHK_MEM(bufSize, fvalLen);
  
  pluVal = (ulong_t *)pVal;

  UNPACKNATIVE(buf, &uP32);

  *pluVal = (ulong_t)uP32;

  return (int)fvalLen;

}

int nmUnpackP64	(	byte_t	buf[],
		size_t	bufSize,
		void *	pVal,
		NMEndian_T	eEndian
	)

Unpack a 64-bit pointer from the message buffer.

If the machine architecture only supports 32-bit pointers, then the 4 MSBs are padded with 0's.

Note

Pointer is always unpacked in native byte order.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1678 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, NMFVAL_LEN_P32, NMFVAL_LEN_P64, NMLIB_WARNING, and UNPACK64NATIVE.

Referenced by nmPackPointer(), nmUnpackFlatP64(), nmUnpackITVP64(), and nmUnpackPointer().

{
  static size_t fvalLen = NMFVAL_LEN_P64;     // message field value length

  uint_t    uMSB;     // Most Signifcant Bytes
  uint_t    uLSB;     // Least Signifcant Bytes
  ulong_t  *pluVal;   // longs are same size as pointers on 32/64 bit machines

  _NM_CHK_MEM(bufSize, fvalLen);
  
  pluVal = (ulong_t *)pVal;

  UNPACK64NATIVE(buf, &uMSB, &uLSB);

  // 8-byte pointer
  if( sizeof(void *) == fvalLen )
  {
#if HOST_WORD_SIZE == 64
    *pluVal = (ulong_t)(((ulong_t)uMSB  << 32) | (uLSB & 0xffffffff));
#else
    *pluVal = (ulong_t)uLSB;
#endif // HOST_WORD_SIZE
  }

  // 4-byte pointer
  else
  {
    _NM_CHK_ARCH(pVal, (size_t)NMFVAL_LEN_P32);

    if( uMSB != 0 )
    {
      NMLIB_WARNING("0x%08x%08x: Unpacking 64-bit pointer into 32 bits "
                    "lost non-zero significance.\n",
                    uMSB, uLSB);
    }
    *pluVal = (ulong_t)uLSB;
  }

  return (int)fvalLen;
}

int nmUnpackS64	(	byte_t	buf[],
		size_t	bufSize,
		long long *	pVal,
		NMEndian_T	eEndian
	)

Unpack an signed 64-bit integer from the message buffer.

If the machine architecture only supports 32-bit long longs, then the 4 MSBs are truncated.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1391 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_S32, NMFVAL_LEN_S64, NMLIB_WARNING, UNPACK64BIG, UNPACK64LITTLE, UNPACK64NATIVE, UNPACKBIG, UNPACKLITTLE, and UNPACKNATIVE.

Referenced by nmPackPointer(), nmUnpackFlatS64(), nmUnpackITVS64(), nmUnpackLong(), and nmUnpackLongLong().

{
  static size_t fvalLen = NMFVAL_LEN_S64;     // message field value length

  uint_t        uMSB;     // most significant bytes
  uint_t        uLSB;     // least signifcant bytes

  _NM_CHK_MEM(bufSize, fvalLen);

  // 8-byte unsigned long long
  if( sizeof(ulonglong_t) == fvalLen )
  {
    switch( eEndian )
    {
      case NMEndianLittle:
        UNPACKLITTLE(buf, pVal);
        break;
      case NMEndianNative:
        UNPACKNATIVE(buf, pVal);
        break;
      case NMEndianBig:
      default:
        UNPACKBIG(buf, pVal);
        break;
    }
  }

  // 4-byte unsigned long long
  else
  {
    _NM_CHK_ARCH(*pVal, (size_t)NMFVAL_LEN_S32);

    switch( eEndian )
    {
      case NMEndianLittle:
        UNPACK64LITTLE(buf, &uMSB, &uLSB);
        break;
      case NMEndianNative:
        UNPACK64NATIVE(buf, &uMSB, &uLSB);
        break;
      case NMEndianBig:
      default:
        UNPACK64BIG(buf, &uMSB, &uLSB);
        break;
    }

    if( (uMSB != 0) && (uMSB != 0xffffffff) )
    {
      NMLIB_WARNING("0x%08x%08x: Unpacking signed 64-bit integer into "
                    "32 bits lost non-zero significance.",
                    uMSB, uLSB);
    }

    *pVal = (long long)uLSB;
  }

  return (int)fvalLen;
}

int nmUnpackU16	(	byte_t	buf[],
		size_t	bufSize,
		ushort_t *	pVal,
		NMEndian_T	eEndian
	)

Unpack an unsigned 16-bit integer from the message buffer.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1256 of file nmLibPack.c.

References _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_U16, UNPACKBIG, UNPACKLITTLE, and UNPACKNATIVE.

Referenced by nmGetITVMsgId(), nmPackPointer(), nmUnpackFlatU16(), nmUnpackITVMsg(), nmUnpackITVMsgDebug(), nmUnpackITVU16(), nmUnpackS16(), nmUnpackShort(), and nmUnpackUShort().

{
  static size_t fvalLen = NMFVAL_LEN_U16;     // message field value length

  _NM_CHK_MEM(bufSize, fvalLen);

  switch( eEndian )
  {
    case NMEndianLittle:
      UNPACKLITTLE(buf, pVal);
      break;
    case NMEndianNative:
      UNPACKNATIVE(buf, pVal);
      break;
    case NMEndianBig:
    default:
      UNPACKBIG(buf, pVal);
      break;
  }

  return (int)fvalLen;
}

int nmUnpackU32	(	byte_t	buf[],
		size_t	bufSize,
		uint_t *	pVal,
		NMEndian_T	eEndian
	)

Unpack an unsigned 32-bit integer from the message buffer.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1288 of file nmLibPack.c.

References _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_U32, UNPACKBIG, UNPACKLITTLE, and UNPACKNATIVE.

Referenced by nmPackPointer(), nmUnpackFlatU32(), nmUnpackInt(), nmUnpackITVU32(), nmUnpackS32(), nmUnpackUInt(), and nmUnpackULong().

{
  static size_t fvalLen = NMFVAL_LEN_U32;     // message field value length

  _NM_CHK_MEM(bufSize, fvalLen);

  switch( eEndian )
  {
    case NMEndianLittle:
      UNPACKLITTLE(buf, pVal);
      break;
    case NMEndianNative:
      UNPACKNATIVE(buf, pVal);
      break;
    case NMEndianBig:
    default:
      UNPACKBIG(buf, pVal);
      break;
  }

  return (int)fvalLen;
}

int nmUnpackU64	(	byte_t	buf[],
		size_t	bufSize,
		ulonglong_t *	pVal,
		NMEndian_T	eEndian
	)

Unpack an unsigned 64-bit integer from the message buffer.

If the machine architecture only supports 32-bit unsigned long longs, then the 4 MSBs are truncated.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1320 of file nmLibPack.c.

References _NM_CHK_ARCH, _NM_CHK_MEM, NMEndianBig, NMEndianLittle, NMEndianNative, NMFVAL_LEN_U32, NMFVAL_LEN_U64, NMLIB_WARNING, UNPACK64BIG, UNPACK64LITTLE, UNPACK64NATIVE, UNPACKBIG, UNPACKLITTLE, and UNPACKNATIVE.

Referenced by nmPackPointer(), nmUnpackFlatU64(), nmUnpackITVU64(), nmUnpackULong(), and nmUnpackULongLong().

{
  static size_t fvalLen = NMFVAL_LEN_U64;     // message field value length

  uint_t        uMSB;     // most significant bytes
  uint_t        uLSB;     // least signifcant bytes

  _NM_CHK_MEM(bufSize, fvalLen);

  // 8-byte unsigned long long
  if( sizeof(ulonglong_t) == fvalLen )
  {
    switch( eEndian )
    {
      case NMEndianLittle:
        UNPACKLITTLE(buf, pVal);
        break;
      case NMEndianNative:
        UNPACKNATIVE(buf, pVal);
        break;
      case NMEndianBig:
      default:
        UNPACKBIG(buf, pVal);
        break;
    }
  }

  // 4-byte unsigned long long
  else
  {
    _NM_CHK_ARCH(*pVal, (size_t)NMFVAL_LEN_U32);

    switch( eEndian )
    {
      case NMEndianLittle:
        UNPACK64LITTLE(buf, &uMSB, &uLSB);
        break;
      case NMEndianNative:
        UNPACK64NATIVE(buf, &uMSB, &uLSB);
        break;
      case NMEndianBig:
      default:
        UNPACK64BIG(buf, &uMSB, &uLSB);
        break;
    }

    if( uMSB != 0 )
    {
      NMLIB_WARNING("0x%08x%08x: Unpacking unsigned 64-bit integer into "
                    "32 bits lost non-zero significance.",
                    uMSB, uLSB);
    }

    *pVal = (ulonglong_t)uLSB;
  }

  return (int)fvalLen;
}

int nmUnpackU8	(	byte_t	buf[],
		size_t	bufSize,
		byte_t *	pVal,
		NMEndian_T	eEndian
	)

Unpack an unsigned 8-bit byte from the message buffer.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pVal	Pointer to value to unpack (set).
	eEndian	Unpacking order. See NMEndian_T.

Returns

On success, returns the number of bytes unpacked. On error, the appropriate negated netmsgs error code ( < 0) is returned.

Definition at line 1239 of file nmLibPack.c.

References _NM_CHK_MEM, and NMFVAL_LEN_U8.

Referenced by nmPackPointer(), nmUnpackBool(), nmUnpackByte(), nmUnpackChar(), nmUnpackFlatU8(), nmUnpackITVU8(), nmUnpackS8(), and nmUnpackSChar().

{
  static size_t fvalLen = NMFVAL_LEN_U8;      // message field value length

  _NM_CHK_MEM(bufSize, fvalLen);

  *pVal = buf[0];

  return (int)fvalLen;
}

static void packbig ( byte_t *  p, size_t  size, byte_t  buf[]  )

inlinestatic

Pack an element into the message buffer in big-endian byte order.

Big-Endian Host Version

Parameters

[in]	p	Byte pointer to typecasted element to be packed.
	size	Byte size of element to pack.
[out]	buf	Output message buffer.

Definition at line 135 of file nmLibPack.c.

{
  size_t    n = 0;

  // forward copy
  while( n < size )
  {
    buf[n++] = *p++;
  }
}

static void packlittle ( byte_t *  p, size_t  size, byte_t  buf[]  )

inlinestatic

Pack an element into the message buffer in little-endian byte order.

Big-Endian Host Version

Parameters

[in]	p	Byte pointer to typecasted element to be packed.
	size	Byte size of element to pack.
[out]	buf	Output message buffer.

Definition at line 175 of file nmLibPack.c.

{
  size_t    n = 0;
  size_t    k = size - 1;

  // reverse copy
  while( n < size )
  {
    buf[n++] = p[k--];
  }
}

static void unpackbig ( byte_t  buf[], byte_t *  p, size_t  size  )

inlinestatic

Unpack an element from the message buffer in big-endian byte order.

Big-Endian Host Version

Parameters

[in]	buf	Output message buffer.
[out]	p	Byte pointer to typecasted element to be unpacked (set).
	size	Byte size of element to unpack.

Definition at line 155 of file nmLibPack.c.

{
  size_t    n = 0;

  // forward copy
  while( n < size )
  {
    *p++ = buf[n++];
  }
}

static void unpacklittle ( byte_t  buf[], byte_t *  p, size_t  size  )

inlinestatic

Unpack an element from the message buffer in little-endian byte order.

Big-Endian Host Version

Parameters

[in]	buf	Output message buffer.
[out]	p	Byte pointer to typecasted element to be unpacked (set).
	size	Byte size of element to unpack.

Definition at line 196 of file nmLibPack.c.

{
  size_t    n = 0;
  size_t    k = size - 1;

  // reverse copy
  while( n < size )
  {
    p[k--] = buf[n++];
  }
}

Variable Documentation

const union ieee754_float IEEE754_F32_Inf

static

Initial value:

=
{
  .ieee.negative  = 0,
  .ieee.exponent  =  0x000000ff , 
  .ieee.mantissa  = 0
}

± Infinity bit pattern for 32-bit floating-point numbers.

Definition at line 587 of file nmLibPack.c.

Referenced by nmUnpackF64().

const union ieee754_float IEEE754_F32_NaN

static

Initial value:

=
{
  .ieee.negative  = 0,
  .ieee.exponent  =  0x000000ff , 
  .ieee.mantissa  = 0x400000,
}

Not-a-Number bit pattern for 32-bit floating-point numbers.

Definition at line 566 of file nmLibPack.c.

Referenced by nmUnpackF64().

const union ieee754_float IEEE754_F32_Zero

static

Initial value:

=
{
  .ieee.negative  = 0,
  .ieee.exponent  = 0,
  .ieee.mantissa  = 0
}

± 0 bit pattern for 32-bit floating-point numbers.

Definition at line 608 of file nmLibPack.c.

Referenced by nmUnpackF64().

const union ieee754_double IEEE754_F64_Inf

static

Initial value:

=
{
  .ieee.negative  = 0,
  .ieee.exponent  =  0x000007ff , 
  .ieee.mantissa0 = 0,
  .ieee.mantissa1 = 0 
}

± Infinity bit pattern for 64-bit floating-point numbers.

Definition at line 597 of file nmLibPack.c.

Referenced by nmPackF64().

const union ieee754_double IEEE754_F64_NaN

static

Initial value:

=
{
  .ieee.negative  = 0,
  .ieee.exponent  =  0x000007ff , 
  .ieee.mantissa0 = 0x80000,
  .ieee.mantissa1 = 0 
}

Not-a-Number bit pattern for 64-bit floating-point numbers.

Definition at line 576 of file nmLibPack.c.

Referenced by nmPackF64().

const union ieee754_double IEEE754_F64_Zero

static

Initial value:

=
{
  .ieee.negative  = 0,
  .ieee.exponent  = 0,
  .ieee.mantissa0 = 0,
  .ieee.mantissa1 = 0 
}

± 0 bit pattern for 64-bit floating-point numbers.

Definition at line 618 of file nmLibPack.c.

Referenced by nmPackF64().