diff --git a/Makefile.am b/Makefile.am
index b7c7fc9..2788fa2 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -9,8 +9,8 @@ cmSRC += src/libcm/cmErr.c src/libcm/cmCtx.c src/libcm/cmRpt.c src/libcm/cmGloba
 cmHDR += src/libcm/cmSerialize.h src/libcm/cmSymTbl.h src/libcm/cmFileSys.h src/libcm/cmFile.h src/libcm/cmMem.h src/libcm/cmTime.h src/libcm/cmPgmOpts.h
 cmSRC += src/libcm/cmSerialize.c src/libcm/cmSymTbl.c src/libcm/cmFileSys.c src/libcm/cmFile.c src/libcm/cmMem.c src/libcm/cmTime.c src/libcm/cmPgmOpts.c
 
-cmHDR += src/libcm/cmLib.h src/libcm/cmText.h src/libcm/cmTextTemplate.h
-cmSRC += src/libcm/cmLib.c src/libcm/cmText.c src/libcm/cmTextTemplate.c
+cmHDR += src/libcm/cmData.h src/libcm/cmLib.h src/libcm/cmText.h src/libcm/cmTextTemplate.h
+cmSRC += src/libcm/cmData.c src/libcm/cmLib.c src/libcm/cmText.c src/libcm/cmTextTemplate.c
 
 cmHDR += src/libcm/cmMath.h src/libcm/cmGnuPlot.h src/libcm/cmKeyboard.h
 cmSRC += src/libcm/cmMath.c src/libcm/cmGnuPlot.c src/libcm/cmKeyboard.c
