From dfb569b54852dcfe323c9affbe7852ad33fc4ca1 Mon Sep 17 00:00:00 2001 From: kpl Date: Sat, 4 May 2013 23:49:37 -0700 Subject: [PATCH] cmData.h/c,Makefile.am:Initial commit. --- Makefile.am | 4 +- cmData.c | 1006 +++++++++++++++++++++++++++++++++++++++++++++++++++ cmData.h | 281 ++++++++++++++ 3 files changed, 1289 insertions(+), 2 deletions(-) create mode 100644 cmData.c create mode 100644 cmData.h 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