1512 行
59 KiB
C
1512 行
59 KiB
C
#include "cmPrefix.h"
|
|
#include "cmGlobal.h"
|
|
#include "cmFloatTypes.h"
|
|
#include "cmRpt.h"
|
|
#include "cmErr.h"
|
|
#include "cmCtx.h"
|
|
#include "cmMem.h"
|
|
#include "cmMallocDebug.h"
|
|
#include "cmLinkedHeap.h"
|
|
#include "cmJson.h"
|
|
|
|
#include "cmDspValue.h"
|
|
|
|
cmDspValue_t cmDspNullValue = { 0 };
|
|
|
|
const cmDspValue_t* _vcptr( const cmDspValue_t* vp )
|
|
{
|
|
while( cmIsFlag(vp->flags, kProxyDsvFl ) )
|
|
vp = vp->u.vp;
|
|
|
|
return vp;
|
|
}
|
|
|
|
|
|
cmDspValue_t* _vptr( cmDspValue_t* vp )
|
|
{
|
|
while( cmIsFlag(vp->flags,kProxyDsvFl) )
|
|
vp = vp->u.vp;
|
|
|
|
return vp;
|
|
}
|
|
|
|
void** _cmDsvGetDataPtrPtr( cmDspValue_t* vp )
|
|
{
|
|
if( cmDsvIsMtx(vp) )
|
|
return &vp->u.m.u.vp;
|
|
|
|
if( cmIsFlag(vp->flags,kStrzDsvFl) )
|
|
return (void**)&vp->u.z;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
unsigned _cmDsvBasicType( unsigned flags )
|
|
{ return flags & (kTypeDsvMask & (~kMtxDsvFl) ); }
|
|
|
|
unsigned _cmDsvEleByteCount( unsigned flags )
|
|
{
|
|
|
|
switch( _cmDsvBasicType(flags) )
|
|
{
|
|
case kBoolDsvFl: return sizeof(bool);
|
|
case kCharDsvFl: return sizeof(char);
|
|
case kUCharDsvFl: return sizeof(unsigned char);
|
|
case kShortDsvFl: return sizeof(short);
|
|
case kUShortDsvFl:return sizeof(unsigned short);
|
|
case kLongDsvFl: return sizeof(long);
|
|
case kULongDsvFl: return sizeof(unsigned long);
|
|
case kIntDsvFl: return sizeof(int);
|
|
case kUIntDsvFl: return sizeof(unsigned int);
|
|
case kFloatDsvFl: return sizeof(float);
|
|
case kDoubleDsvFl:return sizeof(double);
|
|
case kSampleDsvFl:return sizeof(cmSample_t);
|
|
case kRealDsvFl: return sizeof(cmReal_t);
|
|
case kStrzDsvFl: return sizeof(cmChar_t*);
|
|
case kJsonDsvFl: return sizeof(cmJsonNode_t*);
|
|
default:
|
|
{ assert(0); }
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
bool cmDsvIsNull( const cmDspValue_t* vp ){ vp=_vcptr(vp); return vp->flags == kNullDsvFl; }
|
|
bool cmDsvIsBool( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kBoolDsvFl); }
|
|
bool cmDsvIsChar( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kCharDsvFl); }
|
|
bool cmDsvIsUChar( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kUCharDsvFl); }
|
|
bool cmDsvIsShort( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kShortDsvFl); }
|
|
bool cmDsvIsUShort( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kUShortDsvFl); }
|
|
bool cmDsvIsLong( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kLongDsvFl); }
|
|
bool cmDsvIsULong( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kULongDsvFl); }
|
|
bool cmDsvIsInt( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kIntDsvFl); }
|
|
bool cmDsvIsUInt( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kUIntDsvFl); }
|
|
bool cmDsvIsFloat( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kFloatDsvFl); }
|
|
bool cmDsvIsDouble( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kDoubleDsvFl); }
|
|
bool cmDsvIsSample( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kSampleDsvFl); }
|
|
bool cmDsvIsReal( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kRealDsvFl); }
|
|
bool cmDsvIsStrz( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kStrzDsvFl); }
|
|
bool cmDsvIsStrcz( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kStrzDsvFl | kConstDsvFl); }
|
|
bool cmDsvIsSymbol( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kSymDsvFl); }
|
|
bool cmDsvIsJson( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kJsonDsvFl); }
|
|
|
|
bool cmDsvIsBoolMtx( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kBoolDsvFl | kMtxDsvFl); }
|
|
bool cmDsvIsCharMtx( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kCharDsvFl | kMtxDsvFl); }
|
|
bool cmDsvIsUCharMtx( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kUCharDsvFl | kMtxDsvFl); }
|
|
bool cmDsvIsShortMtx( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kShortDsvFl | kMtxDsvFl); }
|
|
bool cmDsvIsUShortMtx( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kUShortDsvFl | kMtxDsvFl); }
|
|
bool cmDsvIsLongMtx( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kLongDsvFl | kMtxDsvFl); }
|
|
bool cmDsvIsULongMtx( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kULongDsvFl | kMtxDsvFl); }
|
|
bool cmDsvIsIntMtx( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kIntDsvFl | kMtxDsvFl); }
|
|
bool cmDsvIsUIntMtx( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kUIntDsvFl | kMtxDsvFl); }
|
|
bool cmDsvIsFloatMtx( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kFloatDsvFl | kMtxDsvFl); }
|
|
bool cmDsvIsDoubleMtx( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kDoubleDsvFl | kMtxDsvFl); }
|
|
bool cmDsvIsSampleMtx( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kSampleDsvFl | kMtxDsvFl); }
|
|
bool cmDsvIsRealMtx( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kRealDsvFl | kMtxDsvFl); }
|
|
bool cmDsvIsJsonMtx( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kJsonDsvFl | kMtxDsvFl); }
|
|
bool cmDsvIsStrzMtx( const cmDspValue_t* vp ){ vp=_vcptr(vp); return cmAllFlags(vp->flags,kStrzDsvFl | kMtxDsvFl); }
|
|
|
|
bool cmDsvSetFromValist( cmDspValue_t* vp, unsigned flags, va_list vl )
|
|
{
|
|
vp = _vptr(vp);
|
|
|
|
switch(flags)
|
|
{
|
|
case kBoolDsvFl: cmDsvSetBool( vp, va_arg(vl,int )); break;
|
|
case kCharDsvFl: cmDsvSetChar( vp, va_arg(vl,int )); break;
|
|
case kUCharDsvFl: cmDsvSetUChar( vp, va_arg(vl,int )); break;
|
|
case kShortDsvFl: cmDsvSetShort( vp, va_arg(vl,int )); break;
|
|
case kUShortDsvFl: cmDsvSetUShort( vp, va_arg(vl,int )); break;
|
|
case kLongDsvFl: cmDsvSetLong( vp, va_arg(vl,long )); break;
|
|
case kULongDsvFl: cmDsvSetULong( vp, va_arg(vl,unsigned long )); break;
|
|
case kIntDsvFl: cmDsvSetInt( vp, va_arg(vl,int )); break;
|
|
case kUIntDsvFl: cmDsvSetUInt( vp, va_arg(vl,unsigned )); break;
|
|
case kFloatDsvFl: cmDsvSetFloat( vp, va_arg(vl,double )); break;
|
|
case kDoubleDsvFl: cmDsvSetDouble( vp, va_arg(vl,double )); break;
|
|
case kSampleDsvFl: cmDsvSetSample( vp, va_arg(vl,double )); break;
|
|
case kRealDsvFl: cmDsvSetReal( vp, va_arg(vl,double )); break;
|
|
case kStrzDsvFl: cmDsvSetStrz( vp, va_arg(vl,cmChar_t* )); break;
|
|
default:
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void cmDsvSetNull( cmDspValue_t* vp ) { vp->flags = kNullDsvFl; }
|
|
void cmDsvSetBool( cmDspValue_t* vp, bool v ) { vp->flags = kBoolDsvFl; vp->u.b = v; }
|
|
void cmDsvSetChar( cmDspValue_t* vp, char v ) { vp->flags = kCharDsvFl; vp->u.c = v; }
|
|
void cmDsvSetUChar( cmDspValue_t* vp, unsigned char v ) { vp->flags = kUCharDsvFl; vp->u.uc = v; }
|
|
void cmDsvSetShort( cmDspValue_t* vp, short v ) { vp->flags = kShortDsvFl; vp->u.s = v; }
|
|
void cmDsvSetUShort( cmDspValue_t* vp, unsigned short v ) { vp->flags = kUShortDsvFl; vp->u.us = v; }
|
|
void cmDsvSetLong( cmDspValue_t* vp, long v ) { vp->flags = kLongDsvFl; vp->u.l = v; }
|
|
void cmDsvSetULong( cmDspValue_t* vp, unsigned long v ) { vp->flags = kULongDsvFl; vp->u.ul = v; }
|
|
void cmDsvSetInt( cmDspValue_t* vp, int v ) { vp->flags = kIntDsvFl; vp->u.i = v; }
|
|
void cmDsvSetUInt( cmDspValue_t* vp, unsigned int v ) { vp->flags = kUIntDsvFl; vp->u.u = v; }
|
|
void cmDsvSetFloat( cmDspValue_t* vp, float v ) { vp->flags = kFloatDsvFl; vp->u.f = v; }
|
|
void cmDsvSetDouble( cmDspValue_t* vp, double v ) { vp->flags = kDoubleDsvFl; vp->u.d = v; }
|
|
void cmDsvSetSample( cmDspValue_t* vp, cmSample_t v ) { vp->flags = kSampleDsvFl; vp->u.a = v; }
|
|
void cmDsvSetReal( cmDspValue_t* vp, cmReal_t v ) { vp->flags = kRealDsvFl; vp->u.r = v; }
|
|
void cmDsvSetSymbol( cmDspValue_t* vp, unsigned v ) { vp->flags = kSymDsvFl; vp->u.u = v; }
|
|
void cmDsvSetStrz( cmDspValue_t* vp, cmChar_t* v ) { vp->flags = kStrzDsvFl; vp->u.z = v; }
|
|
void cmDsvSetStrcz( cmDspValue_t* vp, const cmChar_t* v ){ vp->flags = kStrzDsvFl | kConstDsvFl; vp->u.cz = v; }
|
|
void cmDsvSetJson( cmDspValue_t* vp, cmJsonNode_t* v) { vp->flags = kJsonDsvFl; vp->u.j = v; }
|
|
|
|
void cmDsvSetBoolMtx( cmDspValue_t* vp, bool* v, unsigned rn, unsigned cn ) { vp->flags = kBoolDsvFl | kMtxDsvFl; vp->u.m.u.bp=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
void cmDsvSetCharMtx( cmDspValue_t* vp, char* v, unsigned rn, unsigned cn ) { vp->flags = kCharDsvFl | kMtxDsvFl; vp->u.m.u.cp=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
void cmDsvSetUCharMtx( cmDspValue_t* vp, unsigned char* v, unsigned rn, unsigned cn ) { vp->flags = kUCharDsvFl | kMtxDsvFl; vp->u.m.u.ucp=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
void cmDsvSetShortMtx( cmDspValue_t* vp, short* v, unsigned rn, unsigned cn ) { vp->flags = kShortDsvFl | kMtxDsvFl; vp->u.m.u.sp=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
void cmDsvSetUShortMtx( cmDspValue_t* vp, unsigned short* v, unsigned rn, unsigned cn ) { vp->flags = kUShortDsvFl | kMtxDsvFl; vp->u.m.u.usp=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
void cmDsvSetLongMtx( cmDspValue_t* vp, long* v, unsigned rn, unsigned cn ) { vp->flags = kLongDsvFl | kMtxDsvFl; vp->u.m.u.lp=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
void cmDsvSetULongMtx( cmDspValue_t* vp, unsigned long* v, unsigned rn, unsigned cn ) { vp->flags = kULongDsvFl | kMtxDsvFl; vp->u.m.u.ulp=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
void cmDsvSetIntMtx( cmDspValue_t* vp, int* v, unsigned rn, unsigned cn ) { vp->flags = kIntDsvFl | kMtxDsvFl; vp->u.m.u.ip=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
void cmDsvSetUIntMtx( cmDspValue_t* vp, unsigned int* v, unsigned rn, unsigned cn ) { vp->flags = kUIntDsvFl | kMtxDsvFl; vp->u.m.u.up=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
void cmDsvSetFloatMtx( cmDspValue_t* vp, float* v, unsigned rn, unsigned cn ) { vp->flags = kFloatDsvFl | kMtxDsvFl; vp->u.m.u.fp=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
void cmDsvSetDoubleMtx( cmDspValue_t* vp, double* v, unsigned rn, unsigned cn ) { vp->flags = kDoubleDsvFl | kMtxDsvFl; vp->u.m.u.dp=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
void cmDsvSetSampleMtx( cmDspValue_t* vp, cmSample_t* v, unsigned rn, unsigned cn ) { vp->flags = kSampleDsvFl | kMtxDsvFl; vp->u.m.u.ap=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
void cmDsvSetRealMtx( cmDspValue_t* vp, cmReal_t* v, unsigned rn, unsigned cn ) { vp->flags = kRealDsvFl | kMtxDsvFl; vp->u.m.u.rp=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
void cmDsvSetJsonMtx( cmDspValue_t* vp, cmJsonNode_t** v, unsigned rn, unsigned cn ) { vp->flags = kJsonDsvFl | kMtxDsvFl; vp->u.m.u.jp=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
void cmDsvSetStrzMtx( cmDspValue_t* vp, cmChar_t** v, unsigned rn, unsigned cn ) { vp->flags = kStrzDsvFl | kMtxDsvFl; vp->u.m.u.zp=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
void cmDsvSetStrczMtx( cmDspValue_t* vp, const cmChar_t** v,unsigned rn, unsigned cn ) { vp->flags = kStrzDsvFl | kMtxDsvFl | kConstDsvFl; vp->u.m.u.czp=v; vp->u.m.rn=rn; vp->u.m.cn=cn; }
|
|
|
|
void cmDsvSetMtx( cmDspValue_t* vp, unsigned flags, void* v, unsigned rn, unsigned cn )
|
|
{
|
|
vp->flags=flags;
|
|
vp->u.m.u.vp=v;
|
|
vp->u.m.rn=rn;
|
|
vp->u.m.cn=cn;
|
|
}
|
|
|
|
void cmDsvSetProxy( cmDspValue_t* vp, cmDspValue_t* pp )
|
|
{ vp->flags = kProxyDsvFl; vp->u.vp = pp; }
|
|
|
|
bool cmDsvCanConvertFlags( unsigned destFlags, unsigned srcFlags )
|
|
{
|
|
unsigned sFl = cmClrFlag(srcFlags & kTypeDsvMask, kProxyDsvFl);
|
|
unsigned dFl = cmClrFlag(destFlags & kTypeDsvMask, kProxyDsvFl );
|
|
|
|
|
|
// if the flags are equal then no conversion is necessary
|
|
if( sFl == dFl )
|
|
return true;
|
|
|
|
// if either the src or dst has no assigned type then conversion is always possible
|
|
if( sFl == 0 || dFl == 0 )
|
|
return true;
|
|
|
|
// conversion is not possible between a mtx and a scalar or v.v.
|
|
if( cmIsFlag(sFl,kMtxDsvFl) != cmIsFlag(dFl,kMtxDsvFl) )
|
|
return false;
|
|
|
|
// conversion between JSON nodes and anything else is not possible
|
|
if( cmIsFlag(sFl,kJsonDsvFl) != cmIsFlag(dFl,kJsonDsvFl) )
|
|
return false;
|
|
|
|
// conversion between string and anything else is not possible.
|
|
if( cmIsFlag(sFl,kStrzDsvFl) != cmIsFlag(dFl,kStrzDsvFl) )
|
|
return false;
|
|
|
|
// conversion betweens symbols and anything else is not possible
|
|
if( cmIsFlag(sFl,kSymDsvFl) != cmIsFlag(dFl,kSymDsvFl) )
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool cmDsvCanConvert( const cmDspValue_t* dvp, const cmDspValue_t* svp )
|
|
{
|
|
dvp = _vcptr(dvp);
|
|
svp = _vcptr(svp);
|
|
|
|
|
|
return cmDsvCanConvertFlags( _vcptr(dvp)->flags, _vcptr(svp)->flags );
|
|
}
|
|
|
|
bool cmDsvBool( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmIsFlag((vp->flags & kTypeDsvMask),kBoolDsvFl)) return vp->u.b; assert(0); return 0; }
|
|
char cmDsvChar( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmIsFlag((vp->flags & kTypeDsvMask),kCharDsvFl)) return vp->u.c; assert(0); return 0; }
|
|
unsigned char cmDsvUChar( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmIsFlag((vp->flags & kTypeDsvMask),kUCharDsvFl)) return vp->u.uc; assert(0); return 0; }
|
|
short cmDsvShort( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmIsFlag((vp->flags & kTypeDsvMask),kShortDsvFl)) return vp->u.s; assert(0); return 0; }
|
|
unsigned short cmDsvUShort( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmIsFlag((vp->flags & kTypeDsvMask),kUShortDsvFl)) return vp->u.us; assert(0); return 0; }
|
|
long cmDsvLong( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmIsFlag((vp->flags & kTypeDsvMask),kLongDsvFl)) return vp->u.l; assert(0); return 0; }
|
|
unsigned long cmDsvULong( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmIsFlag((vp->flags & kTypeDsvMask),kULongDsvFl)) return vp->u.ul; assert(0); return 0; }
|
|
int cmDsvInt( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmIsFlag((vp->flags & kTypeDsvMask),kIntDsvFl)) return vp->u.i; assert(0); return 0; }
|
|
unsigned int cmDsvUInt( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmIsFlag((vp->flags & kTypeDsvMask),kUIntDsvFl)) return vp->u.u; assert(0); return 0; }
|
|
float cmDsvFloat( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmIsFlag((vp->flags & kTypeDsvMask),kFloatDsvFl)) return vp->u.f; assert(0); return 0; }
|
|
double cmDsvDouble( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmIsFlag((vp->flags & kTypeDsvMask),kDoubleDsvFl)) return vp->u.d; assert(0); return 0; }
|
|
cmSample_t cmDsvSample( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmIsFlag((vp->flags & kTypeDsvMask),kSampleDsvFl)) return vp->u.a; assert(0); return 0; }
|
|
cmReal_t cmDsvReal( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmIsFlag((vp->flags & kTypeDsvMask),kRealDsvFl)) return vp->u.r; assert(0); return 0; }
|
|
unsigned int cmDsvSymbol( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmIsFlag((vp->flags & kTypeDsvMask),kSymDsvFl)) return vp->u.u; assert(0); return cmInvalidId; }
|
|
cmJsonNode_t* cmDsvJson( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmIsFlag((vp->flags & kTypeDsvMask),kJsonDsvFl)) return vp->u.j; assert(0); return NULL; }
|
|
|
|
const cmDspValue_t* cmDsvValueCPtr( const cmDspValue_t* vp )
|
|
{ return _vcptr(vp); }
|
|
|
|
cmDspValue_t* cmDsvValuePtr( cmDspValue_t* vp )
|
|
{ return _vptr(vp); }
|
|
|
|
cmChar_t* cmDsvStrz( const cmDspValue_t* vp )
|
|
{
|
|
vp=_vcptr(vp);
|
|
|
|
if(cmIsFlag((vp->flags & kTypeDsvMask),kStrzDsvFl) && cmIsFlag(vp->flags,kConstDsvFl)==false )
|
|
return vp->u.z;
|
|
|
|
assert(0);
|
|
return NULL;
|
|
}
|
|
|
|
const cmChar_t*cmDsvStrcz( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
if(cmIsFlag((vp->flags & kTypeDsvMask),kStrzDsvFl))
|
|
return vp->u.z;
|
|
assert(0);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
const bool* cmDsvBoolCMtx( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kBoolDsvFl)) return vp->u.m.u.bp; assert(0); return NULL; }
|
|
const char* cmDsvCharCMtx( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kCharDsvFl)) return vp->u.m.u.cp; assert(0); return NULL; }
|
|
const unsigned char* cmDsvUCharCMtx( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kUCharDsvFl)) return vp->u.m.u.ucp; assert(0); return NULL; }
|
|
const short* cmDsvShortCMtx( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kShortDsvFl)) return vp->u.m.u.sp; assert(0); return NULL; }
|
|
const unsigned short* cmDsvUShortCMtx( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kUShortDsvFl)) return vp->u.m.u.usp; assert(0); return NULL; }
|
|
const long* cmDsvLongCMtx( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kLongDsvFl)) return vp->u.m.u.lp; assert(0); return NULL; }
|
|
const unsigned long* cmDsvULongCMtx( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kULongDsvFl)) return vp->u.m.u.ulp; assert(0); return NULL; }
|
|
const int* cmDsvIntCMtx( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kIntDsvFl)) return vp->u.m.u.ip; assert(0); return NULL; }
|
|
const unsigned int* cmDsvUIntCMtx( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kUIntDsvFl)) return vp->u.m.u.up; assert(0); return NULL; }
|
|
const float* cmDsvFloatCMtx( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kFloatDsvFl)) return vp->u.m.u.fp; assert(0); return NULL; }
|
|
const double* cmDsvDoubleCMtx( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kDoubleDsvFl)) return vp->u.m.u.dp; assert(0); return NULL; }
|
|
const cmSample_t* cmDsvSampleCMtx( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kSampleDsvFl)) return vp->u.m.u.ap; assert(0); return NULL; }
|
|
const cmReal_t* cmDsvRealCMtx( const cmDspValue_t* vp ) { vp=_vcptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kRealDsvFl)) return vp->u.m.u.rp; assert(0); return NULL; }
|
|
|
|
const cmChar_t** cmDsvStrzCMtx( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kStrzDsvFl) )
|
|
return vp->u.m.u.czp;
|
|
|
|
assert(0);
|
|
return NULL;
|
|
}
|
|
|
|
const cmChar_t** cmDsvStrczCMtx( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kStrzDsvFl))
|
|
return vp->u.m.u.czp;
|
|
|
|
assert(0);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
bool* cmDsvBoolMtx( cmDspValue_t* vp ) { vp=_vptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kBoolDsvFl)) return vp->u.m.u.bp; assert(0); return NULL; }
|
|
char* cmDsvCharMtx( cmDspValue_t* vp ) { vp=_vptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kCharDsvFl)) return vp->u.m.u.cp; assert(0); return NULL; }
|
|
unsigned char* cmDsvUCharMtx( cmDspValue_t* vp ) { vp=_vptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kUCharDsvFl)) return vp->u.m.u.ucp; assert(0); return NULL; }
|
|
short* cmDsvShortMtx( cmDspValue_t* vp ) { vp=_vptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kShortDsvFl)) return vp->u.m.u.sp; assert(0); return NULL; }
|
|
unsigned short* cmDsvUShortMtx( cmDspValue_t* vp ) { vp=_vptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kUShortDsvFl)) return vp->u.m.u.usp; assert(0); return NULL; }
|
|
long* cmDsvLongMtx( cmDspValue_t* vp ) { vp=_vptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kLongDsvFl)) return vp->u.m.u.lp; assert(0); return NULL; }
|
|
unsigned long* cmDsvULongMtx( cmDspValue_t* vp ) { vp=_vptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kULongDsvFl)) return vp->u.m.u.ulp; assert(0); return NULL; }
|
|
int* cmDsvIntMtx( cmDspValue_t* vp ) { vp=_vptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kIntDsvFl)) return vp->u.m.u.ip; assert(0); return NULL; }
|
|
unsigned int* cmDsvUIntMtx( cmDspValue_t* vp ) { vp=_vptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kUIntDsvFl)) return vp->u.m.u.up; assert(0); return NULL; }
|
|
float* cmDsvFloatMtx( cmDspValue_t* vp ) { vp=_vptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kFloatDsvFl)) return vp->u.m.u.fp; assert(0); return NULL; }
|
|
double* cmDsvDoubleMtx( cmDspValue_t* vp ) { vp=_vptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kDoubleDsvFl)) return vp->u.m.u.dp; assert(0); return NULL; }
|
|
cmSample_t* cmDsvSampleMtx( cmDspValue_t* vp ) { vp=_vptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kSampleDsvFl)) return vp->u.m.u.ap; assert(0); return NULL; }
|
|
cmReal_t* cmDsvRealMtx( cmDspValue_t* vp ) { vp=_vptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kRealDsvFl)) return vp->u.m.u.rp; assert(0); return NULL; }
|
|
cmJsonNode_t** cmDsvJsonMtx( cmDspValue_t* vp ) { vp=_vptr(vp); if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kJsonDsvFl)) return vp->u.m.u.jp; assert(0); return NULL; }
|
|
cmChar_t** cmDsvStrzMtx( cmDspValue_t* vp )
|
|
{
|
|
vp = _vptr(vp);
|
|
|
|
if(cmAllFlags((vp->flags & kTypeDsvMask), kMtxDsvFl | kStrzDsvFl) && cmIsFlag(vp->flags,kConstDsvFl))
|
|
return vp->u.m.u.zp;
|
|
|
|
assert(0);
|
|
return NULL;
|
|
}
|
|
|
|
const cmChar_t** cmDsvStrczMtx( cmDspValue_t* vp )
|
|
{ return cmDsvStrczCMtx(vp); }
|
|
|
|
// Get the value of a cmDspValue_t as a <type>.
|
|
// Conversion is performed if the return type does not exactly match the cmDspValue_t type.
|
|
bool cmDsvGetBool( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
switch((vp->flags & kTypeDsvMask))
|
|
{
|
|
case kNullDsvFl: break;
|
|
case kBoolDsvFl: return vp->u.b;
|
|
case kCharDsvFl: return (bool)vp->u.c;
|
|
case kUCharDsvFl: return (bool)vp->u.uc;
|
|
case kShortDsvFl: return (bool)vp->u.s;
|
|
case kUShortDsvFl: return (bool)vp->u.us;
|
|
case kLongDsvFl: return (bool)vp->u.l;
|
|
case kULongDsvFl: return (bool)vp->u.ul;
|
|
case kIntDsvFl: return (bool)vp->u.i;
|
|
case kUIntDsvFl: return (bool)vp->u.u;
|
|
case kFloatDsvFl: return (bool)vp->u.f;
|
|
case kDoubleDsvFl: return (bool)vp->u.d;
|
|
case kSampleDsvFl: return (bool)vp->u.a;
|
|
case kRealDsvFl: return (bool)vp->u.r;
|
|
default:
|
|
assert(0);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
char cmDsvGetChar( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
switch((vp->flags & kTypeDsvMask))
|
|
{
|
|
case kNullDsvFl: break;
|
|
case kBoolDsvFl: return (char)vp->u.b;
|
|
case kCharDsvFl: return vp->u.c;
|
|
case kUCharDsvFl: return (char)vp->u.uc;
|
|
case kShortDsvFl: return (char)vp->u.s;
|
|
case kUShortDsvFl: return (char)vp->u.us;
|
|
case kLongDsvFl: return (char)vp->u.l;
|
|
case kULongDsvFl: return (char)vp->u.ul;
|
|
case kIntDsvFl: return (char)vp->u.i;
|
|
case kUIntDsvFl: return (char)vp->u.u;
|
|
case kFloatDsvFl: return (char)vp->u.f;
|
|
case kDoubleDsvFl: return (char)vp->u.d;
|
|
case kSampleDsvFl: return (char)vp->u.a;
|
|
case kRealDsvFl: return (char)vp->u.r;
|
|
default:
|
|
assert(0);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
unsigned char cmDsvGetUChar( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
switch((vp->flags & kTypeDsvMask))
|
|
{
|
|
case kNullDsvFl: break;
|
|
case kBoolDsvFl: return (char)vp->u.b;
|
|
case kCharDsvFl: return (unsigned char)vp->u.c;
|
|
case kUCharDsvFl: return vp->u.uc;
|
|
case kShortDsvFl: return (unsigned char)vp->u.s;
|
|
case kUShortDsvFl: return (unsigned char)vp->u.us;
|
|
case kLongDsvFl: return (unsigned char)vp->u.l;
|
|
case kULongDsvFl: return (unsigned char)vp->u.ul;
|
|
case kIntDsvFl: return (unsigned char)vp->u.i;
|
|
case kUIntDsvFl: return (unsigned char)vp->u.u;
|
|
case kFloatDsvFl: return (unsigned char)vp->u.f;
|
|
case kDoubleDsvFl: return (unsigned char)vp->u.d;
|
|
case kSampleDsvFl: return (unsigned char)vp->u.a;
|
|
case kRealDsvFl: return (unsigned char)vp->u.r;
|
|
default:
|
|
assert(0);
|
|
}
|
|
return 0;
|
|
}
|
|
short cmDsvGetShort( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
switch((vp->flags & kTypeDsvMask))
|
|
{
|
|
case kNullDsvFl: break;
|
|
case kBoolDsvFl: return (char)vp->u.b;
|
|
case kCharDsvFl: return (short)vp->u.c;
|
|
case kUCharDsvFl: return (short)vp->u.uc;
|
|
case kShortDsvFl: return vp->u.s;
|
|
case kUShortDsvFl: return (short)vp->u.us;
|
|
case kLongDsvFl: return (short)vp->u.l;
|
|
case kULongDsvFl: return (short)vp->u.ul;
|
|
case kIntDsvFl: return (short)vp->u.i;
|
|
case kUIntDsvFl: return (short)vp->u.u;
|
|
case kFloatDsvFl: return (short)vp->u.f;
|
|
case kDoubleDsvFl: return (short)vp->u.d;
|
|
case kSampleDsvFl: return (short)vp->u.a;
|
|
case kRealDsvFl: return (short)vp->u.r;
|
|
default:
|
|
assert(0);
|
|
}
|
|
return 0;
|
|
}
|
|
unsigned short cmDsvGetUShort( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
switch((vp->flags & kTypeDsvMask))
|
|
{
|
|
case kNullDsvFl: break;
|
|
case kBoolDsvFl: return (char)vp->u.b;
|
|
case kCharDsvFl: return (unsigned short)vp->u.c;
|
|
case kUCharDsvFl: return (unsigned short)vp->u.uc;
|
|
case kShortDsvFl: return (unsigned short)vp->u.s;
|
|
case kUShortDsvFl: return vp->u.us;
|
|
case kLongDsvFl: return (unsigned short)vp->u.l;
|
|
case kULongDsvFl: return (unsigned short)vp->u.ul;
|
|
case kIntDsvFl: return (unsigned short)vp->u.i;
|
|
case kUIntDsvFl: return (unsigned short)vp->u.u;
|
|
case kFloatDsvFl: return (unsigned short)vp->u.f;
|
|
case kDoubleDsvFl: return (unsigned short)vp->u.d;
|
|
case kSampleDsvFl: return (unsigned short)vp->u.a;
|
|
case kRealDsvFl: return (unsigned short)vp->u.r;
|
|
default:
|
|
assert(0);
|
|
}
|
|
return 0;
|
|
}
|
|
long cmDsvGetLong( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
switch((vp->flags & kTypeDsvMask))
|
|
{
|
|
case kNullDsvFl: break;
|
|
case kBoolDsvFl: return (char)vp->u.b;
|
|
case kCharDsvFl: return (long)vp->u.c;
|
|
case kUCharDsvFl: return (long)vp->u.uc;
|
|
case kShortDsvFl: return (long)vp->u.s;
|
|
case kUShortDsvFl: return (long)vp->u.us;
|
|
case kLongDsvFl: return vp->u.l;
|
|
case kULongDsvFl: return (long)vp->u.ul;
|
|
case kIntDsvFl: return (long)vp->u.i;
|
|
case kUIntDsvFl: return (long)vp->u.u;
|
|
case kFloatDsvFl: return (long)vp->u.f;
|
|
case kDoubleDsvFl: return (long)vp->u.d;
|
|
case kSampleDsvFl: return (long)vp->u.a;
|
|
case kRealDsvFl: return (long)vp->u.r;
|
|
default:
|
|
assert(0);
|
|
}
|
|
return 0;
|
|
}
|
|
unsigned long cmDsvGetULong( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
switch((vp->flags & kTypeDsvMask))
|
|
{
|
|
case kNullDsvFl: break;
|
|
case kBoolDsvFl: return (char)vp->u.b;
|
|
case kCharDsvFl: return (unsigned long)vp->u.c;
|
|
case kUCharDsvFl: return (unsigned long)vp->u.uc;
|
|
case kShortDsvFl: return (unsigned long)vp->u.s;
|
|
case kUShortDsvFl: return (unsigned long)vp->u.us;
|
|
case kLongDsvFl: return (unsigned long)vp->u.l;
|
|
case kULongDsvFl: return vp->u.ul;
|
|
case kIntDsvFl: return (unsigned long)vp->u.i;
|
|
case kUIntDsvFl: return (unsigned long)vp->u.u;
|
|
case kFloatDsvFl: return (unsigned long)vp->u.f;
|
|
case kDoubleDsvFl: return (unsigned long)vp->u.d;
|
|
case kSampleDsvFl: return (unsigned long)vp->u.a;
|
|
case kRealDsvFl: return (unsigned long)vp->u.r;
|
|
default:
|
|
assert(0);
|
|
}
|
|
return 0;
|
|
}
|
|
int cmDsvGetInt( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
switch((vp->flags & kTypeDsvMask))
|
|
{
|
|
case kNullDsvFl: break;
|
|
case kBoolDsvFl: return (char)vp->u.b;
|
|
case kCharDsvFl: return (int)vp->u.c;
|
|
case kUCharDsvFl: return (int)vp->u.uc;
|
|
case kShortDsvFl: return (int)vp->u.s;
|
|
case kUShortDsvFl: return (int)vp->u.us;
|
|
case kLongDsvFl: return (int)vp->u.l;
|
|
case kULongDsvFl: return (int)vp->u.ul;
|
|
case kIntDsvFl: return vp->u.i;
|
|
case kUIntDsvFl: return (int)vp->u.u;
|
|
case kFloatDsvFl: return (int)vp->u.f;
|
|
case kDoubleDsvFl: return (int)vp->u.d;
|
|
case kSampleDsvFl: return (int)vp->u.a;
|
|
case kRealDsvFl: return (int)vp->u.r;
|
|
default:
|
|
assert(0);
|
|
}
|
|
return 0;
|
|
}
|
|
unsigned int cmDsvGetUInt( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
switch((vp->flags & kTypeDsvMask))
|
|
{
|
|
case kNullDsvFl: break;
|
|
case kBoolDsvFl: return (char)vp->u.b;
|
|
case kCharDsvFl: return (unsigned int)vp->u.c;
|
|
case kUCharDsvFl: return (unsigned int)vp->u.uc;
|
|
case kShortDsvFl: return (unsigned int)vp->u.s;
|
|
case kUShortDsvFl: return (unsigned int)vp->u.us;
|
|
case kLongDsvFl: return (unsigned int)vp->u.l;
|
|
case kULongDsvFl: return (unsigned int)vp->u.ul;
|
|
case kIntDsvFl: return (unsigned int)vp->u.i;
|
|
case kUIntDsvFl: return vp->u.u;
|
|
case kFloatDsvFl: return (unsigned int)vp->u.f;
|
|
case kDoubleDsvFl: return (unsigned int)vp->u.d;
|
|
case kSampleDsvFl: return (unsigned int)vp->u.a;
|
|
case kRealDsvFl: return (unsigned int)vp->u.r;
|
|
default:
|
|
assert(0);
|
|
}
|
|
return 0;
|
|
}
|
|
float cmDsvGetFloat( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
switch((vp->flags & kTypeDsvMask))
|
|
{
|
|
case kNullDsvFl: break;
|
|
case kBoolDsvFl: return (char)vp->u.b;
|
|
case kCharDsvFl: return (float)vp->u.c;
|
|
case kUCharDsvFl: return (float)vp->u.uc;
|
|
case kShortDsvFl: return (float)vp->u.s;
|
|
case kUShortDsvFl: return (float)vp->u.us;
|
|
case kLongDsvFl: return (float)vp->u.l;
|
|
case kULongDsvFl: return (float)vp->u.ul;
|
|
case kIntDsvFl: return (float)vp->u.i;
|
|
case kUIntDsvFl: return (float)vp->u.u;
|
|
case kFloatDsvFl: return vp->u.f;
|
|
case kDoubleDsvFl: return (float)vp->u.d;
|
|
case kSampleDsvFl: return (float)vp->u.a;
|
|
case kRealDsvFl: return (float)vp->u.r;
|
|
default:
|
|
assert(0);
|
|
}
|
|
return 0;
|
|
}
|
|
double cmDsvGetDouble( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
switch((vp->flags & kTypeDsvMask))
|
|
{
|
|
case kNullDsvFl: break;
|
|
case kBoolDsvFl: return (char)vp->u.b;
|
|
case kCharDsvFl: return (double)vp->u.c;
|
|
case kUCharDsvFl: return (double)vp->u.uc;
|
|
case kShortDsvFl: return (double)vp->u.s;
|
|
case kUShortDsvFl: return (double)vp->u.us;
|
|
case kLongDsvFl: return (double)vp->u.l;
|
|
case kULongDsvFl: return (double)vp->u.ul;
|
|
case kIntDsvFl: return (double)vp->u.i;
|
|
case kUIntDsvFl: return (double)vp->u.u;
|
|
case kFloatDsvFl: return (double)vp->u.f;
|
|
case kDoubleDsvFl: return vp->u.d;
|
|
case kSampleDsvFl: return (double)vp->u.a;
|
|
case kRealDsvFl: return (double)vp->u.r;
|
|
default:
|
|
assert(0);
|
|
}
|
|
return 0;
|
|
}
|
|
cmSample_t cmDsvGetSample( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
switch((vp->flags & kTypeDsvMask))
|
|
{
|
|
case kNullDsvFl: break;
|
|
case kBoolDsvFl: return (char)vp->u.b;
|
|
case kCharDsvFl: return (cmSample_t)vp->u.c;
|
|
case kUCharDsvFl: return (cmSample_t)vp->u.uc;
|
|
case kShortDsvFl: return (cmSample_t)vp->u.s;
|
|
case kUShortDsvFl: return (cmSample_t)vp->u.us;
|
|
case kLongDsvFl: return (cmSample_t)vp->u.l;
|
|
case kULongDsvFl: return (cmSample_t)vp->u.ul;
|
|
case kIntDsvFl: return (cmSample_t)vp->u.i;
|
|
case kUIntDsvFl: return (cmSample_t)vp->u.u;
|
|
case kFloatDsvFl: return (cmSample_t)vp->u.f;
|
|
case kDoubleDsvFl: return (cmSample_t)vp->u.d;
|
|
case kSampleDsvFl: return vp->u.a;
|
|
case kRealDsvFl: return (cmSample_t)vp->u.r;
|
|
default:
|
|
assert(0);
|
|
}
|
|
return 0;
|
|
}
|
|
cmReal_t cmDsvGetReal( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
switch((vp->flags & kTypeDsvMask))
|
|
{
|
|
case kNullDsvFl: break;
|
|
case kBoolDsvFl: return (char)vp->u.b;
|
|
case kCharDsvFl: return (cmReal_t)vp->u.c;
|
|
case kUCharDsvFl: return (cmReal_t)vp->u.uc;
|
|
case kShortDsvFl: return (cmReal_t)vp->u.s;
|
|
case kUShortDsvFl: return (cmReal_t)vp->u.us;
|
|
case kLongDsvFl: return (cmReal_t)vp->u.l;
|
|
case kULongDsvFl: return (cmReal_t)vp->u.ul;
|
|
case kIntDsvFl: return (cmReal_t)vp->u.i;
|
|
case kUIntDsvFl: return (cmReal_t)vp->u.u;
|
|
case kFloatDsvFl: return (cmReal_t)vp->u.f;
|
|
case kDoubleDsvFl: return (cmReal_t)vp->u.d;
|
|
case kSampleDsvFl: return (cmReal_t)vp->u.a;
|
|
case kRealDsvFl: return vp->u.r;
|
|
default:
|
|
assert(0);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
unsigned int cmDsvGetSymbol( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
if( (vp->flags & kTypeDsvMask) == kSymDsvFl )
|
|
return vp->u.u;
|
|
return cmInvalidId;
|
|
}
|
|
|
|
|
|
cmChar_t* cmDsvGetStrz( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
if( (vp->flags & kTypeDsvMask) == kStrzDsvFl && cmIsFlag(vp->flags,kConstDsvFl)==false )
|
|
return vp->u.z;
|
|
return NULL;
|
|
}
|
|
|
|
const cmChar_t* cmDsvGetStrcz( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
if( (vp->flags & kTypeDsvMask) == kStrzDsvFl )
|
|
return vp->u.z;
|
|
return NULL;
|
|
}
|
|
|
|
cmJsonNode_t* cmDsvGetJson( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
if( (vp->flags & kTypeDsvMask) == kJsonDsvFl )
|
|
return vp->u.j;
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
#define cvt_b( dt,vp,op,sn) do{bool* sp=vp->u.m.u.bp; bool* ep=sp+sn; while(sp<ep) *op++=(dt)*sp++; }while(0)
|
|
#define cvt_c( dt,vp,op,sn) do{char* sp=vp->u.m.u.cp; char* ep=sp+sn; while(sp<ep) *op++=(dt)*sp++; }while(0)
|
|
#define cvt_uc( dt,vp,op,sn) do{unsigned char* sp=vp->u.m.u.ucp; unsigned char* ep=sp+sn; while(sp<ep) *op++=(dt)*sp++; }while(0)
|
|
#define cvt_s( dt,vp,op,sn) do{short* sp=vp->u.m.u.sp; short* ep=sp+sn; while(sp<ep) *op++=(dt)*sp++; }while(0)
|
|
#define cvt_us( dt,vp,op,sn) do{unsigned short* sp=vp->u.m.u.usp; unsigned short* ep=sp+sn; while(sp<ep) *op++=(dt)*sp++; }while(0)
|
|
#define cvt_l( dt,vp,op,sn) do{long* sp=vp->u.m.u.lp; long* ep=sp+sn; while(sp<ep) *op++=(dt)*sp++; }while(0)
|
|
#define cvt_ul( dt,vp,op,sn) do{unsigned long* sp=vp->u.m.u.ulp; unsigned long* ep=sp+sn; while(sp<ep) *op++=(dt)*sp++; }while(0)
|
|
#define cvt_i( dt,vp,op,sn) do{int* sp=vp->u.m.u.ip; int* ep=sp+sn; while(sp<ep) *op++=(dt)*sp++; }while(0)
|
|
#define cvt_u( dt,vp,op,sn) do{unsigned int* sp=vp->u.m.u.up; unsigned int* ep=sp+sn; while(sp<ep) *op++=(dt)*sp++; }while(0)
|
|
#define cvt_f( dt,vp,op,sn) do{float* sp=vp->u.m.u.fp; float* ep=sp+sn; while(sp<ep) *op++=(dt)*sp++; }while(0)
|
|
#define cvt_d( dt,vp,op,sn) do{double* sp=vp->u.m.u.dp; double* ep=sp+sn; while(sp<ep) *op++=(dt)*sp++; }while(0)
|
|
#define cvt_a( dt,vp,op,sn) do{cmSample_t* sp=vp->u.m.u.ap; cmSample_t* ep=sp+sn; while(sp<ep) *op++=(dt)*sp++; }while(0)
|
|
#define cvt_r( dt,vp,op,sn) do{cmReal_t* sp=vp->u.m.u.rp; cmReal_t* ep=sp+sn; while(sp<ep) *op++=(dt)*sp++; }while(0)
|
|
|
|
cmDsvRC_t _cmDsvValidateMtx( const cmDspValue_t* vp, unsigned vn, unsigned* snp )
|
|
{
|
|
if( cmIsFlag(vp->flags,kMtxDsvFl)==false)
|
|
{
|
|
assert(0);
|
|
return kNotMtxDsvRC;
|
|
}
|
|
|
|
*snp = vp->u.m.rn * vp->u.m.cn;
|
|
|
|
if( *snp > vn )
|
|
{
|
|
assert(0);
|
|
return kRetTooSmallDsvRC;
|
|
}
|
|
|
|
return kOkDsvRC;
|
|
|
|
}
|
|
|
|
cmDsvRC_t cmDsvGetBoolMtx( cmDspValue_t* vp, bool* v, unsigned vn )
|
|
{
|
|
cmDsvRC_t rc;
|
|
unsigned sn;
|
|
|
|
vp = _vptr(vp);
|
|
|
|
if((rc = _cmDsvValidateMtx(vp,vn,&sn)) != kOkDsvRC )
|
|
return rc;
|
|
|
|
switch(cmDsvBasicType(vp))
|
|
{
|
|
case kBoolDsvFl: cvt_b( bool,vp,v,sn); break;
|
|
case kCharDsvFl: cvt_c( bool,vp,v,sn); break;
|
|
case kUCharDsvFl: cvt_uc( bool,vp,v,sn); break;
|
|
case kShortDsvFl: cvt_s( bool,vp,v,sn); break;
|
|
case kUShortDsvFl: cvt_us( bool,vp,v,sn); break;
|
|
case kLongDsvFl: cvt_l( bool,vp,v,sn); break;
|
|
case kULongDsvFl: cvt_ul( bool,vp,v,sn); break;
|
|
case kIntDsvFl: cvt_i( bool,vp,v,sn); break;
|
|
case kUIntDsvFl: cvt_u( bool,vp,v,sn); break;
|
|
case kFloatDsvFl: cvt_f( bool,vp,v,sn); break;
|
|
case kDoubleDsvFl: cvt_d( bool,vp,v,sn); break;
|
|
case kSampleDsvFl: cvt_s( bool,vp,v,sn); break;
|
|
case kRealDsvFl: cvt_r( bool,vp,v,sn); break;
|
|
default:
|
|
assert(0);
|
|
return kUnknownTypeDsvRC;
|
|
}
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
cmDsvRC_t cmDsvGetCharMtx( cmDspValue_t* vp, char* v, unsigned vn )
|
|
{
|
|
vp = _vptr(vp);
|
|
|
|
cmDsvRC_t rc;
|
|
unsigned sn;
|
|
if((rc = _cmDsvValidateMtx(vp,vn,&sn)) != kOkDsvRC )
|
|
return rc;
|
|
|
|
switch(cmDsvBasicType(vp))
|
|
{
|
|
case kBoolDsvFl: cvt_b( char,vp,v,sn); break;
|
|
case kCharDsvFl: cvt_c( char,vp,v,sn); break;
|
|
case kUCharDsvFl: cvt_uc( char,vp,v,sn); break;
|
|
case kShortDsvFl: cvt_s( char,vp,v,sn); break;
|
|
case kUShortDsvFl: cvt_us( char,vp,v,sn); break;
|
|
case kLongDsvFl: cvt_l( char,vp,v,sn); break;
|
|
case kULongDsvFl: cvt_ul( char,vp,v,sn); break;
|
|
case kIntDsvFl: cvt_i( char,vp,v,sn); break;
|
|
case kUIntDsvFl: cvt_u( char,vp,v,sn); break;
|
|
case kFloatDsvFl: cvt_f( char,vp,v,sn); break;
|
|
case kDoubleDsvFl: cvt_d( char,vp,v,sn); break;
|
|
case kSampleDsvFl: cvt_s( char,vp,v,sn); break;
|
|
case kRealDsvFl: cvt_r( char,vp,v,sn); break;
|
|
default:
|
|
assert(0);
|
|
return kUnknownTypeDsvRC;
|
|
}
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
|
|
cmDsvRC_t cmDsvGetUCharMtx( cmDspValue_t* vp, unsigned char* v, unsigned vn )
|
|
{
|
|
vp = _vptr(vp);
|
|
|
|
cmDsvRC_t rc;
|
|
unsigned sn;
|
|
if((rc = _cmDsvValidateMtx(vp,vn,&sn)) != kOkDsvRC )
|
|
return rc;
|
|
|
|
switch(cmDsvBasicType(vp))
|
|
{
|
|
case kBoolDsvFl: cvt_b( unsigned char,vp,v,sn); break;
|
|
case kCharDsvFl: cvt_c( unsigned char,vp,v,sn); break;
|
|
case kUCharDsvFl: cvt_uc( unsigned char,vp,v,sn); break;
|
|
case kShortDsvFl: cvt_s( unsigned char,vp,v,sn); break;
|
|
case kUShortDsvFl: cvt_us( unsigned char,vp,v,sn); break;
|
|
case kLongDsvFl: cvt_l( unsigned char,vp,v,sn); break;
|
|
case kULongDsvFl: cvt_ul( unsigned char,vp,v,sn); break;
|
|
case kIntDsvFl: cvt_i( unsigned char,vp,v,sn); break;
|
|
case kUIntDsvFl: cvt_u( unsigned char,vp,v,sn); break;
|
|
case kFloatDsvFl: cvt_f( unsigned char,vp,v,sn); break;
|
|
case kDoubleDsvFl: cvt_d( unsigned char,vp,v,sn); break;
|
|
case kSampleDsvFl: cvt_s( unsigned char,vp,v,sn); break;
|
|
case kRealDsvFl: cvt_r( unsigned char,vp,v,sn); break;
|
|
default:
|
|
assert(0);
|
|
return kUnknownTypeDsvRC;
|
|
}
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
cmDsvRC_t cmDsvGetShortMtx( cmDspValue_t* vp, short* v, unsigned vn )
|
|
{
|
|
vp = _vptr(vp);
|
|
cmDsvRC_t rc;
|
|
unsigned sn;
|
|
if((rc = _cmDsvValidateMtx(vp,vn,&sn)) != kOkDsvRC )
|
|
return rc;
|
|
|
|
switch(cmDsvBasicType(vp))
|
|
{
|
|
case kBoolDsvFl: cvt_b( short,vp,v,sn); break;
|
|
case kCharDsvFl: cvt_c( short,vp,v,sn); break;
|
|
case kUCharDsvFl: cvt_uc( short,vp,v,sn); break;
|
|
case kShortDsvFl: cvt_s( short,vp,v,sn); break;
|
|
case kUShortDsvFl: cvt_us( short,vp,v,sn); break;
|
|
case kLongDsvFl: cvt_l( short,vp,v,sn); break;
|
|
case kULongDsvFl: cvt_ul( short,vp,v,sn); break;
|
|
case kIntDsvFl: cvt_i( short,vp,v,sn); break;
|
|
case kUIntDsvFl: cvt_u( short,vp,v,sn); break;
|
|
case kFloatDsvFl: cvt_f( short,vp,v,sn); break;
|
|
case kDoubleDsvFl: cvt_d( short,vp,v,sn); break;
|
|
case kSampleDsvFl: cvt_s( short,vp,v,sn); break;
|
|
case kRealDsvFl: cvt_r( short,vp,v,sn); break;
|
|
default:
|
|
assert(0);
|
|
return kUnknownTypeDsvRC;
|
|
}
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
cmDsvRC_t cmDsvGetUShortMtx( cmDspValue_t* vp, unsigned short* v, unsigned vn )
|
|
{
|
|
vp = _vptr(vp);
|
|
cmDsvRC_t rc;
|
|
unsigned sn;
|
|
if((rc = _cmDsvValidateMtx(vp,vn,&sn)) != kOkDsvRC )
|
|
return rc;
|
|
|
|
switch(cmDsvBasicType(vp))
|
|
{
|
|
case kBoolDsvFl: cvt_b( unsigned short,vp,v,sn); break;
|
|
case kCharDsvFl: cvt_c( unsigned short,vp,v,sn); break;
|
|
case kUCharDsvFl: cvt_uc( unsigned short,vp,v,sn); break;
|
|
case kShortDsvFl: cvt_s( unsigned short,vp,v,sn); break;
|
|
case kUShortDsvFl: cvt_us( unsigned short,vp,v,sn); break;
|
|
case kLongDsvFl: cvt_l( unsigned short,vp,v,sn); break;
|
|
case kULongDsvFl: cvt_ul( unsigned short,vp,v,sn); break;
|
|
case kIntDsvFl: cvt_i( unsigned short,vp,v,sn); break;
|
|
case kUIntDsvFl: cvt_u( unsigned short,vp,v,sn); break;
|
|
case kFloatDsvFl: cvt_f( unsigned short,vp,v,sn); break;
|
|
case kDoubleDsvFl: cvt_d( unsigned short,vp,v,sn); break;
|
|
case kSampleDsvFl: cvt_s( unsigned short,vp,v,sn); break;
|
|
case kRealDsvFl: cvt_r( unsigned short,vp,v,sn); break;
|
|
default:
|
|
assert(0);
|
|
return kUnknownTypeDsvRC;
|
|
}
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
cmDsvRC_t cmDsvGetLongMtx( cmDspValue_t* vp, long* v, unsigned vn )
|
|
{
|
|
vp = _vptr(vp);
|
|
cmDsvRC_t rc;
|
|
unsigned sn;
|
|
if((rc = _cmDsvValidateMtx(vp,vn,&sn)) != kOkDsvRC )
|
|
return rc;
|
|
|
|
switch(cmDsvBasicType(vp))
|
|
{
|
|
case kBoolDsvFl: cvt_b( long,vp,v,sn); break;
|
|
case kCharDsvFl: cvt_c( long,vp,v,sn); break;
|
|
case kUCharDsvFl: cvt_uc( long,vp,v,sn); break;
|
|
case kShortDsvFl: cvt_s( long,vp,v,sn); break;
|
|
case kUShortDsvFl: cvt_us( long,vp,v,sn); break;
|
|
case kLongDsvFl: cvt_l( long,vp,v,sn); break;
|
|
case kULongDsvFl: cvt_ul( long,vp,v,sn); break;
|
|
case kIntDsvFl: cvt_i( long,vp,v,sn); break;
|
|
case kUIntDsvFl: cvt_u( long,vp,v,sn); break;
|
|
case kFloatDsvFl: cvt_f( long,vp,v,sn); break;
|
|
case kDoubleDsvFl: cvt_d( long,vp,v,sn); break;
|
|
case kSampleDsvFl: cvt_s( long,vp,v,sn); break;
|
|
case kRealDsvFl: cvt_r( long,vp,v,sn); break;
|
|
default:
|
|
assert(0);
|
|
return kUnknownTypeDsvRC;
|
|
}
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
cmDsvRC_t cmDsvGetULongMtx( cmDspValue_t* vp, unsigned long* v, unsigned vn )
|
|
{
|
|
vp = _vptr(vp);
|
|
cmDsvRC_t rc;
|
|
unsigned sn;
|
|
if((rc = _cmDsvValidateMtx(vp,vn,&sn)) != kOkDsvRC )
|
|
return rc;
|
|
|
|
switch(cmDsvBasicType(vp))
|
|
{
|
|
case kBoolDsvFl: cvt_b( unsigned long,vp,v,sn); break;
|
|
case kCharDsvFl: cvt_c( unsigned long,vp,v,sn); break;
|
|
case kUCharDsvFl: cvt_uc( unsigned long,vp,v,sn); break;
|
|
case kShortDsvFl: cvt_s( unsigned long,vp,v,sn); break;
|
|
case kUShortDsvFl: cvt_us( unsigned long,vp,v,sn); break;
|
|
case kLongDsvFl: cvt_l( unsigned long,vp,v,sn); break;
|
|
case kULongDsvFl: cvt_ul( unsigned long,vp,v,sn); break;
|
|
case kIntDsvFl: cvt_i( unsigned long,vp,v,sn); break;
|
|
case kUIntDsvFl: cvt_u( unsigned long,vp,v,sn); break;
|
|
case kFloatDsvFl: cvt_f( unsigned long,vp,v,sn); break;
|
|
case kDoubleDsvFl: cvt_d( unsigned long,vp,v,sn); break;
|
|
case kSampleDsvFl: cvt_s( unsigned long,vp,v,sn); break;
|
|
case kRealDsvFl: cvt_r( unsigned long,vp,v,sn); break;
|
|
default:
|
|
assert(0);
|
|
return kUnknownTypeDsvRC;
|
|
}
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
cmDsvRC_t cmDsvGetIntMtx( cmDspValue_t* vp, int* v, unsigned vn )
|
|
{
|
|
vp = _vptr(vp);
|
|
cmDsvRC_t rc;
|
|
unsigned sn;
|
|
if((rc = _cmDsvValidateMtx(vp,vn,&sn)) != kOkDsvRC )
|
|
return rc;
|
|
|
|
switch(cmDsvBasicType(vp))
|
|
{
|
|
case kBoolDsvFl: cvt_b( int,vp,v,sn); break;
|
|
case kCharDsvFl: cvt_c( int,vp,v,sn); break;
|
|
case kUCharDsvFl: cvt_uc( int,vp,v,sn); break;
|
|
case kShortDsvFl: cvt_s( int,vp,v,sn); break;
|
|
case kUShortDsvFl: cvt_us( int,vp,v,sn); break;
|
|
case kLongDsvFl: cvt_l( int,vp,v,sn); break;
|
|
case kULongDsvFl: cvt_ul( int,vp,v,sn); break;
|
|
case kIntDsvFl: cvt_i( int,vp,v,sn); break;
|
|
case kUIntDsvFl: cvt_u( int,vp,v,sn); break;
|
|
case kFloatDsvFl: cvt_f( int,vp,v,sn); break;
|
|
case kDoubleDsvFl: cvt_d( int,vp,v,sn); break;
|
|
case kSampleDsvFl: cvt_s( int,vp,v,sn); break;
|
|
case kRealDsvFl: cvt_r( int,vp,v,sn); break;
|
|
default:
|
|
assert(0);
|
|
return kUnknownTypeDsvRC;
|
|
}
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
cmDsvRC_t cmDsvGetUIntMtx( cmDspValue_t* vp, unsigned int* v, unsigned vn )
|
|
{
|
|
vp = _vptr(vp);
|
|
cmDsvRC_t rc;
|
|
unsigned sn;
|
|
if((rc = _cmDsvValidateMtx(vp,vn,&sn)) != kOkDsvRC )
|
|
return rc;
|
|
|
|
switch(cmDsvBasicType(vp))
|
|
{
|
|
case kBoolDsvFl: cvt_b( unsigned int,vp,v,sn); break;
|
|
case kCharDsvFl: cvt_c( unsigned int,vp,v,sn); break;
|
|
case kUCharDsvFl: cvt_uc( unsigned int,vp,v,sn); break;
|
|
case kShortDsvFl: cvt_s( unsigned int,vp,v,sn); break;
|
|
case kUShortDsvFl: cvt_us( unsigned int,vp,v,sn); break;
|
|
case kLongDsvFl: cvt_l( unsigned int,vp,v,sn); break;
|
|
case kULongDsvFl: cvt_ul( unsigned int,vp,v,sn); break;
|
|
case kIntDsvFl: cvt_i( unsigned int,vp,v,sn); break;
|
|
case kUIntDsvFl: cvt_u( unsigned int,vp,v,sn); break;
|
|
case kFloatDsvFl: cvt_f( unsigned int,vp,v,sn); break;
|
|
case kDoubleDsvFl: cvt_d( unsigned int,vp,v,sn); break;
|
|
case kSampleDsvFl: cvt_s( unsigned int,vp,v,sn); break;
|
|
case kRealDsvFl: cvt_r( unsigned int,vp,v,sn); break;
|
|
default:
|
|
assert(0);
|
|
return kUnknownTypeDsvRC;
|
|
}
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
cmDsvRC_t cmDsvGetFloatMtx( cmDspValue_t* vp, float* v, unsigned vn )
|
|
{
|
|
vp = _vptr(vp);
|
|
cmDsvRC_t rc;
|
|
unsigned sn;
|
|
if((rc = _cmDsvValidateMtx(vp,vn,&sn)) != kOkDsvRC )
|
|
return rc;
|
|
|
|
switch(cmDsvBasicType(vp))
|
|
{
|
|
case kBoolDsvFl: cvt_b( float,vp,v,sn); break;
|
|
case kCharDsvFl: cvt_c( float,vp,v,sn); break;
|
|
case kUCharDsvFl: cvt_uc( float,vp,v,sn); break;
|
|
case kShortDsvFl: cvt_s( float,vp,v,sn); break;
|
|
case kUShortDsvFl: cvt_us( float,vp,v,sn); break;
|
|
case kLongDsvFl: cvt_l( float,vp,v,sn); break;
|
|
case kULongDsvFl: cvt_ul( float,vp,v,sn); break;
|
|
case kIntDsvFl: cvt_i( float,vp,v,sn); break;
|
|
case kUIntDsvFl: cvt_u( float,vp,v,sn); break;
|
|
case kFloatDsvFl: cvt_f( float,vp,v,sn); break;
|
|
case kDoubleDsvFl: cvt_d( float,vp,v,sn); break;
|
|
case kSampleDsvFl: cvt_s( float,vp,v,sn); break;
|
|
case kRealDsvFl: cvt_r( float,vp,v,sn); break;
|
|
default:
|
|
assert(0);
|
|
return kUnknownTypeDsvRC;
|
|
}
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
cmDsvRC_t cmDsvGetDoubleMtx( cmDspValue_t* vp, double* v, unsigned vn )
|
|
{
|
|
vp = _vptr(vp);
|
|
cmDsvRC_t rc;
|
|
unsigned sn;
|
|
if((rc = _cmDsvValidateMtx(vp,vn,&sn)) != kOkDsvRC )
|
|
return rc;
|
|
|
|
switch(cmDsvBasicType(vp))
|
|
{
|
|
case kBoolDsvFl: cvt_b( double,vp,v,sn); break;
|
|
case kCharDsvFl: cvt_c( double,vp,v,sn); break;
|
|
case kUCharDsvFl: cvt_uc( double,vp,v,sn); break;
|
|
case kShortDsvFl: cvt_s( double,vp,v,sn); break;
|
|
case kUShortDsvFl: cvt_us( double,vp,v,sn); break;
|
|
case kLongDsvFl: cvt_l( double,vp,v,sn); break;
|
|
case kULongDsvFl: cvt_ul( double,vp,v,sn); break;
|
|
case kIntDsvFl: cvt_i( double,vp,v,sn); break;
|
|
case kUIntDsvFl: cvt_u( double,vp,v,sn); break;
|
|
case kFloatDsvFl: cvt_f( double,vp,v,sn); break;
|
|
case kDoubleDsvFl: cvt_d( double,vp,v,sn); break;
|
|
case kSampleDsvFl: cvt_s( double,vp,v,sn); break;
|
|
case kRealDsvFl: cvt_r( double,vp,v,sn); break;
|
|
default:
|
|
assert(0);
|
|
return kUnknownTypeDsvRC;
|
|
}
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
cmDsvRC_t cmDsvGetSampleMtx( cmDspValue_t* vp, cmSample_t* v, unsigned vn )
|
|
{
|
|
vp = _vptr(vp);
|
|
cmDsvRC_t rc;
|
|
unsigned sn;
|
|
if((rc = _cmDsvValidateMtx(vp,vn,&sn)) != kOkDsvRC )
|
|
return rc;
|
|
|
|
switch(cmDsvBasicType(vp))
|
|
{
|
|
case kBoolDsvFl: cvt_b( cmSample_t,vp,v,sn); break;
|
|
case kCharDsvFl: cvt_c( cmSample_t,vp,v,sn); break;
|
|
case kUCharDsvFl: cvt_uc( cmSample_t,vp,v,sn); break;
|
|
case kShortDsvFl: cvt_s( cmSample_t,vp,v,sn); break;
|
|
case kUShortDsvFl: cvt_us( cmSample_t,vp,v,sn); break;
|
|
case kLongDsvFl: cvt_l( cmSample_t,vp,v,sn); break;
|
|
case kULongDsvFl: cvt_ul( cmSample_t,vp,v,sn); break;
|
|
case kIntDsvFl: cvt_i( cmSample_t,vp,v,sn); break;
|
|
case kUIntDsvFl: cvt_u( cmSample_t,vp,v,sn); break;
|
|
case kFloatDsvFl: cvt_f( cmSample_t,vp,v,sn); break;
|
|
case kDoubleDsvFl: cvt_d( cmSample_t,vp,v,sn); break;
|
|
case kSampleDsvFl: cvt_s( cmSample_t,vp,v,sn); break;
|
|
case kRealDsvFl: cvt_r( cmSample_t,vp,v,sn); break;
|
|
default:
|
|
assert(0);
|
|
return kUnknownTypeDsvRC;
|
|
}
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
cmDsvRC_t cmDsvGetRealMtx( cmDspValue_t* vp, cmReal_t* v, unsigned vn )
|
|
{
|
|
vp = _vptr(vp);
|
|
cmDsvRC_t rc;
|
|
unsigned sn;
|
|
if((rc = _cmDsvValidateMtx(vp,vn,&sn)) != kOkDsvRC )
|
|
return rc;
|
|
|
|
switch(cmDsvBasicType(vp))
|
|
{
|
|
case kBoolDsvFl: cvt_b( cmReal_t,vp,v,sn); break;
|
|
case kCharDsvFl: cvt_c( cmReal_t,vp,v,sn); break;
|
|
case kUCharDsvFl: cvt_uc( cmReal_t,vp,v,sn); break;
|
|
case kShortDsvFl: cvt_s( cmReal_t,vp,v,sn); break;
|
|
case kUShortDsvFl: cvt_us( cmReal_t,vp,v,sn); break;
|
|
case kLongDsvFl: cvt_l( cmReal_t,vp,v,sn); break;
|
|
case kULongDsvFl: cvt_ul( cmReal_t,vp,v,sn); break;
|
|
case kIntDsvFl: cvt_i( cmReal_t,vp,v,sn); break;
|
|
case kUIntDsvFl: cvt_u( cmReal_t,vp,v,sn); break;
|
|
case kFloatDsvFl: cvt_f( cmReal_t,vp,v,sn); break;
|
|
case kDoubleDsvFl: cvt_d( cmReal_t,vp,v,sn); break;
|
|
case kSampleDsvFl: cvt_s( cmReal_t,vp,v,sn); break;
|
|
case kRealDsvFl: cvt_r( cmReal_t,vp,v,sn); break;
|
|
default:
|
|
assert(0);
|
|
return kUnknownTypeDsvRC;
|
|
}
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
cmDsvRC_t cmDsvGetStrzMtx( cmDspValue_t* vp, cmChar_t* v, unsigned vn )
|
|
{
|
|
vp = _vptr(vp);
|
|
cmDsvRC_t rc;
|
|
unsigned sn;
|
|
if((rc = _cmDsvValidateMtx(vp,vn,&sn)) != kOkDsvRC )
|
|
return rc;
|
|
|
|
if( cmIsFlag(vp->flags,kConstDsvFl) )
|
|
return kConstViolationDsvRC;
|
|
|
|
switch(cmDsvBasicType(vp))
|
|
{
|
|
case kBoolDsvFl: cvt_b( cmChar_t,vp,v,sn); break;
|
|
case kCharDsvFl: cvt_c( cmChar_t,vp,v,sn); break;
|
|
case kUCharDsvFl: cvt_uc( cmChar_t,vp,v,sn); break;
|
|
case kShortDsvFl: cvt_s( cmChar_t,vp,v,sn); break;
|
|
case kUShortDsvFl: cvt_us( cmChar_t,vp,v,sn); break;
|
|
case kLongDsvFl: cvt_l( cmChar_t,vp,v,sn); break;
|
|
case kULongDsvFl: cvt_ul( cmChar_t,vp,v,sn); break;
|
|
case kIntDsvFl: cvt_i( cmChar_t,vp,v,sn); break;
|
|
case kUIntDsvFl: cvt_u( cmChar_t,vp,v,sn); break;
|
|
case kFloatDsvFl: cvt_f( cmChar_t,vp,v,sn); break;
|
|
case kDoubleDsvFl: cvt_d( cmChar_t,vp,v,sn); break;
|
|
case kSampleDsvFl: cvt_s( cmChar_t,vp,v,sn); break;
|
|
case kRealDsvFl: cvt_r( cmChar_t,vp,v,sn); break;
|
|
default:
|
|
assert(0);
|
|
return kUnknownTypeDsvRC;
|
|
}
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
|
|
bool cmDsvIsType( const cmDspValue_t* vp, unsigned flags )
|
|
{ vp = _vcptr(vp); return cmAllFlags(vp->flags,flags); }
|
|
|
|
bool cmDsvIsMtx( const cmDspValue_t* vp )
|
|
{ return cmIsFlag(vp->flags,kMtxDsvFl); }
|
|
|
|
unsigned cmDsvEleCount( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
if( cmIsFlag(vp->flags,kMtxDsvFl)==false)
|
|
return 0;
|
|
return vp->u.m.rn * vp->u.m.cn;
|
|
}
|
|
unsigned cmDsvRows( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
if( cmIsFlag(vp->flags,kMtxDsvFl)==false)
|
|
return 0;
|
|
return vp->u.m.rn;
|
|
}
|
|
|
|
unsigned cmDsvCols( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
if( cmIsFlag(vp->flags,kMtxDsvFl)==false)
|
|
return 0;
|
|
return vp->u.m.cn;
|
|
}
|
|
|
|
unsigned cmDsvBasicType( const cmDspValue_t* vp )
|
|
{ vp = _vcptr(vp); return _cmDsvBasicType(vp->flags); }
|
|
|
|
unsigned cmDsvEleByteCount( const cmDspValue_t* vp )
|
|
{ vp = _vcptr(vp); return _cmDsvEleByteCount(vp->flags); }
|
|
|
|
|
|
unsigned cmDsvByteCount( unsigned flags, unsigned rn, unsigned cn )
|
|
{
|
|
flags = flags & kTypeDsvMask;
|
|
return (cmIsFlag(flags,kMtxDsvFl) ? rn*cn : 1) * _cmDsvEleByteCount(flags);
|
|
}
|
|
|
|
unsigned cmDsvSerialByteCount( const cmDspValue_t* vp )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
unsigned byteCnt = sizeof(cmDspValue_t);
|
|
unsigned basicType = cmDsvBasicType(vp);
|
|
|
|
if( cmDsvIsMtx(vp) )
|
|
{
|
|
switch(basicType)
|
|
{
|
|
case kBoolDsvFl:
|
|
case kCharDsvFl:
|
|
case kUCharDsvFl:
|
|
case kShortDsvFl:
|
|
case kUShortDsvFl:
|
|
case kLongDsvFl:
|
|
case kULongDsvFl:
|
|
case kIntDsvFl:
|
|
case kUIntDsvFl:
|
|
case kFloatDsvFl:
|
|
case kDoubleDsvFl:
|
|
case kSampleDsvFl:
|
|
case kRealDsvFl:
|
|
case kSymDsvFl:
|
|
byteCnt += cmDsvRows(vp) * cmDsvCols(vp) * cmDsvEleByteCount(vp);
|
|
break;
|
|
|
|
case kStrzDsvFl:
|
|
case kJsonDsvFl:
|
|
// not implemented - these serializers still need to be implemented
|
|
byteCnt = 0;
|
|
assert(0);
|
|
break;
|
|
|
|
default:
|
|
{ assert(0); }
|
|
|
|
}
|
|
|
|
}
|
|
else // scalars
|
|
{
|
|
switch(basicType)
|
|
{
|
|
case kBoolDsvFl:
|
|
case kCharDsvFl:
|
|
case kUCharDsvFl:
|
|
case kShortDsvFl:
|
|
case kUShortDsvFl:
|
|
case kLongDsvFl:
|
|
case kULongDsvFl:
|
|
case kIntDsvFl:
|
|
case kUIntDsvFl:
|
|
case kFloatDsvFl:
|
|
case kDoubleDsvFl:
|
|
case kSampleDsvFl:
|
|
case kRealDsvFl:
|
|
case kSymDsvFl:
|
|
// these types are stored as part of the type record
|
|
// and therefore don't need any extra storage
|
|
break;
|
|
|
|
case kStrzDsvFl:
|
|
byteCnt += vp->u.z==NULL ? 0 : strlen(vp->u.z) + 1;
|
|
break;
|
|
|
|
case kJsonDsvFl:
|
|
if( vp->u.j != NULL )
|
|
{
|
|
assert( cmJsonValidate(vp->u.j) == kOkJsRC );
|
|
byteCnt += cmJsonSerialByteCount( vp->u.j );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{ assert(0); }
|
|
|
|
}
|
|
}
|
|
|
|
return byteCnt;
|
|
}
|
|
|
|
unsigned cmDsvSerialDataByteCount( const cmDspValue_t* vp )
|
|
{ vp = _vcptr(vp); return cmDsvSerialByteCount(vp) - sizeof(cmDspValue_t); }
|
|
|
|
cmDsvRC_t cmDsvSerialize( const cmDspValue_t* vp, void* buf, unsigned bufByteCnt )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
// the buffer must be at least large enough to
|
|
// hold the cmDspValue_t header record
|
|
if( bufByteCnt < sizeof(cmDspValue_t) )
|
|
return kRetTooSmallDsvRC;
|
|
|
|
cmDspValue_t* hp = (cmDspValue_t*)buf;
|
|
char* dp = (char*)(hp + 1);
|
|
char* ep = ((char*)buf) + bufByteCnt;
|
|
unsigned basicType = cmDsvBasicType(vp);
|
|
|
|
*hp = *vp; // copy the type header record
|
|
|
|
if( cmDsvIsMtx(vp) )
|
|
{
|
|
switch(basicType)
|
|
{
|
|
case kBoolDsvFl:
|
|
case kCharDsvFl:
|
|
case kUCharDsvFl:
|
|
case kShortDsvFl:
|
|
case kUShortDsvFl:
|
|
case kLongDsvFl:
|
|
case kULongDsvFl:
|
|
case kIntDsvFl:
|
|
case kUIntDsvFl:
|
|
case kFloatDsvFl:
|
|
case kDoubleDsvFl:
|
|
case kSampleDsvFl:
|
|
case kRealDsvFl:
|
|
{
|
|
// if the mtx data ptr is NULL then set it to NULL in the serialized data
|
|
if( vp->u.m.u.vp == NULL )
|
|
hp->u.m.u.vp = NULL;
|
|
else
|
|
{
|
|
unsigned bn = cmDsvRows(vp) * cmDsvCols(vp) * cmDsvEleByteCount(vp);
|
|
if( dp + bn > ep )
|
|
return kRetTooSmallDsvRC;
|
|
|
|
memcpy(dp, vp->u.m.u.vp, bn);
|
|
hp->u.m.u.vp = dp;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case kStrzDsvFl:
|
|
case kJsonDsvFl:
|
|
// not implemented - fall through and assert
|
|
|
|
default:
|
|
{ assert(0); }
|
|
|
|
}
|
|
|
|
}
|
|
else // scalars
|
|
{
|
|
switch(basicType)
|
|
{
|
|
case kBoolDsvFl:
|
|
case kCharDsvFl:
|
|
case kUCharDsvFl:
|
|
case kShortDsvFl:
|
|
case kUShortDsvFl:
|
|
case kLongDsvFl:
|
|
case kULongDsvFl:
|
|
case kIntDsvFl:
|
|
case kUIntDsvFl:
|
|
case kFloatDsvFl:
|
|
case kDoubleDsvFl:
|
|
case kSampleDsvFl:
|
|
case kRealDsvFl:
|
|
case kSymDsvFl:
|
|
// these types are stored as part of the type record
|
|
// and therefore don't need any extra storage
|
|
break;
|
|
|
|
case kStrzDsvFl:
|
|
if( vp->u.z==NULL )
|
|
hp->u.z = NULL;
|
|
else
|
|
{
|
|
unsigned bn = strlen(vp->u.z) + 1;
|
|
|
|
if( dp + bn > ep )
|
|
return kRetTooSmallDsvRC;
|
|
|
|
strncpy(dp,vp->u.z,bn);
|
|
hp->u.z = dp;
|
|
}
|
|
|
|
break;
|
|
|
|
case kJsonDsvFl:
|
|
if( vp->u.j == NULL )
|
|
hp->u.j = NULL;
|
|
else
|
|
{
|
|
unsigned bn = cmJsonSerialByteCount( vp->u.j );
|
|
|
|
if( dp + bn > ep )
|
|
return kRetTooSmallDsvRC;
|
|
|
|
if( cmJsonSerialize(vp->u.j,dp,bufByteCnt-sizeof(cmDspValue_t)) != kOkJsRC )
|
|
return kRetTooSmallDsvRC;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{ assert(0); }
|
|
|
|
}
|
|
}
|
|
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
cmDsvRC_t cmDsvDeserializeInPlace( cmDspValue_t* vp, unsigned dataBufByteCnt )
|
|
{
|
|
vp = _vptr(vp);
|
|
|
|
assert( cmIsFlag(vp->flags,kJsonDsvFl)==false );
|
|
|
|
void** vpp = _cmDsvGetDataPtrPtr(vp);
|
|
if( vpp != NULL )
|
|
{
|
|
*vpp = vp + 1;
|
|
}
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
cmDsvRC_t cmDsvDeserializeJson( cmDspValue_t* vp, cmJsonH_t jsH )
|
|
{
|
|
vp = _vptr(vp);
|
|
|
|
if( cmJsonClearTree(jsH) )
|
|
return kJsonDeserialFailDsvRC;
|
|
|
|
if( cmJsonDeserialize(jsH, vp + 1, NULL ) != kOkJsRC )
|
|
return kJsonDeserialFailDsvRC;
|
|
|
|
vp->u.j = cmJsonRoot(jsH);
|
|
|
|
return kOkDsvRC;
|
|
}
|
|
|
|
void cmDsvPrint( const cmDspValue_t* vp, const cmChar_t* label, cmRpt_t* rpt )
|
|
{
|
|
vp = _vcptr(vp);
|
|
|
|
const char* noLbl="";
|
|
const char* lbl = label==NULL? noLbl : label;
|
|
|
|
if( cmDsvIsMtx(vp) )
|
|
{
|
|
unsigned i,j;
|
|
unsigned rn = cmDsvCols(vp);
|
|
unsigned cn = cmDsvRows(vp);
|
|
for(i=0; i<rn; ++i)
|
|
{
|
|
for(j=0; j<cn; ++j)
|
|
{
|
|
switch( cmDsvBasicType(vp) )
|
|
{
|
|
case kCharDsvFl: cmRptPrintf (rpt,"%s%c ",lbl,vp->u.m.u.cp[ (j*rn) + i ]); break;
|
|
case kUCharDsvFl: cmRptPrintf (rpt,"%s%c ",lbl,vp->u.m.u.ucp[ (j*rn) + i ]); break;
|
|
case kShortDsvFl: cmRptPrintf (rpt,"%s%i ",lbl,vp->u.m.u.sp[ (j*rn) + i ]); break;
|
|
case kUShortDsvFl: cmRptPrintf (rpt,"%s%i ",lbl,vp->u.m.u.usp[ (j*rn) + i ]); break;
|
|
case kLongDsvFl: cmRptPrintf (rpt,"%s%i ",lbl,vp->u.m.u.lp[ (j*rn) + i ]); break;
|
|
case kULongDsvFl: cmRptPrintf (rpt,"%s%i ",lbl,vp->u.m.u.ulp[ (j*rn) + i ]); break;
|
|
case kIntDsvFl: cmRptPrintf (rpt,"%s%i ",lbl,vp->u.m.u.ip[ (j*rn) + i ]); break;
|
|
case kUIntDsvFl: cmRptPrintf (rpt,"%s%i ",lbl,vp->u.m.u.up[ (j*rn) + i ]); break;
|
|
case kFloatDsvFl: cmRptPrintf (rpt,"%s%f ",lbl,vp->u.m.u.fp[ (j*rn) + i ]); break;
|
|
case kDoubleDsvFl: cmRptPrintf (rpt,"%s%f ",lbl,vp->u.m.u.dp[ (j*rn) + i ]); break;
|
|
case kSampleDsvFl: cmRptPrintf (rpt,"%s%f ",lbl,vp->u.m.u.ap[ (j*rn) + i ]); break;
|
|
case kRealDsvFl: cmRptPrintf (rpt,"%s%f ",lbl,vp->u.m.u.rp[ (j*rn) + i ]); break;
|
|
case kStrzDsvFl: cmRptPrintf (rpt,"%s%s ",lbl,vp->u.m.u.zp[ (j*rn) + i ]); break;
|
|
case kJsonDsvFl: cmJsonPrintTree(vp->u.m.u.jp[ (j*rn) + i ],rpt); break;
|
|
default:
|
|
{ assert(0); }
|
|
}
|
|
}
|
|
cmRptPrint(rpt,"\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch( cmDsvBasicType(vp) )
|
|
{
|
|
case kBoolDsvFl: cmRptPrintf(rpt,"%s%s ",lbl,vp->u.b ? "true" : "false"); break;
|
|
case kCharDsvFl: cmRptPrintf(rpt,"%s%c ",lbl,vp->u.c); break;
|
|
case kUCharDsvFl: cmRptPrintf(rpt,"%s%c ",lbl,vp->u.uc); break;
|
|
case kShortDsvFl: cmRptPrintf(rpt,"%s%i ",lbl,vp->u.s); break;
|
|
case kUShortDsvFl: cmRptPrintf(rpt,"%s%i ",lbl,vp->u.us); break;
|
|
case kLongDsvFl: cmRptPrintf(rpt,"%s%i ",lbl,vp->u.l); break;
|
|
case kULongDsvFl: cmRptPrintf(rpt,"%s%i ",lbl,vp->u.ul); break;
|
|
case kIntDsvFl: cmRptPrintf(rpt,"%s%i ",lbl,vp->u.i); break;
|
|
case kUIntDsvFl: cmRptPrintf(rpt,"%s%i ",lbl,vp->u.u); break;
|
|
case kFloatDsvFl: cmRptPrintf(rpt,"%s%f ",lbl,vp->u.f); break;
|
|
case kDoubleDsvFl: cmRptPrintf(rpt,"%s%f ",lbl,vp->u.d); break;
|
|
case kSampleDsvFl: cmRptPrintf(rpt,"%s%f ",lbl,vp->u.a); break;
|
|
case kRealDsvFl: cmRptPrintf(rpt,"%s%f ",lbl,vp->u.r); break;
|
|
case kStrzDsvFl: cmRptPrintf(rpt,"%s%s ",lbl,vp->u.z); break;
|
|
case kSymDsvFl: cmRptPrintf(rpt,"%s%i ",lbl,vp->u.u); break;
|
|
case kJsonDsvFl: cmJsonPrintTree(vp->u.j,rpt); break;
|
|
default:
|
|
{ assert(0); }
|
|
}
|
|
}
|
|
}
|