diff --git a/cmData.c b/cmData.c
new file mode 100644
index 0000000..39c886e
--- /dev/null
+++ b/cmData.c
@@ -0,0 +1,1006 @@
+#include "cmData.h"
+
+
+cmDtRC_t _cmDataErrNo = kOkDtRC;
+
+void _cmDataFreeArray( cmData_t* p )
+{
+  if(cmIsFlag(p->flags,kDynPtrDtFl))
+  {
+    cmMemFree(p->vp);
+    p->vp    = NULL;
+    p->flags = cmClrFlag(p->flags,kDynPtrFl);
+  }
+  p->tid = cmInvalidDtId;
+  p->cnt = 0;
+}
+
+void _cmDataFree( cmData_t* p )
+{
+  _cmDataFreeArray(p);
+  if( cmIsFlag(p->flags,kDynObjDtFl) )
+    cmMemFree(p);
+}
+
+unsigned _cmDataByteCount( cmData_t* p )
+{
+  unsigned n = sizeof(cmDataSerialHdr_t)
+  switch( p->tid )
+  {
+    case kInvalidDtId:   return 0;
+    case kNullDtId:      return n;
+    case kUCharDtId:     return n + sizeof(unsigned char); 
+    case kCharDtId:      return n + sizeof(char);
+    case kUShortDtId:    return n + sizeof(unsigned short);
+    case kShortDtId:     return n + sizeof(short);
+    case kUIntDtId:      return n + sizeof(unsigned int);
+    case kIntDtId:       return n + sizeof(int);
+    case kULongDtId:     return n + sizeof(unsigned long);
+    case kLongDtId:      return n + sizeof(long);
+    case kFloatDtId:     return n + sizeof(float);
+    case kDoubleDtId:    return n + sizeof(double);
+      
+    case kStrDtId:       return n + (p->u.z ==NULL ? 0 : strlen(p->u.z)  + 1);
+    case kConstStrDtId:  return n + (p->u.cz==NULL ? 0 : strlen(p->u.cz) + 1);
+
+    case kUCharPtrDtId:  return n + p->cnt * sizeof(unsigned char);
+    case kCharPtrDtId:   return n + p->cnt * sizeof(char); 
+    case kUShortPtrDtId: return n + p->cnt * sizeof(unsigned short);
+    case kShortPtrDtId:  return n + p->cnt * sizeof(short);
+    case kUIntPtrDtId:   return n + p->cnt * sizeof(unsigned int);
+    case kIntPtrDtId:    return n + p->cnt * sizeof(int);
+    case kULongPtrDtId:  return n + p->cnt * sizeof(unsigned long);
+    case kLongPtrDtId:   return n + p->cnt * sizeof(long);
+    case kFloatPtrDtId:  return n + p->cnt * sizeof(float);
+    case kDoublePtrDtId: return n + p->cnt * sizeof(double);
+    case kVoidPtrDtId:   return n + p->cnt * sizeof(char);
+  }
+  assert(0);
+  return 0;
+}
+
+char            cmDataChar(      const cmData_t* p ) { assert(p->tid==kCharDtId);      p->u.c; }
+unsigned char   cmDataUChar(     const cmData_t* p ) { assert(p->tid==kUCharDtId);     p->u.uc; } 
+short           cmDataShort(     const cmData_t* p ) { assert(p->tid==kShortDtId);     p->u.s; } 
+unsigned short  cmDataUShort(    const cmData_t* p ) { assert(p->tid==kUShortDtId);    p->u.us; } 
+int             cmDataInt(       const cmData_t* p ) { assert(p->tid==kIntDtId);       p->u.i; } 
+unsigned int    cmDataUInt(      const cmData_t* p ) { assert(p->tid==kUIntDtId);      p->u.ui; } 
+long            cmDataLong(      const cmData_t* p ) { assert(p->tid==kLongDtId);      p->u.l; } 
+unsigned long   cmDataULong(     const cmData_t* p ) { assert(p->tid==kULongDtId);     p->u.ul; } 
+float           cmDataFloat(     const cmData_t* p ) { assert(p->tid==kFloatDtId);     p->u.f; } 
+double          cmDataDouble(    const cmData_t* p ) { assert(p->tid==kDoubleDtId);    p->u.d; } 
+cmChar_t*       cmDataStr(       const cmData_t* p ) { assert(p->tid==kStrDtId);       p->u.z; } 
+const cmChar_t* cmDataConstStr(  const cmData_t* p ) { assert(p->tid==kConstStrDtId);  p->u.cz; } 
+void*           cmDataVoidPtr(   const cmData_t* p ) { assert(p->tid==kVoidDtId);      p->u.vp; }
+char*           cmDataCharPtr(   const cmData_t* p ) { assert(p->tid==kCharPtrDtId);   p->u.cp; } 
+unsigned char*  cmDataUCharPtr(  const cmData_t* p ) { assert(p->tid==kUCharPtrDtId);  p->u.ucp; } 
+short*          cmDataShortPtr(  const cmData_t* p ) { assert(p->tid==kShortPtrDtId);  p->u.sp; } 
+unsigned short* cmDataUShortPtr( const cmData_t* p ) { assert(p->tid==kUShortPtrDtId); p->u.usp; } 
+int*            cmDataIntPtr(    const cmData_t* p ) { assert(p->tid==kIntPtrDtId);    p->u.ip; } 
+unsigned int*   cmDataUIntPtr(   const cmData_t* p ) { assert(p->tid==kUIntPtrDtId);   p->u.uip; } 
+long*           cmDataLongPtr(   const cmData_t* p ) { assert(p->tid==kLongPtrDtId);   p->u.lp; } 
+unsigned long*  cmDataULongPtr(  const cmData_t* p ) { assert(p->tid==kULongPtrDtId);  p->u.ulp; } 
+float*          cmDataFloatPtr(  const cmData_t* p ) { assert(p->tid==kFloatPtrDtId);  p->u.fp; } 
+double*         cmDataDoublePtr( const cmData_t* p ) { assert(p->tid==kDoublePtrDtId); p->u.dp; } 
+
+unsigned char   cmDataGetUChar(     const cmData_t* p )
+{
+  unsigned char v = kInvalidUChar;
+
+  switch( p->tid )
+  {
+    case kUCharDtId:  v =                p->u.uc; break;
+    case kCharDtId:   v = (unsigned char)p->u.c;  break;
+    case kUShortDtId: v = (unsigned char)p->u.us; break;
+    case kShortDtId:  v = (unsigned char)p->u.s;  break;
+    case kUIntDtId:   v = (unsigned char)p->u.ui; break;
+    case kIntDtId:    v = (unsigned char)p->u.i;  break;
+    case kULongDtId:  v = (unsigned char)p->u.ul; break;
+    case kLongDtId:   v = (unsigned char)p->u.l;  break;
+    case kFloatDtId:  v = (unsigned char)p->u.f;  break;
+    case kDoubleDtId: v = (unsigned char)p->u.d;  break;
+    default:
+      _cmDataErrNo = kCvtErrDtRC;
+  }
+  return v;
+}
+
+char  cmDataGetChar( const cmData_t* p )
+{
+  char v = kInvalidChar;
+
+  switch( p->tid )
+  {
+    case kUCharDtId:  v = (char)p->u.uc; break;
+    case kCharDtId:   v =       p->u.c;  break;
+    case kUShortDtId: v = (char)p->u.us; break;
+    case kShortDtId:  v = (char)p->u.s;  break;
+    case kUIntDtId:   v = (char)p->u.ui; break;
+    case kIntDtId:    v = (char)p->u.i;  break;
+    case kULongDtId:  v = (char)p->u.ul; break;
+    case kLongDtId:   v = (char)p->u.l;  break;
+    case kFloatDtId:  v = (char)p->u.f;  break;
+    case kDoubleDtId: v = (char)p->u.d;  break;
+    default:
+      _cmDataErrNo = kCvtErrDtRC;
+  }
+  return v;
+}
+
+short           cmDataGetShort(     const cmData_t* p )
+{
+  short v = kInvalidShort;
+
+  switch( p->tid )
+  {
+    case kUCharDtId:  v = (short)p->u.uc; break;
+    case kCharDtId:   v = (short)p->u.c;  break;
+    case kUShortDtId: v = (short)p->u.us; break;
+    case kShortDtId:  v =        p->u.s;  break;
+    case kUIntDtId:   v = (short)p->u.ui; break;
+    case kIntDtId:    v = (short)p->u.i;  break;
+    case kULongDtId:  v = (short)p->u.ul; break;
+    case kLongDtId:   v = (short)p->u.l;  break;
+    case kFloatDtId:  v = (short)p->u.f;  break;
+    case kDoubleDtId: v = (short)p->u.d;  break;
+    default:
+      _cmDataErrNo = kCvtErrDtRC;
+  }
+
+  return v;
+}
+
+
+unsigned short  cmDataGetUShort(    const cmData_t* p )
+{
+  unsigned short v = kInvalidUShort;
+
+  switch( p->tid )
+  {
+    case kUCharDtId:  v = (unsigned short)p->u.uc; break;
+    case kCharDtId:   v = (unsigned short)p->u.c;  break;
+    case kUShortDtId: v =                 p->u.us; break;
+    case kShortDtId:  v = (unsigned short)p->u.s;  break;
+    case kUIntDtId:   v = (unsigned short)p->u.ui; break;
+    case kIntDtId:    v = (unsigned short)p->u.i;  break;
+    case kULongDtId:  v = (unsigned short)p->u.ul; break;
+    case kLongDtId:   v = (unsigned short)p->u.l;  break;
+    case kFloatDtId:  v = (unsigned short)p->u.f;  break;
+    case kDoubleDtId: v = (unsigned short)p->u.d;  break;
+    default:
+      _cmDataErrNo = kCvtErrDtRC;
+  }
+
+  return v;
+}
+
+int             cmDataGetInt(       const cmData_t* p )
+{
+  int v = kInvalidInt;
+
+  switch( p->tid )
+  {
+    case kUCharDtId:  v = (int)p->u.uc; break;
+    case kCharDtId:   v = (int)p->u.c;  break;
+    case kUShortDtId: v = (int)p->u.us; break;
+    case kShortDtId:  v = (int)p->u.s;  break;
+    case kUIntDtId:   v = (int)p->u.ui; break;
+    case kIntDtId:    v =      p->u.i;  break;
+    case kULongDtId:  v = (int)p->u.ul; break;
+    case kLongDtId:   v = (int)p->u.l;  break;
+    case kFloatDtId:  v = (int)p->u.f;  break;
+    case kDoubleDtId: v = (int)p->u.d;  break;
+    default:
+      _cmDataErrNo = kCvtErrDtRC;
+  }
+
+  return v;
+}
+
+unsigned int    cmDataGetUInt(      const cmData_t* p )
+{
+  unsigned int v = kInvalidUInt;
+
+  switch( p->tid )
+  {
+    case kUCharDtId:  v = (unsigned int)p->u.uc; break;
+    case kCharDtId:   v = (unsigned int)p->u.c;  break;
+    case kUShortDtId: v = (unsigned int)p->u.us; break;
+    case kShortDtId:  v = (unsigned int)p->u.s;  break;
+    case kUIntDtId:   v =               p->u.ui; break;
+    case kIntDtId:    v = (unsigned int)p->u.i;  break;
+    case kULongDtId:  v = (unsigned int)p->u.ul; break;
+    case kLongDtId:   v = (unsigned int)p->u.l;  break;
+    case kFloatDtId:  v = (unsigned int)p->u.f;  break;
+    case kDoubleDtId: v = (unsigned int)p->u.d;  break;
+    default:
+      _cmDataErrNo = kCvtErrDtRC;
+  }
+
+  return v;
+}
+
+long            cmDataGetLong(      const cmData_t* p )
+{
+  long v = kInvalidLong;
+
+  switch( p->tid )
+  {
+    case kUCharDtId:  v = (long)p->u.uc; break;
+    case kCharDtId:   v = (long)p->u.c;  break;
+    case kUShortDtId: v = (long)p->u.us; break;
+    case kShortDtId:  v = (long)p->u.s;  break;
+    case kUIntDtId:   v = (long)p->u.ui; break;
+    case kIntDtId:    v = (long)p->u.i;  break;
+    case kULongDtId:  v = (long)p->u.ul; break;
+    case kLongDtId:   v =       p->u.l;  break;
+    case kFloatDtId:  v = (long)p->u.f;  break;
+    case kDoubleDtId: v = (long)p->u.d;  break;
+    default:
+      _cmDataErrNo = kCvtErrDtRC;
+  }
+
+  return v;
+}
+
+unsigned long   cmDataGetULong(     const cmData_t* p )
+{
+  unsigned long v = kInvalidULong;
+
+  switch( p->tid )
+  {
+    case kUCharDtId:  v = (unsigned long)p->u.uc; break;
+    case kCharDtId:   v = (unsigned long)p->u.c;  break;
+    case kUShortDtId: v = (unsigned long)p->u.us; break;
+    case kShortDtId:  v = (unsigned long)p->u.s;  break;
+    case kUIntDtId:   v = (unsigned long)p->u.ui; break;
+    case kIntDtId:    v = (unsigned long)p->u.i;  break;
+    case kULongDtId:  v =                p->u.ul; break;
+    case kLongDtId:   v = (unsigned long)p->u.l;  break;
+    case kFloatDtId:  v = (unsigned long)p->u.f;  break;
+    case kDoubleDtId: v = (unsigned long)p->u.d;  break;
+    default:
+      _cmDataErrNo = kCvtErrDtRC;
+  }
+
+  return v;
+}
+
+float           cmDataGetFloat(     const cmData_t* p )
+{
+  float v = kInvalidChar;
+
+  switch( p->tid )
+  {
+    case kUCharDtId:  v = (float)p->u.uc; break;
+    case kCharDtId:   v = (float)p->u.c;  break;
+    case kUShortDtId: v = (float)p->u.us; break;
+    case kShortDtId:  v = (float)p->u.s;  break;
+    case kUIntDtId:   v = (float)p->u.ui; break;
+    case kIntDtId:    v = (float)p->u.i;  break;
+    case kULongDtId:  v = (float)p->u.ul; break;
+    case kLongDtId:   v = (float)p->u.l;  break;
+    case kFloatDtId:  v =        p->u.f;  break;
+    case kDoubleDtId: v = (float)p->u.d;  break;
+    default:
+      _cmDataErrNo = kCvtErrDtRC;
+  }
+
+  return v;
+}
+
+double          cmDataGetDouble(    const cmData_t* p )
+{
+  double v = kInvalidChar;
+
+  switch( p->tid )
+  {
+    case kUCharDtId:  v = (double)p->u.uc; break;
+    case kCharDtId:   v = (double)p->u.c;  break;
+    case kUShortDtId: v = (double)p->u.us; break;
+    case kShortDtId:  v = (double)p->u.s;  break;
+    case kUIntDtId:   v = (double)p->u.ui; break;
+    case kIntDtId:    v = (double)p->u.i;  break;
+    case kULongDtId:  v = (double)p->u.ul; break;
+    case kLongDtId:   v = (double)p->u.l;  break;
+    case kFloatDtId:  v = (double)p->u.f;  break;
+    case kDoubleDtId: v =         p->u.d;  break;
+    default:
+      _cmDataErrNo = kCvtErrDtRC;
+  }
+
+  return v;
+}
+
+cmChar_t*       cmDataGetStr(       const cmData_t* p )
+{ 
+  assert( p->tid == kStrDtId || p->tid == kConstStrDtId); 
+  return (p->tid == kStrDtId || p->tid == kConstStrDtId) ? p->u.z : NULL; 
+}
+
+const cmChar_t* cmDataGetConstStr(  const cmData_t* p )
+{ 
+  assert( p->tid == kStrDtId || p->tid == kConstStrDtId); 
+  return (p->tid == kStrDtId || p->tid == kConstStrDtId) ? p->u.cz : NULL; 
+}
+
+void*           cmDataGetVoidPtr(   const cmData_t* p )
+{ return cmDataVoidPtr(p); }
+
+void*           cmDataGetVoidPtr(   const cmData_t* p )
+{
+  assert( kMinPtrDtId <= p->tid && p->tid <= kMaxPtrDtId );
+  return ( kMinPtrDtId <= p->tid && p->tid <= kMaxPtrDtId ) ? p->u.vp : NULL;  
+}
+
+char*           cmDataGetCharPtr(   const cmData_t* p )
+{ 
+  assert( p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId );
+  return (p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId) ? p->u.cp : NULL; 
+}
+
+unsigned char*  cmDataGetUCharPtr(  const cmData_t* p )
+{ 
+  assert( p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId );
+  return (p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId) ? p->u.ucp : NULL; 
+}
+
+short*          cmDataGetShortPtr(  const cmData_t* p )
+{ 
+  assert( p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId );
+  return (p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId ) ? p->u.sp : NULL; 
+}
+
+unsigned short* cmDataGetUShortPtr( const cmData_t* p )
+{
+  assert( p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId );
+  return (p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId ) ? p->u.usp : NULL; 
+}
+
+int*            cmDataGetIntPtr(    const cmData_t* p )
+{
+  assert( p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId );
+  return (p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId ) ? p->u.ip : NULL; 
+}
+
+unsigned int*   cmDataGetUIntPtr(   const cmData_t* p )
+{
+  assert( p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId );
+  return (p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId ) ? p->u.uip : NULL; 
+}
+
+long*           cmDataGetLongPtr(   const cmData_t* p )
+{
+  assert( p->tid == kLongPtrDtId || p->tid == kULongPtrDtId );
+  return (p->tid == kLongPtrDtId || p->tid == kULongPtrDtId ) ? p->u.lp : NULL; 
+}
+
+unsigned long*  cmDataGetULongPtr(  const cmData_t* p )
+{
+  assert( p->tid == kLongPtrDtId || p->tid == kULongPtrDtId );
+  return (p->tid == kLongPtrDtId || p->tid == kULongPtrDtId ) ? p->u.ulp : NULL; 
+}
+
+float*          cmDataGetFloatPtr(  const cmData_t* p )
+{ return p->tid == kFloatPtrDtId ? p->u.fp : NULL; }
+
+double*         cmDataGetDoublePtr( const cmData_t* p )
+{ return p->tid == kDoublePtrDtId ? p->u.dp : NULL; }
+
+  // Set the value of an existing data object.
+void cmDataSetChar(      cmData_t* p, char v )
+{
+  _cmDataFreeArray(p);
+  p->tid = kCharDtId;
+  p->u.c = v;
+}
+
+void cmDataSetUChar(     cmData_t* p, unsigned char v )
+{
+  _cmDataFreeArray(p);
+  p->tid = kUCharDtId;
+  p->u.uc = v;
+}
+
+void cmDataSetShort(     cmData_t* p, short v )
+{
+  _cmDataFreeArray(p);
+  p->tid = kShortDtId;
+  p->u.s = v;
+}
+void cmDataSetUShort(    cmData_t* p, unsigned short v )
+{
+  _cmDataFreeArray(p);
+  p->tid = kUShortDtId;
+  p->u.us = v;
+}
+void cmDataSetInt(       cmData_t* p, int v )
+{
+  _cmDataFreeArray(p);
+  p->tid = kCharDtId;
+  p->u.c = v;
+}
+void cmDataSetUInt(      cmData_t* p, unsigned int v )
+{
+  _cmDataFreeArray(p);
+  p->tid = kUIntDtId;
+  p->u.ui = v;
+}
+void cmDataSetLong(      cmData_t* p, long v )
+{
+  _cmDataFreeArray(p);
+  p->tid = kLongDtId;
+  p->u.l = v;
+}
+void cmDataSetULong(     cmData_t* p, unsigned long v )
+{
+  _cmDataFreeArray(p);
+  p->tid = kULongDtId;
+  p->u.ul = v;
+}
+void cmDataSetFloat(     cmData_t* p, float v )
+{
+  _cmDataFreeArray(p);
+  p->tid = kFloatDtId;
+  p->u.f = v;
+}
+void cmDataSetDouble(    cmData_t* p, double v )
+{
+  _cmDataFreeArray(p);
+  p->tid = kDoubleDtId;
+  p->u.d = v;
+}
+
+void cmDataSetStr(       cmData_t* p, cmChar_t* s )
+{
+  _cmDataFreeArray(p);
+  p->tid = kStrDtId;
+  p->u.z = s;
+}
+
+void cmDataSetConstStr(  cmData_t* p, const cmChar_t* s )
+{
+  _cmDataFreeArray(p);
+  p->tid = kConstStrDtId;
+  p->u.cz = s;
+}
+
+// Set the value of an existing data object to an external array.
+// The array is not copied.
+void cmDataSetVoidPtr(   cmData_t* p, void* vp,          unsigned cnt )
+{
+  cmDataSetCharPtr(p,(char*),cnt);  
+}
+
+void cmDataSetCharPtr(   cmData_t* p, char* vp,          unsigned cnt )
+{
+  _cmDataFreeArray(p);
+  p->tid  = kCharPtrDtId;
+  p->u.cp = vp;
+  p->cnt  = cnt;
+}
+
+void cmDataSetUCharPtr(  cmData_t* p, unsigned char* vp,  unsigned cnt )
+{
+  _cmDataFreeArray(p);
+  p->tid  = kUCharPtrDtId;
+  p->u.ucp = vp;
+  p->cnt  = cnt;
+}
+
+void cmDataSetShortPtr(  cmData_t* p, short* vp,          unsigned cnt )
+{
+  _cmDataFreeArray(p);
+  p->tid  = kShortPtrDtId;
+  p->u.sp = vp;
+  p->cnt  = cnt;
+}
+
+void cmDataSetUShortPtr( cmData_t* p, unsigned short* vp, unsigned cnt )
+{
+  _cmDataFreeArray(p);
+  p->tid   = kUShortPtrDtId;
+  p->u.usp = vp;
+  p->cnt   = cnt;
+}
+
+void cmDataSetIntPtr(    cmData_t* p, int* vp,            unsigned cnt )
+{
+  _cmDataFreeArray(p);
+  p->tid  = kCharPtrDtId;
+  p->u.cp = vp;
+  p->cnt  = cnt;
+}
+
+void cmDataSetUIntPtr(   cmData_t* p, unsigned int* vp,   unsigned cnt )
+{
+  _cmDataFreeArray(p);
+  p->tid   = kUIntPtrDtId;
+  p->u.uip = vp;
+  p->cnt   = cnt;
+}
+
+void cmDataSetLongPtr(   cmData_t* p, long* vp,           unsigned cnt )
+{
+  _cmDataFreeArray(p);
+  p->tid  = kLongPtrDtId;
+  p->u.lp = vp;
+  p->cnt  = cnt;
+}
+
+void cmDataSetULongPtr(  cmData_t* p, unsigned long* vp,  unsigned cnt )
+{
+  _cmDataFreeArray(p);
+  p->tid   = kULongPtrDtId;
+  p->u.ulp = vp;
+  p->cnt   = cnt;
+}
+
+void cmDataSetFloatPtr(  cmData_t* p, float* vp,          unsigned cnt )
+{
+  _cmDataFreeArray(p);
+  p->tid  = kFloatPtrDtId;
+  p->u.fp = vp;
+  p->cnt  = cnt;
+}
+
+void cmDataSetDoublePtr( cmData_t* p, double* vp,         unsigned cnt )
+{
+  _cmDataFreeArray(p);
+  p->tid  = kDoublePtrDtId;
+  p->u.dp = vp;
+  p->cnt  = cnt;
+}
+
+// Set the value of an existing array based data object. 
+// Allocate the internal array and copy the array into it.
+void cmDataSetStrAlloc( cmData_t* p, const cmChar_t* s )
+{
+  if( cmIsFlag(p->flags,kDynPtrDtFl) )
+    cmMemResizeStr(p->u.z,s);
+  else
+  {
+    _cmDataFreeArray(p);
+    cmMemAllocStr(p->u.z,s);
+  }
+  p->tid    = kStrDtId;
+  p->flags  = cmSetFlag(p->flags,kDynPtrDtFl);
+}
+
+void cmDataSetConstStrAlloc(  cmData_t* p, const cmChar_t* s )
+{ cmDataSetStrAlloc(p,s); }
+
+void cmDataSetVoidAllocPtr(   cmData_t* p, const void* vp, unsigned cnt )
+{ cmDataSetCharAllocPtr(p,(char*)vp,cnt); }
+
+void cmDataSetCharAllocPtr(  cmData_t* p, const char* vp,  unsigned cnt )
+{
+  if( cmIsFlag(p->flags,kDynPtrDtFl) )
+    cmMemResize(char, p->u.ucp, cnt );
+  else
+  {
+    _cmDataFreeArray(p);
+    p->u.ucp = cmMemAlloc(char, cnt );
+  }
+  p->tid   = kCharPtrDtId;
+  p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
+}
+
+void cmDataSetUCharAllocPtr(  cmData_t* p, const unsigned char* vp,  unsigned cnt )
+{
+  if( cmIsFlag(p->flags,kDynPtrDtFl) )
+    cmMemResize(unsigned char, p->u.ucp, cnt );
+  else
+  {
+    _cmDataFreeArray(p);
+    p->u.ucp = cmMemAlloc(unsigned char, cnt );
+  }
+  p->tid   = kUCharPtrDtId;
+  p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
+}
+
+void cmDataSetShortAllocPtr(  cmData_t* p, const short* vp,          unsigned cnt )
+{
+  if( cmIsFlag(p->flags,kDynPtrDtFl) )
+    cmMemResize(short, p->u.ucp, cnt );
+  else
+  {
+    _cmDataFreeArray(p);
+    p->u.ucp = cmMemAlloc(short, cnt );
+  }
+  p->tid   = kShortPtrDtId;
+  p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
+}
+
+void cmDataSetUShortAllocPtr( cmData_t* p, const unsigned short* vp, unsigned cnt )
+{
+  if( cmIsFlag(p->flags,kDynPtrDtFl) )
+    cmMemResize(unsigned short, p->u.ucp, cnt );
+  else
+  {
+    _cmDataFreeArray(p);
+    p->u.ucp = cmMemAlloc(unsigned short, cnt );
+  }
+  p->tid   = kUShortPtrDtId;
+  p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
+}
+
+void cmDataSetIntAllocPtr(    cmData_t* p, const int* vp,            unsigned cnt )
+{
+  if( cmIsFlag(p->flags,kDynPtrDtFl) )
+    cmMemResize(int, p->u.ucp, cnt );
+  else
+  {
+    _cmDataFreeArray(p);
+    p->u.ucp = cmMemAlloc(int, cnt );
+  }
+  p->tid   = kIntPtrDtId;
+  p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
+}
+
+void cmDataSetUIntAllocPtr(   cmData_t* p, const unsigned int* vp,   unsigned cnt )
+{
+  if( cmIsFlag(p->flags,kDynPtrDtFl) )
+    cmMemResize(unsigned int, p->u.ucp, cnt );
+  else
+  {
+    _cmDataFreeArray(p);
+    p->u.ucp = cmMemAlloc(unsigned int, cnt );
+  }
+  p->tid   = kUIntPtrDtId;
+  p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
+}
+
+
+void cmDataSetLongAllocPtr(   cmData_t* p, const long* vp,           unsigned cnt )
+{
+  if( cmIsFlag(p->flags,kDynPtrDtFl) )
+    cmMemResize(long, p->u.ucp, cnt );
+  else
+  {
+    _cmDataFreeArray(p);
+    p->u.ucp = cmMemAlloc(long, cnt );
+  }
+  p->tid   = kLongPtrDtId;
+  p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
+}
+
+
+void cmDataSetULongAllocPtr(  cmData_t* p, const unsigned long* vp,  unsigned cnt )
+{
+  if( cmIsFlag(p->flags,kDynPtrDtFl) )
+    cmMemResize(unsigned long, p->u.ucp, cnt );
+  else
+  {
+    _cmDataFreeArray(p);
+    p->u.ucp = cmMemAlloc(unsigned long, cnt );
+  }
+  p->tid   = kULongPtrDtId;
+  p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
+}
+
+
+void cmDataSetFloatAllocPtr(  cmData_t* p, const float* vp,          unsigned cnt )
+{
+  if( cmIsFlag(p->flags,kDynPtrDtFl) )
+    cmMemResize(float, p->u.ucp, cnt );
+  else
+  {
+    _cmDataFreeArray(p);
+    p->u.ucp = cmMemAlloc(float, cnt );
+  }
+  p->tid   = kFloatPtrDtId;
+  p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
+}
+
+
+void cmDataSetDoubleAllocPtr( cmData_t* p, const double* vp,         unsigned cnt )
+{
+  if( cmIsFlag(p->flags,kDynPtrDtFl) )
+    cmMemResize(double, p->u.ucp, cnt );
+  else
+  {
+    _cmDataFreeArray(p);
+    p->u.ucp = cmMemAlloc(double, cnt );
+  }
+  p->tid   = kDoublePtrDtId;
+  p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
+}
+
+  
+
+  // Dynamically allocate a data object and set it's value.
+cmData_t* cmDataAllocChar(   char v )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetChar(p,v);
+  return p;
+}
+
+cmData_t* cmDataAllocUChar(  unsigned char v )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetUChar(p,v);
+  return p;
+}
+
+cmData_t* cmDataAllocShort(  short v )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetShort(p,v);
+  return p;
+}
+
+cmData_t* cmDataAllocUShort( unsigned short v )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetUShort(p,v);
+  return p;
+}
+
+cmData_t* cmDataAllocInt(    int v )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetInt(p,v);
+  return p;
+}
+
+cmData_t* cmDataAllocUInt(   unsigned int v )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetUInt(p,v);
+  return p;
+}
+
+cmData_t* cmDataAllocLong(   long v )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetLong(p,v);
+  return p;
+}
+
+cmData_t* cmDataAllocULong(  unsigned long v )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetULong(p,v);
+  return p;
+}
+
+cmData_t* cmDataAllocFloat(  float v )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetFloat(p,v);
+  return p;
+}
+
+cmData_t* cmDataAllocDouble( double v )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetDouble(p,v);
+  return p;
+}
+
+
+cmData_t* cmDataAllocStr( cmChar_t* str )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetStr(p,v);
+  return p;
+}
+
+cmData_t* cmDataAllocConstStr( const cmChar_t* str )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetConstStr(p,v);
+  return p;
+}
+
+// Dynamically allocate a data object and set its array value to an external
+// array. The data is not copied.
+cmData_t* cmDataAllocVoidPtr(   const void* v,           unsigned cnt );
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetCharPtr(p,(const char*)v,cnt);
+  return p;
+}
+
+cmData_t* cmDataAllocCharPtr(   const char* v,           unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetCharPtr(p,v,cnt);
+  return p;
+}
+
+  cmData_t* cmDataAllocUCharPtr(  const unsigned char* v,  unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetUCharPtr(p,v,cnt);
+  return p;
+}
+
+  cmData_t* cmDataAllocShortPtr(  const short* v,          unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetShortPtr(p,v,cnt);
+  return p;
+}
+
+  cmData_t* cmDataAllocUShortPtr( const unsigned short* v, unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetUShortPtr(p,v,cnt);
+  return p;
+}
+
+  cmData_t* cmDataAllocIntPtr(    const int* v,            unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetIntPtr(p,v,cnt);
+  return p;
+}
+
+  cmData_t* cmDataAllocUIntPtr(   const unsigned int* v,   unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetUIntPtr(p,v,cnt);
+  return p;
+}
+
+  cmData_t* cmDataAllocLongPtr(   const long* v,           unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetLongPtr(p,v,cnt);
+  return p;
+}
+
+  cmData_t* cmDataAllocULongPtr(  const unsigned long* v,  unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetULongPtr(p,v,cnt);
+  return p;
+}
+
+  cmData_t* cmDataAllocFloatPtr(  const float* v,          unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetFloatPtr(p,v,cnt);
+  return p;
+}
+
+  cmData_t* cmDataAllocDoublePtr( const double* v,         unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetDoublePtr(p,v,cnt);
+  return p;
+}
+
+
+
+// Dynamically allocate a data object and its array value.  
+// v[cnt] is copied into the allocated array.
+cmData_t* cmDataVoidAllocPtr(   const void* v,           unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetCharAllocPtr(p, (const char*)v, cnt );
+  return p;
+}
+
+cmData_t* cmDataCharAllocPtr(   const char* v,           unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetCharAllocPtr(p, v, cnt );
+  return p;
+}
+
+cmData_t* cmDataUCharAllocPtr(  const unsigned char* v,  unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetUCharAllocPtr(p, v, cnt );
+  return p;
+}
+
+cmData_t* cmDataShortAllocPtr(  const short* v,          unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetShortAllocPtr(p, v, cnt );
+  return p;
+}
+
+cmData_t* cmDataUShortAllocPtr( const unsigned short* v, unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetUShortAllocPtr(p, v, cnt );
+  return p;
+}
+
+cmData_t* cmDataIntAllocPtr(    const int* v,            unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetIntAllocPtr(p, v, cnt );
+  return p;
+}
+
+cmData_t* cmDataUIntAllocPtr(   const unsigned int* v,   unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetUIntAllocPtr(p, v, cnt );
+  return p;
+}
+
+cmData_t* cmDataLongAllocPtr(   const long* v,           unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetLongAllocPtr(p, v, cnt );
+  return p;
+}
+
+cmData_t* cmDataULongAllocPtr(  const unsigned long* v,  unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetULongAllocPtr(p, v, cnt );
+  return p;  
+}
+
+cmData_t* cmDataFloatAllocPtr(  const float* v,          unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetFloatAllocPtr(p, v, cnt );
+  return p;  
+}
+
+cmData_t* cmDataDoubleAllocPtr( const double* v,         unsigned cnt )
+{
+  cmData_t* p = cmMemAllocZ(cmData_t,1);
+  cmDataSetDoubleAllocPtr(p, v, cnt );
+  return p;  
+}
+
+
+void cmDataFree( cmData_t* p )
+{
+  _cmDataFree(p);
+}
+
+  
+  
+unsigned cmDataSerializeByteCount( const cmData_t* p )
+{
+  unsigned bn = 0;
+
+  // if this data type has a child then calculate it's size
+  if( kMinStructDtId <= p->tid && p->tid <= kMaxStructDtId && p->u.child != NULL )
+    bn = cmDataSerializeByteCount(p->child);
+  
+  // if this data type has siblings get their type
+  cmData_t* dp = p->u.child;
+  for(; dp != NULL; dp=dp->sibling )
+    bn += cmDataSerializeByteCount(dp->sibling);
+    
+  // 
+  return  _cmDataByteCount(p) + bn;
+}
+
+typedef struct
+{
+  cmDataFmtId_t tid;
+  unsigned      cnt;
+} cmDataSerialHdr_t;
+
+
+cmDtRC_t cmDataSerialize( const cmData_t* p, void* buf, unsigned bufByteCnt )
+{
+}
+
+cmDtRC_t cmDataDeserialize( const void* buf, unsigned bufByteCnt, cmData_t** pp )
+{
+}
+
+void     cmDataPrint( const cmData_t* p, cmRpt_t* rpt )
+{
+}
+
+void     cmDataTest( cmCtx_t* ctx )
+{
+}
+
+
diff --git a/cmData.h b/cmData.h
new file mode 100644
index 0000000..b0c720b
--- /dev/null
+++ b/cmData.h
@@ -0,0 +1,281 @@
+#ifndef cmData_h
+#define cmData_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  enum
+  {
+    kOkDtRC = cmOkRC,
+    kCvtErrDtRC
+  };
+
+  enum
+  {
+    kInvalidDtChar  = 0xff,
+    kInvalidDtUChar = 0xff,
+    kInvalidDtShort = 0xffff,
+    kInvalidDtUShort = 0xffff,
+    kInvalidDtInt    = 0xffffffff,
+    kInvalidDtUInt   = 0xffffffff,
+    kInvalidDtLong   = 0xffffffff,
+    kInvalidDtULong  = 0xffffffff,    
+  };
+
+  typedef enum
+  {
+    kInvalidDtId,
+
+    kNullDtId,
+
+    kUCharDtId,
+    kCharDtId,
+    kUShortDtId,
+    kShortDtId,
+    kUIntDtId,
+    kIntDtId,
+    kULongDtId,
+    kLongDtId,
+    kFloatDtId,
+    kDoubleDtId,
+
+    kStrDtId,
+    kConstStrDtId,
+
+    kMinPtrDtId,
+    kUCharPtrDtId = kMinPtrDtId,  // cnt=array element count
+    kCharPtrDtId,
+    kUShortPtrDtId,
+    kShortPtrDtId,
+    kUIntPtrDtId,
+    kIntPtrDtId,
+    kULongPtrDtId,
+    kLongPtrDtId,
+    kFloatPtrDtId,
+    kDoublePtrDtId,
+    kVoidPtrDtId,
+    kMaxPtrDtId = kVoidPtrDtId,
+
+    kMinStructDtId,
+    kListDtId = kMinStructDtId, // children nodes are array elements, cnt=child count
+    kPairDtId,                  // key/value pairs, cnt=2, first child is key, second is value
+    kRecordDtId,                // children nodes are pairs, cnt=pair count
+    kMaxStructDtId
+
+  } cmDataFmtId_t;
+
+  enum
+  {
+    kDynObjDtFl = 0x01,  // object was dynamically allocated
+    kDynPtrDtFl = 0x02   // ptr array was dynamically allocated
+  };
+
+  typedef struct cmData_str
+  {
+    cmDataFmtId_t      tid;       // data format id
+    unsigned           flags;     // 
+    struct cmData_str* parent;    // this childs parent
+    struct cmData_str* sibling;   // this childs sibling
+    unsigned           allocCnt;  // allocated count
+    unsigned           cnt;       // actual count
+
+    union
+    {
+      char              c;
+      unsigned char    uc;
+      short             s;
+      unsigned short   us;
+      int               i;
+      unsigned int     ui;
+      long              l;
+      unsigned long    ul;
+      float             f;
+      double            d;
+
+      cmChar_t*         z;
+      const cmChar_t*  cz;
+
+      void*             vp;
+
+      char*             cp;
+      unsigned char*   ucp;
+      short*            sp;
+      unsigned short*  usp;
+      int*              ip;
+      unsigned int*    uip;
+      long*             lp;
+      unsigned long*   ulp;
+      float*            fp;
+      double*           dp;
+
+
+      struct cmData_str* child; // first child (array,record,pair)
+    } u;
+  
+  } cmData_t;
+
+  typedef unsigned cmDtRC_t;
+
+  // Get the value of an object without conversion.
+  // The data type id must match the return type or the
+  // conversion must be an automatic C conversion.
+  char            cmDataChar(      const cmData_t* p );
+  unsigned char   cmDataUChar(     const cmData_t* p );
+  short           cmDataShort(     const cmData_t* p );
+  unsigned short  cmDataUShort(    const cmData_t* p );
+  int             cmDataInt(       const cmData_t* p );
+  unsigned int    cmDataUInt(      const cmData_t* p );
+  long            cmDataLong(      const cmData_t* p );
+  unsigned long   cmDataULong(     const cmData_t* p );
+  float           cmDataFloat(     const cmData_t* p );
+  double          cmDataDouble(    const cmData_t* p );
+  cmChar_t*       cmDataStr(       const cmData_t* p );
+  const cmChar_t* cmDataConstStr(  const cmData_t* p );
+  void*           cmDataVoidPtr(   const cmData_t* p );
+  char*           cmDataCharPtr(   const cmData_t* p );
+  unsigned char*  cmDataUCharPtr(  const cmData_t* p );
+  short*          cmDataShortPtr(  const cmData_t* p );
+  unsigned short* cmDataUShortPtr( const cmData_t* p );
+  int*            cmDataIntPtr(    const cmData_t* p );
+  unsigned int*   cmDataUIntPtr(   const cmData_t* p );
+  long*           cmDataLongPtr(   const cmData_t* p );
+  unsigned long*  cmDataULongPtr(  const cmData_t* p );
+  float*          cmDataFloatPtr(  const cmData_t* p );
+  double*         cmDataDoublePtr( const cmData_t* p );
+
+
+  // Get the value of an object with conversion.
+  char            cmDataGetChar(      const cmData_t* p );
+  unsigned char   cmDataGetUChar(     const cmData_t* p );
+  short           cmDataGetShort(     const cmData_t* p );
+  unsigned short  cmDataGetUShort(    const cmData_t* p );
+  int             cmDataGetInt(       const cmData_t* p );
+  unsigned int    cmDataGetUInt(      const cmData_t* p );
+  long            cmDataGetLong(      const cmData_t* p );
+  unsigned long   cmDataGetULong(     const cmData_t* p );
+  float           cmDataGetFloat(     const cmData_t* p );
+  double          cmDataGetDouble(    const cmData_t* p );
+  cmChar_t*       cmDataGetStr(       const cmData_t* p );
+  const cmChar_t* cmDataGetConstStr(  const cmData_t* p );
+  void*           cmDataGetVoidPtr(   const cmData_t* p );
+  char*           cmDataGetCharPtr(   const cmData_t* p );
+  unsigned char*  cmDataGetUCharPtr(  const cmData_t* p );
+  short*          cmDataGetShortPtr(  const cmData_t* p );
+  unsigned short* cmDataGetUShortPtr( const cmData_t* p );
+  int*            cmDataGetIntPtr(    const cmData_t* p );
+  unsigned int*   cmDataGetUIntPtr(   const cmData_t* p );
+  long*           cmDataGetLongPtr(   const cmData_t* p );
+  unsigned long*  cmDataGetULongPtr(  const cmData_t* p );
+  float*          cmDataGetFloatPtr(  const cmData_t* p );
+  double*         cmDataGetDoublePtr( const cmData_t* p );
+
+
+  // Set the value of an existing data object.
+  void cmDataSetChar(      cmData_t* p, char v );
+  void cmDataSetUChar(     cmData_t* p, unsigned char v );
+  void cmDataSetShort(     cmData_t* p, short v );
+  void cmDataSetUShort(    cmData_t* p, unsigned short v );
+  void cmDataSetInt(       cmData_t* p, int v );
+  void cmDataSetUInt(      cmData_t* p, unsigned int v );
+  void cmDataSetLong(      cmData_t* p, long v );
+  void cmDataSetULong(     cmData_t* p, unsigned long v );
+  void cmDataSetFloat(     cmData_t* p, float v );
+  void cmDataSetDouble(    cmData_t* p, double v );
+  void cmDataSetStr(       cmData_t* p, cmChar_t* s );
+  void cmDataSetConstStr(  cmData_t* p, const cmChar_t* s );
+
+  // Set the value of an existing data object to an external array.
+  // The array is not copied.
+  void cmDataSetVoidPtr(   cmData_t* p, void* vp,           unsigned cnt );
+  void cmDataSetCharPtr(   cmData_t* p, char* vp,           unsigned cnt );
+  void cmDataSetUCharPtr(  cmData_t* p, unsigned char* vp,  unsigned cnt );
+  void cmDataSetShortPtr(  cmData_t* p, short* vp,          unsigned cnt );
+  void cmDataSetUShortPtr( cmData_t* p, unsigned short* vp, unsigned cnt );
+  void cmDataSetIntPtr(    cmData_t* p, int* vp,            unsigned cnt );
+  void cmDataSetUIntPtr(   cmData_t* p, unsigned int* vp,   unsigned cnt );
+  void cmDataSetLongPtr(   cmData_t* p, long* vp,           unsigned cnt );
+  void cmDataSetULongPtr(  cmData_t* p, unsigned long* vp,  unsigned cnt );
+  void cmDataSetFloatPtr(  cmData_t* p, float* vp,          unsigned cnt );
+  void cmDataSetDoublePtr( cmData_t* p, double* vp,         unsigned cnt );
+
+  // Set the value of an existing array based data object. 
+  // Allocate the internal array and copy the array into it.
+  void cmDataSetStrAlloc(       cmData_t* p, const cmChar_t* s );
+  void cmDataSetConstStrAlloc(  cmData_t* p, const cmChar_t* s );
+  void cmDataSetVoidAllocPtr(   cmData_t* p, const void* vp,           unsigned cnt );
+  void cmDataSetCharAllocPtr(   cmData_t* p, const char* vp,           unsigned cnt );
+  void cmDataSetUCharAllocPtr(  cmData_t* p, const unsigned char* vp,  unsigned cnt );
+  void cmDataSetShortAllocPtr(  cmData_t* p, const short* vp,          unsigned cnt );
+  void cmDataSetUShortAllocPtr( cmData_t* p, const unsigned short* vp, unsigned cnt );
+  void cmDataSetIntAllocPtr(    cmData_t* p, const int* vp,            unsigned cnt );
+  void cmDataSetUIntAllocPtr(   cmData_t* p, const unsigned int* vp,   unsigned cnt );
+  void cmDataSetLongAllocPtr(   cmData_t* p, const long* vp,           unsigned cnt );
+  void cmDataSetULongAllocPtr(  cmData_t* p, const unsigned long* vp,  unsigned cnt );
+  void cmDataSetFloatAllocPtr(  cmData_t* p, const float* vp,          unsigned cnt );
+  void cmDataSetDoubleAllocPtr( cmData_t* p, const double* vp,         unsigned cnt );
+  
+
+  // Dynamically allocate a data object and set it's value.
+  cmData_t* cmDataAllocChar(   char v );
+  cmData_t* cmDataAllocUChar(  unsigned char v );
+  cmData_t* cmDataAllocShort(  short v );
+  cmData_t* cmDataAllocUShort( unsigned short v );
+  cmData_t* cmDataAllocInt(    int v );
+  cmData_t* cmDataAllocUInt(   unsigned int v );
+  cmData_t* cmDataAllocLong(   long v );
+  cmData_t* cmDataAllocULong(  unsigned long v );
+  cmData_t* cmDataAllocFloat(  float v );
+  cmData_t* cmDataAllocDouble( double v );
+  cmData_t* cmDataAllocStr(    cmChar_t* str );
+  cmData_t* cmDataAllocConstStr( const cmChar_t* str );
+
+  // Dynamically allocate a data object and set its array value to an external
+  // array. The data is not copied.
+  cmData_t* cmDataAllocVoidPtr(   const void* v,           unsigned cnt );
+  cmData_t* cmDataAllocCharPtr(   const char* v,           unsigned cnt );
+  cmData_t* cmDataAllocUCharPtr(  const unsigned char* v,  unsigned cnt );
+  cmData_t* cmDataAllocShortPtr(  const short* v,          unsigned cnt );
+  cmData_t* cmDataAllocUShortPtr( const unsigned short* v, unsigned cnt );
+  cmData_t* cmDataAllocIntPtr(    const int* v,            unsigned cnt );
+  cmData_t* cmDataAllocUIntPtr(   const unsigned int* v,   unsigned cnt );
+  cmData_t* cmDataAllocLongPtr(   const long* v,           unsigned cnt );
+  cmData_t* cmDataAllocULongPtr(  const unsigned long* v,  unsigned cnt );
+  cmData_t* cmDataAllocFloatPtr(  const float* v,          unsigned cnt );
+  cmData_t* cmDataAllocDoublePtr( const double* v,         unsigned cnt );
+
+
+  // Dynamically allocate a data object and its array value.  
+  // v[cnt] is copied into the allocated array.
+  cmData_t* cmDataVoidAllocPtr(   const void* v,           unsigned cnt );
+  cmData_t* cmDataCharAllocPtr(   const char* v,           unsigned cnt );
+  cmData_t* cmDataUCharAllocPtr(  const unsigned char* v,  unsigned cnt );
+  cmData_t* cmDataShortAllocPtr(  const short* v,          unsigned cnt );
+  cmData_t* cmDataUShortAllocPtr( const unsigned short* v, unsigned cnt );
+  cmData_t* cmDataIntAllocPtr(    const int* v,            unsigned cnt );
+  cmData_t* cmDataUIntAllocPtr(   const unsigned int* v,   unsigned cnt );
+  cmData_t* cmDataLongAllocPtr(   const long* v,           unsigned cnt );
+  cmData_t* cmDataULongAllocPtr(  const unsigned long* v,  unsigned cnt );
+  cmData_t* cmDataFloatAllocPtr(  const float* v,          unsigned cnt );
+  cmData_t* cmDataDoubleAllocPtr( const double* v,         unsigned cnt );
+
+  
+
+  void cmDataFree( cmData_t* p );
+
+  
+  unsigned cmDataSerializeByteCount( const cmData_t* p );
+  cmDtRC_t cmDataSerialize( const cmData_t* p, void* buf, unsigned bufByteCnt );
+  cmDtRC_t cmDataDeserialize( const void* buf, unsigned bufByteCnt, cmData_t** pp );
+  
+  void     cmDataPrint( const cmData_t* p, cmRpt_t* rpt );
+  
+  void     cmDataTest( cmCtx_t* ctx );
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif