#include "cmGlobal.h" #include "cmRpt.h" #include "cmErr.h" #include "cmCtx.h" #include "cmMem.h" #include "cmMallocDebug.h" #include "cmLinkedHeap.h" #include "cmData.h" #include "cmLex.h" #include "cmText.h" #include "cmStack.h" typedef struct { cmDataTypeId_t typeId; unsigned byteWidth; const cmChar_t* label; } cmDtTypeInfo_t; typedef struct { cmDataContainerId_t id; const cmChar_t* label; } cmDtCntInfo_t; cmDtTypeInfo_t _cmDtTypeInfoArray[] = { { kNullDtId, 0, "null" }, { kBoolDtId, sizeof(bool), "bool" }, { kUCharDtId, sizeof(unsigned char), "uchar" }, { kCharDtId, sizeof(char), "char" }, { kUShortDtId, sizeof(unsigned short), "ushort" }, { kShortDtId, sizeof(short), "short" }, { kUIntDtId, sizeof(unsigned int), "uint" }, { kIntDtId, sizeof(int), "int" }, { kULongDtId, sizeof(unsigned long), "ulong" }, { kLongDtId, sizeof(long), "long" }, { kFloatDtId, sizeof(float), "float" }, { kDoubleDtId, sizeof(double), "double" }, { kStrDtId, sizeof(char*), "string" }, { kBlobDtId, sizeof(void*), "blob" }, { kInvalidTypeDtId, 0, "" }, }; cmDtCntInfo_t _cmDtCntInfoArray[] = { { kScalarDtId, "scalar" }, { kArrayDtId, "array" }, { kListDtId, "list" }, { kPairDtId, "pair" }, { kRecordDtId, "record"}, { kInvalidCntDtId,""} }; cmData_t cmDataNull = { kInvalidTypeDtId,kInvalidCntDtId,0,NULL,NULL,0 }; cmDtRC_t _cmDtErrMsgV( const cmData_t* d, cmDtRC_t rc, const cmChar_t* fmt, va_list vl ) { // REPLACE this with a global cmRpt call. vprintf(fmt,vl); return rc; } cmDtRC_t _cmDtErrMsg( const cmData_t* d, cmDtRC_t rc, const cmChar_t* fmt, ... ) { va_list vl; va_start(vl,fmt); rc = _cmDtErrMsgV(d,rc,fmt,vl); va_end(vl); return rc; } const cmChar_t* cmDataTypeToLabel( cmDataTypeId_t tid ) { unsigned i; for(i=0; _cmDtTypeInfoArray[i].typeId!=kInvalidTypeDtId; ++i) if( _cmDtTypeInfoArray[i].typeId == tid ) return _cmDtTypeInfoArray[i].label; return NULL; } cmDataTypeId_t cmDataLabelToType( const cmChar_t* typeLabelStr ) { unsigned i; for(i=0; _cmDtTypeInfoArray[i].typeId!=kInvalidTypeDtId; ++i) if( strcmp(_cmDtTypeInfoArray[i].label,typeLabelStr) == 0 ) return _cmDtTypeInfoArray[i].typeId; return kInvalidTypeDtId; } unsigned cmDataByteWidth( cmDataTypeId_t tid ) { unsigned i; for(i=0; _cmDtTypeInfoArray[i].typeId!=kInvalidTypeDtId; ++i) if( _cmDtTypeInfoArray[i].typeId == tid ) return _cmDtTypeInfoArray[i].byteWidth; return cmInvalidCnt; } const cmChar_t* cmDataContainerIdToLabel( cmDataContainerId_t tid ) { unsigned i; for(i=0; _cmDtCntInfoArray[i].id!=kInvalidCntDtId; ++i) if( _cmDtCntInfoArray[i].id == tid ) return _cmDtCntInfoArray[i].label; return NULL; } cmDataContainerId_t cmDataLabelToContainerId( const cmChar_t* contLabelStr ) { unsigned i; for(i=0; _cmDtCntInfoArray[i].id!=kInvalidCntDtId; ++i) if( strcmp(_cmDtCntInfoArray[i].label,contLabelStr) == 0 ) return _cmDtCntInfoArray[i].id; return kInvalidCntDtId; } bool _cmDataIsDataOwner( const cmData_t* d ) { return cmIsFlag(d->flags,kFreeValueDtFl) && (d->cid==kArrayDtId || d->tid==kStrDtId || d->tid==kBlobDtId); } cmDtRC_t _cmDataFreeData( cmData_t* d ) { if( _cmDataIsDataOwner(d) ) { cmMemPtrFree(&d->u.vp); } d->flags = cmClrFlag(d->flags,kFreeValueDtFl | kConstValueDtFl ); d->tid = kNullDtId; // objects without data are always of type 'null'. d->cnt = 0; memset(&d->u,0,sizeof(d->u)); return kOkDtRC; } void _cmDataFree( cmData_t* p ) { if( p == NULL ) return; if( cmDataIsStruct(p) ) { cmData_t* cp = p->u.child; for(; cp!=NULL; cp=cp->sibling) _cmDataFree(cp); } _cmDataFreeData(p); if( cmIsFlag(p->flags,kFreeObjDtFl) ) { // if the object body is going to be freed then be sure it is unlinked cmDataUnlink(p); cmMemFree(p); } } // Dynamically allocate a new data object. cmData_t* _cmDataNew(cmData_t* parent, cmDataContainerId_t cid, cmDataTypeId_t tid) { cmData_t* d = cmMemAllocZ(cmData_t,1); d->tid = tid; // objects without data are of type 'null'. d->cid = cid; d->flags = kFreeObjDtFl; d->parent = parent; d->cnt = 0; if( parent != NULL ) cmDataAppendChild(parent,d); return d; } bool cmDataIsConstObj( const cmData_t* d ) { return cmIsFlag(d->flags,kConstObjDtFl); } void cmDataEnableConstObj( cmData_t* d, bool enaFl ) { d->flags = cmEnaFlag(d->flags,kConstObjDtFl,enaFl); } bool cmDataIsConstValue( const cmData_t* d ) { return cmIsFlag(d->flags,kConstValueDtFl); } void cmDataEnableConstValue( cmData_t* d, bool enaFl ) { d->flags = cmEnaFlag(d->flags,kConstValueDtFl,enaFl); } bool cmDataIsFreeValue( const cmData_t* d ) { return cmIsFlag(d->flags,kFreeValueDtFl); } void cmDataEnableFreeValue( cmData_t* d, bool enaFl ) { d->flags = cmEnaFlag(d->flags,kFreeValueDtFl,enaFl); } bool cmDataIsLeaf( const cmData_t* d) { return d->cid == kScalarDtId || d->cid == kArrayDtId; } bool cmDataIsStruct( const cmData_t* d ) { return !cmDataIsLeaf(d); } cmDtRC_t cmDataNewScalar( cmData_t* parent, cmDataTypeId_t tid, unsigned flags, void* vp, unsigned byteCnt, cmData_t** ref ) { cmDtRC_t rc; if( ref != NULL ) *ref = NULL; // create a scalar null object cmData_t* d = _cmDataNew(parent,kScalarDtId,kNullDtId); if( tid!=kStrDtId && tid!=kBlobDtId ) { // When used with scalars kFreeValueDtFl and kNoCopyDtFl only // has meaning for strings and blobs - so clear these flags for other types. flags = cmClrFlag(flags,kFreeValueDtFl | kNoCopyDtFl); // if this is not a blob or string then the byteCnt is reset byteCnt = cmDataByteWidth(tid); } // assign the value if((rc = cmDataSetScalarValue(d,tid,vp,byteCnt,flags)) != kOkDtRC ) return rc; // set the const flags for the new object d->flags = cmSetFlag(d->flags, flags & (kConstValueDtFl | kConstObjDtFl)); if( ref != NULL ) *ref = d; return rc; } cmDtRC_t cmDataNewNull( cmData_t* parent, unsigned flags, cmData_t** ref ) { *ref = _cmDataNew(parent, kScalarDtId, kNullDtId); return kOkDtRC; } cmDtRC_t cmDataNewBool( cmData_t* parent, unsigned flags, bool v, cmData_t** ref ) { return cmDataNewScalar(parent,kBoolDtId,flags,&v,0,ref); } cmDtRC_t cmDataNewChar( cmData_t* parent, unsigned flags, char v, cmData_t** ref ) { return cmDataNewScalar(parent,kCharDtId,flags,&v,0,ref); } cmDtRC_t cmDataNewUChar( cmData_t* parent, unsigned flags, unsigned char v, cmData_t** ref ) { return cmDataNewScalar(parent,kUCharDtId,flags,&v,0,ref); } cmDtRC_t cmDataNewShort( cmData_t* parent, unsigned flags, short v, cmData_t** ref ) { return cmDataNewScalar(parent,kShortDtId,flags,&v,0,ref); } cmDtRC_t cmDataNewUShort( cmData_t* parent, unsigned flags, unsigned short v, cmData_t** ref ) { return cmDataNewScalar(parent,kUShortDtId,flags,&v,0,ref); } cmDtRC_t cmDataNewInt( cmData_t* parent, unsigned flags, int v, cmData_t** ref ) { return cmDataNewScalar(parent,kIntDtId,flags,&v,0,ref); } cmDtRC_t cmDataNewUInt( cmData_t* parent, unsigned flags, unsigned int v, cmData_t** ref ) { return cmDataNewScalar(parent,kUIntDtId,flags,&v,0,ref); } cmDtRC_t cmDataNewLong( cmData_t* parent, unsigned flags, long v, cmData_t** ref ) { return cmDataNewScalar(parent,kLongDtId,flags,&v,0,ref); } cmDtRC_t cmDataNewULong( cmData_t* parent, unsigned flags, unsigned long v, cmData_t** ref ) { return cmDataNewScalar(parent,kULongDtId,flags,&v,0,ref); } cmDtRC_t cmDataNewFloat( cmData_t* parent, unsigned flags, float v, cmData_t** ref ) { return cmDataNewScalar(parent,kFloatDtId,flags,&v,0,ref); } cmDtRC_t cmDataNewDouble( cmData_t* parent, unsigned flags, double v, cmData_t** ref ) { return cmDataNewScalar(parent,kDoubleDtId,flags,&v,0,ref); } cmDtRC_t cmDataNewStr( cmData_t* parent, unsigned flags, cmChar_t* v, cmData_t** ref ) { return cmDataNewScalar(parent,kStrDtId,flags,v,strlen(v)+1,ref); } cmDtRC_t cmDataNewConstStr( cmData_t* parent, unsigned flags, const cmChar_t* v, cmData_t** ref ) { return cmDataNewScalar(parent,kStrDtId,flags | kConstValueDtFl, (void*)v,strlen(v)+1,ref); } cmDtRC_t cmDataNewStrN( cmData_t* parent, unsigned flags, cmChar_t* v, unsigned charCnt, cmData_t** ref ) { return cmDataNewScalar(parent,kStrDtId,flags,v,charCnt+1,ref); } cmDtRC_t cmDataNewConstStrN( cmData_t* parent, unsigned flags, const cmChar_t* v, unsigned charCnt, cmData_t** ref ) { return cmDataNewScalar(parent,kStrDtId,flags | kConstValueDtFl, (void*)v,charCnt+1,ref); } cmDtRC_t cmDataNewBlob( cmData_t* parent, unsigned flags, void* v, unsigned byteCnt, cmData_t** ref ) { return cmDataNewScalar(parent,kBlobDtId,flags,v,byteCnt,ref); } cmDtRC_t cmDataNewConstBlob( cmData_t* parent, unsigned flags, const void* v, unsigned byteCnt, cmData_t** ref ) { return cmDataNewScalar(parent,kBlobDtId,flags | kConstValueDtFl, (void*)v,byteCnt,ref); } cmDtRC_t cmDataSetScalarValue( cmData_t* d, cmDataTypeId_t tid, void* vp, unsigned byteCnt, unsigned flags ) { cmDtRC_t rc; // if the type of the object is changing if( d->tid != tid || d->cid != kScalarDtId ) { // verify that it is legal to change the type of the object if( cmIsFlag(d->flags,kConstObjDtFl) ) return _cmDtErrMsg(d,kConstErrDtRC,"Const object violation."); // convert this to a scalar null object. if((rc = _cmDataFreeData(d)) != kOkDtRC ) return rc; } // verify that it is legal to change the value of this object if( cmIsFlag(d->flags,kConstValueDtFl) ) return _cmDtErrMsg(d,kConstErrDtRC,"Const value violation."); switch( tid ) { case kInvalidTypeDtId: return _cmDtErrMsg(d,kAssertErrDtRC,"Invalid data type."); case kNullDtId: // 'd' is already NULL. break; case kBoolDtId: d->u.b = *(bool*)vp; break; case kUCharDtId: d->u.uc = *(unsigned char*)vp; break; case kCharDtId: d->u.c = *(char*)vp; break; case kUShortDtId: d->u.us = *(unsigned short*)vp; break; case kShortDtId: d->u.s = *(short*)vp; break; case kUIntDtId: d->u.ui = *(unsigned int*)vp; break; case kIntDtId: d->u.i = *(int*)vp; break; case kULongDtId: d->u.ul = *(unsigned long*)vp; break; case kLongDtId: d->u.l = *(long*)vp; break; case kFloatDtId: d->u.f = *(float*)vp; break; case kDoubleDtId: d->u.d = *(double*)vp; break; case kStrDtId: case kBlobDtId: { cmChar_t* blankStr = ""; // strings must have a byteCnt of at least one assert( tid==kBlobDtId || (tid==kStrDtId && byteCnt>0) ); // if a NULL source string is encountered then make it a 0 length string if( d->tid==kStrDtId && vp==NULL ) vp = blankStr; // if an empty blob was passed in then be sure it's src ptr is NULL and byteCnt==0 if( d->tid==kBlobDtId && (vp==NULL || byteCnt==0) ) { if((rc = _cmDataFreeData(d)) != kOkDtRC ) return rc; byteCnt = 0; d->u.z = NULL; break; } // if the incoming string/blob should be internally duplicated if( cmIsNotFlag(flags,kNoCopyDtFl) ) { // allocate internal space to store the incoming data if( (d->tid==kBlobDtId || d->tid == kStrDtId) && cmIsFlag(d->flags,kFreeValueDtFl) ) d->u.z = cmMemResize(char,d->u.z,byteCnt); else d->u.z = cmMemAlloc(char,byteCnt); // store the source string/blob into the internal memory buffer memcpy(d->u.z,vp,byteCnt); // be sure the string is zero terminated if( tid == kStrDtId ) d->u.z[byteCnt-1] = 0; // by default the system now takes responsibility for freeing this buffer d->flags |= kFreeValueDtFl; } else // the incoming string/blob pointer is simply being assigned w/o duplication { // free the objects previous value ... if((rc = _cmDataFreeData(d)) != kOkDtRC ) return rc; // and assign the new value (without reallocating the string) d->u.z = vp; d->flags = cmEnaFlag(d->flags,kFreeValueDtFl,cmIsFlag(flags,kFreeValueDtFl)); d->flags |= kNoCopyDtFl; } } break; default: break; } // we can't set this above because the string type relies // on knowing the previous type of the object d->cid = kScalarDtId; d->tid = tid; d->cnt = byteCnt; return rc; } cmDtRC_t cmDataSetNull( cmData_t* d ) { return cmDataSetScalarValue(d, kNullDtId, NULL, 0, kNoFlagsDtFl ); } cmDtRC_t cmDataSetBool( cmData_t* d, bool v ) { return cmDataSetScalarValue(d, kBoolDtId, &v, 0, kNoFlagsDtFl ); } cmDtRC_t cmDataSetChar( cmData_t* d, char v ) { return cmDataSetScalarValue(d, kCharDtId, &v, 0, kNoFlagsDtFl ); } cmDtRC_t cmDataSetUChar( cmData_t* d, unsigned char v ) { return cmDataSetScalarValue(d, kUCharDtId, &v, 0, kNoFlagsDtFl ); } cmDtRC_t cmDataSetShort( cmData_t* d, short v ) { return cmDataSetScalarValue(d, kShortDtId, &v, 0, kNoFlagsDtFl ); } cmDtRC_t cmDataSetUShort( cmData_t* d, unsigned short v ) { return cmDataSetScalarValue(d, kUShortDtId, &v, 0, kNoFlagsDtFl ); } cmDtRC_t cmDataSetInt( cmData_t* d, int v ) { return cmDataSetScalarValue(d, kIntDtId, &v, 0, kNoFlagsDtFl ); } cmDtRC_t cmDataSetUInt( cmData_t* d, unsigned int v ) { return cmDataSetScalarValue(d, kUIntDtId, &v, 0, kNoFlagsDtFl ); } cmDtRC_t cmDataSetLong( cmData_t* d, long v ) { return cmDataSetScalarValue(d, kLongDtId, &v, 0, kNoFlagsDtFl ); } cmDtRC_t cmDataSetULong( cmData_t* d, unsigned long v ) { return cmDataSetScalarValue(d, kULongDtId, &v, 0, kNoFlagsDtFl ); } cmDtRC_t cmDataSetFloat( cmData_t* d, float v ) { return cmDataSetScalarValue(d, kFloatDtId, &v, 0, kNoFlagsDtFl ); } cmDtRC_t cmDataSetDouble( cmData_t* d, double v ) { return cmDataSetScalarValue(d, kDoubleDtId, &v, 0, kNoFlagsDtFl ); } cmDtRC_t cmDataSetStr( cmData_t* d, unsigned flags, cmChar_t* v ) { return cmDataSetScalarValue(d, kStrDtId, v, v==NULL ? 1 : strlen(v)+1, flags ); } cmDtRC_t cmDataSetConstStr( cmData_t* d, unsigned flags, const cmChar_t* v ) { return cmDataSetScalarValue(d, kStrDtId, (void*)v, v==NULL ? 1 : strlen(v)+1, flags |= kConstValueDtFl ); } cmDtRC_t cmDataSetStrN( cmData_t* d, unsigned flags, cmChar_t* v, unsigned charCnt ) { return cmDataSetScalarValue(d, kStrDtId, (void*)v, v==NULL ? 1 : charCnt+1, flags); } cmDtRC_t cmDataSetConstStrN( cmData_t* d, unsigned flags, const cmChar_t* v, unsigned charCnt ) { return cmDataSetScalarValue(d, kStrDtId, (void*)v, v==NULL ? 1 : charCnt+1, flags |= kConstValueDtFl); } cmDtRC_t cmDataSetBlob( cmData_t* d, unsigned flags, void* v, unsigned byteCnt ) { return cmDataSetScalarValue(d, kBlobDtId, v, byteCnt, flags); } cmDtRC_t cmDataSetConstBlob( cmData_t* d, unsigned flags, const void* v, unsigned byteCnt ) { return cmDataSetScalarValue(d, kBlobDtId, (void*)v, byteCnt, flags |= kConstValueDtFl); } cmDtRC_t cmDataBool( const cmData_t* d, bool* v ) { if( d->tid != kBoolDtId ) return _cmDtErrMsg(d,kInvalidTypeDtRC,"Expected type:bool but encountered type:%s.",cmDataTypeToLabel(d->tid)); *v = d->u.c; return kOkDtRC; } cmDtRC_t cmDataChar( const cmData_t* d, char* v ) { if( d->tid != kCharDtId ) return _cmDtErrMsg(d,kInvalidTypeDtRC,"Expected type:char but encountered type:%s.",cmDataTypeToLabel(d->tid)); *v = d->u.c; return kOkDtRC; } cmDtRC_t cmDataUChar( const cmData_t* d, unsigned char* v ) { if( d->tid != kUCharDtId ) return _cmDtErrMsg(d,kInvalidTypeDtRC,"Expected type:uchar but encountered type:%s.",cmDataTypeToLabel(d->tid)); *v = d->u.uc; return kOkDtRC; } cmDtRC_t cmDataShort( const cmData_t* d, short* v ) { if( d->tid != kShortDtId ) return _cmDtErrMsg(d,kInvalidTypeDtRC,"Expected type:short but encountered type:%s.",cmDataTypeToLabel(d->tid)); *v = d->u.s; return kOkDtRC; } cmDtRC_t cmDataUShort( const cmData_t* d, unsigned short* v ) { if( d->tid != kUShortDtId ) return _cmDtErrMsg(d,kInvalidTypeDtRC,"Expected type:ushort but encountered type:%s.",cmDataTypeToLabel(d->tid)); *v = d->u.us; return kOkDtRC; } cmDtRC_t cmDataInt( const cmData_t* d, int* v ) { if( d->tid != kIntDtId ) return _cmDtErrMsg(d,kInvalidTypeDtRC,"Expected type:int but encountered type:%s.",cmDataTypeToLabel(d->tid)); *v = d->u.i; return kOkDtRC; } cmDtRC_t cmDataUInt( const cmData_t* d, unsigned int* v ) { if( d->tid != kUIntDtId ) return _cmDtErrMsg(d,kInvalidTypeDtRC,"Expected type:uint but encountered type:%s.",cmDataTypeToLabel(d->tid)); *v = d->u.ui; return kOkDtRC; } cmDtRC_t cmDataLong( const cmData_t* d, long* v ) { if( d->tid != kLongDtId ) return _cmDtErrMsg(d,kInvalidTypeDtRC,"Expected type:long but encountered type:%s.",cmDataTypeToLabel(d->tid)); *v = d->u.l; return kOkDtRC; } cmDtRC_t cmDataULong( const cmData_t* d, unsigned long* v ) { if( d->tid != kULongDtId ) return _cmDtErrMsg(d,kInvalidTypeDtRC,"Expected type:ulong but encountered type:%s.",cmDataTypeToLabel(d->tid)); *v = d->u.ul; return kOkDtRC; } cmDtRC_t cmDataFloat( const cmData_t* d, float* v ) { if( d->tid != kFloatDtId ) return _cmDtErrMsg(d,kInvalidTypeDtRC,"Expected type:float but encountered type:%s.",cmDataTypeToLabel(d->tid)); *v = d->u.f; return kOkDtRC; } cmDtRC_t cmDataDouble( const cmData_t* d, double* v ) { if( d->tid != kDoubleDtId ) return _cmDtErrMsg(d,kInvalidTypeDtRC,"Expected type:double but encountered type:%s.",cmDataTypeToLabel(d->tid)); *v = d->u.d; return kOkDtRC; } cmDtRC_t cmDataStr( const cmData_t* d, cmChar_t** v ) { if( d->tid != kStrDtId ) return _cmDtErrMsg(d,kInvalidTypeDtRC,"Expected type:string but encountered type:%s.",cmDataTypeToLabel(d->tid)); if( cmIsFlag(d->flags,kConstValueDtFl) ) return _cmDtErrMsg(d,kConstErrDtRC,"A const string cannot return as a non-const string."); *v = d->u.z; return kOkDtRC; } cmDtRC_t cmDataConstStr( const cmData_t* d, const cmChar_t** v ) { if( d->tid != kStrDtId ) return _cmDtErrMsg(d,kInvalidTypeDtRC,"Expected type:string but encountered type:%s.",cmDataTypeToLabel(d->tid)); *v = d->u.z; return kOkDtRC; } cmDtRC_t cmDataBlob( const cmData_t* d, void** v, unsigned* byteCntRef ) { if( v != NULL ) *v = NULL; if( byteCntRef != NULL ) *byteCntRef = 0; if( d->tid != kBlobDtId ) return _cmDtErrMsg(d,kInvalidTypeDtRC,"Expected type:string but encountered type:%s.",cmDataTypeToLabel(d->tid)); if( v != NULL ) *v = d->u.z; if( byteCntRef != NULL ) *byteCntRef = d->cnt; return kOkDtRC; } cmDtRC_t cmDataConstBlob( const cmData_t* d, const void** v, unsigned* byteCntRef ) { if( v != NULL ) *v = NULL; if( byteCntRef != NULL ) *byteCntRef = 0; if( d->tid != kBlobDtId ) return _cmDtErrMsg(d,kInvalidTypeDtRC,"Expected type:string but encountered type:%s.",cmDataTypeToLabel(d->tid)); if( v != NULL ) *v = d->u.z; if( byteCntRef != NULL ) *byteCntRef = d->cnt; return kOkDtRC; } bool cmDtBool( const cmData_t* p ) { bool v; if( cmDataBool(p,&v) != kOkDtRC ) v = kInvalidDtBool; return v; } char cmDtChar( const cmData_t* p ) { char v; if( cmDataChar(p,&v) != kOkDtRC ) v = kInvalidDtChar; return v; } unsigned char cmDtUChar( const cmData_t* p ) { unsigned char v; if( cmDataUChar(p,&v) != kOkDtRC ) v = kInvalidDtChar; return v; } short cmDtShort( const cmData_t* p ) { short v; if( cmDataShort(p,&v) != kOkDtRC ) v = kInvalidDtShort; return v; } unsigned short cmDtUShort( const cmData_t* p ) { unsigned short v; if( cmDataUShort(p,&v) != kOkDtRC ) v = kInvalidDtShort; return v; } int cmDtInt( const cmData_t* p ) { int v; if( cmDataInt(p,&v) != kOkDtRC ) v = kInvalidDtInt; return v; } unsigned cmDtUInt( const cmData_t* p ) { unsigned v; if( cmDataUInt(p,&v) != kOkDtRC ) v = kInvalidDtInt; return v; } long cmDtLong( const cmData_t* p ) { long v; if( cmDataLong(p,&v) != kOkDtRC ) v = kInvalidDtLong; return v; } unsigned long cmDtULong( const cmData_t* p ) { unsigned long v; if( cmDataULong(p,&v) != kOkDtRC ) v = kInvalidDtLong; return v; } float cmDtFloat( const cmData_t* p ) { float v; if( cmDataFloat(p,&v) != kOkDtRC ) v = kInvalidDtFloat; return v; } double cmDtDouble( const cmData_t* p ) { double v; if( cmDataDouble(p,&v) != kOkDtRC ) v = kInvalidDtDouble; return v; } char* cmDtStr( const cmData_t* p ) { char* v; if( cmDataStr(p,&v) != kOkDtRC ) v = NULL; return v; } const char* cmDtConstStr( const cmData_t* p ) { const char* v; if( cmDataConstStr(p,&v) != kOkDtRC ) v = NULL; return v; } void* cmDtBlob( const cmData_t* p, unsigned* byteCntRef ) { void* v; if( cmDataBlob(p,&v,byteCntRef) != kOkDtRC ) v = NULL; return v; } const void* cmDtConstBlob( const cmData_t* p, unsigned* byteCntRef ) { const void* v; if( cmDataConstBlob(p,&v,byteCntRef) != kOkDtRC ) v = NULL; return v; } cmDtRC_t cmDataGetBool( const cmData_t* p, bool* vp ) { if( p->cid != kScalarDtId ) return _cmDtErrMsg(p,kInvalidContDtRC,"Cannot convert a non-scalar value to a scalar value."); switch( p->tid ) { case kBoolDtId: *vp = p->u.b; break; case kUCharDtId: *vp = (bool)p->u.uc; break; case kCharDtId: *vp = (bool)p->u.c; break; case kUShortDtId: *vp = (bool)p->u.us; break; case kShortDtId: *vp = (bool)p->u.s; break; case kUIntDtId: *vp = (bool)p->u.ui; break; case kIntDtId: *vp = (bool)p->u.i; break; case kULongDtId: *vp = (bool)p->u.ul; break; case kLongDtId: *vp = (bool)p->u.l; break; case kFloatDtId: *vp = (bool)p->u.f; break; case kDoubleDtId: *vp = (bool)p->u.d; break; default: return _cmDtErrMsg(p,kCvtErrDtRC,"Cannot convert '%s' to 'bool'.",cmDataTypeToLabel(p->tid)); } return kOkDtRC; } cmDtRC_t cmDataGetUChar( const cmData_t* p, unsigned char* vp ) { if( p->cid != kScalarDtId ) return _cmDtErrMsg(p,kInvalidContDtRC,"Cannot convert a non-scalar value to a scalar value."); switch( p->tid ) { case kUCharDtId: *vp = p->u.uc; break; case kBoolDtId: *vp = (unsigned char)p->u.b; break; case kCharDtId: *vp = (unsigned char)p->u.c; break; case kUShortDtId: *vp = (unsigned char)p->u.us; break; case kShortDtId: *vp = (unsigned char)p->u.s; break; case kUIntDtId: *vp = (unsigned char)p->u.ui; break; case kIntDtId: *vp = (unsigned char)p->u.i; break; case kULongDtId: *vp = (unsigned char)p->u.ul; break; case kLongDtId: *vp = (unsigned char)p->u.l; break; case kFloatDtId: *vp = (unsigned char)p->u.f; break; case kDoubleDtId: *vp = (unsigned char)p->u.d; break; default: return _cmDtErrMsg(p,kCvtErrDtRC,"Cannot convert '%s' to 'uchar'.",cmDataTypeToLabel(p->tid)); } return kOkDtRC; } cmDtRC_t cmDataGetChar( const cmData_t* p, char* vp ) { if( p->cid != kScalarDtId ) return _cmDtErrMsg(p,kInvalidContDtRC,"Cannot convert a non-scalar value to a scalar value."); switch( p->tid ) { case kBoolDtId: *vp = (char)p->u.b; break; case kUCharDtId: *vp = (char)p->u.uc; break; case kCharDtId: *vp = p->u.c; break; case kUShortDtId: *vp = (char)p->u.us; break; case kShortDtId: *vp = (char)p->u.s; break; case kUIntDtId: *vp = (char)p->u.ui; break; case kIntDtId: *vp = (char)p->u.i; break; case kULongDtId: *vp = (char)p->u.ul; break; case kLongDtId: *vp = (char)p->u.l; break; case kFloatDtId: *vp = (char)p->u.f; break; case kDoubleDtId: *vp = (char)p->u.d; break; default: return _cmDtErrMsg(p,kCvtErrDtRC,"Cannot convert '%s' to 'char'.",cmDataTypeToLabel(p->tid)); } return kOkDtRC; } cmDtRC_t cmDataGetShort( const cmData_t* p, short* vp ) { if( p->cid != kScalarDtId ) return _cmDtErrMsg(p,kInvalidContDtRC,"Cannot convert a non-scalar value to a scalar value."); switch( p->tid ) { case kBoolDtId: *vp = (short)p->u.b; break; case kUCharDtId: *vp = (short)p->u.uc; break; case kCharDtId: *vp = (short)p->u.c; break; case kUShortDtId: *vp = (short)p->u.us; break; case kShortDtId: *vp = p->u.s; break; case kUIntDtId: *vp = (short)p->u.ui; break; case kIntDtId: *vp = (short)p->u.i; break; case kULongDtId: *vp = (short)p->u.ul; break; case kLongDtId: *vp = (short)p->u.l; break; case kFloatDtId: *vp = (short)p->u.f; break; case kDoubleDtId: *vp = (short)p->u.d; break; default: return _cmDtErrMsg(p,kCvtErrDtRC,"Cannot convert '%s' to 'short'.",cmDataTypeToLabel(p->tid)); } return kOkDtRC; } cmDtRC_t cmDataGetUShort( const cmData_t* p, unsigned short* vp ) { if( p->cid != kScalarDtId ) return _cmDtErrMsg(p,kInvalidContDtRC,"Cannot convert a non-scalar value to a scalar value."); switch( p->tid ) { case kBoolDtId: *vp = (unsigned short)p->u.b; break; case kUCharDtId: *vp = (unsigned short)p->u.uc; break; case kCharDtId: *vp = (unsigned short)p->u.c; break; case kUShortDtId: *vp = p->u.us; break; case kShortDtId: *vp = (unsigned short)p->u.s; break; case kUIntDtId: *vp = (unsigned short)p->u.ui; break; case kIntDtId: *vp = (unsigned short)p->u.i; break; case kULongDtId: *vp = (unsigned short)p->u.ul; break; case kLongDtId: *vp = (unsigned short)p->u.l; break; case kFloatDtId: *vp = (unsigned short)p->u.f; break; case kDoubleDtId: *vp = (unsigned short)p->u.d; break; default: return _cmDtErrMsg(p,kCvtErrDtRC,"Cannot convert '%s' to 'ushort'.",cmDataTypeToLabel(p->tid)); } return kOkDtRC; } cmDtRC_t cmDataGetInt( const cmData_t* p, int* vp ) { if( p->cid != kScalarDtId ) return _cmDtErrMsg(p,kInvalidContDtRC,"Cannot convert a non-scalar value to a scalar value."); switch( p->tid ) { case kBoolDtId: *vp = (int)p->u.b; break; case kUCharDtId: *vp = (int)p->u.uc; break; case kCharDtId: *vp = (int)p->u.c; break; case kUShortDtId: *vp = (int)p->u.us; break; case kShortDtId: *vp = (int)p->u.s; break; case kUIntDtId: *vp = (int)p->u.ui; break; case kIntDtId: *vp = p->u.i; break; case kULongDtId: *vp = (int)p->u.ul; break; case kLongDtId: *vp = (int)p->u.l; break; case kFloatDtId: *vp = (int)p->u.f; break; case kDoubleDtId: *vp = (int)p->u.d; break; default: return _cmDtErrMsg(p,kCvtErrDtRC,"Cannot convert '%s' to 'int'.",cmDataTypeToLabel(p->tid)); } return kOkDtRC; } cmDtRC_t cmDataGetUInt( const cmData_t* p, unsigned int* vp ) { if( p->cid != kScalarDtId ) return _cmDtErrMsg(p,kInvalidContDtRC,"Cannot convert a non-scalar value to a scalar value."); switch( p->tid ) { case kBoolDtId: *vp = (unsigned int)p->u.b; break; case kUCharDtId: *vp = (unsigned int)p->u.uc; break; case kCharDtId: *vp = (unsigned int)p->u.c; break; case kUShortDtId: *vp = (unsigned int)p->u.us; break; case kShortDtId: *vp = (unsigned int)p->u.s; break; case kUIntDtId: *vp = p->u.ui; break; case kIntDtId: *vp = (unsigned int)p->u.i; break; case kULongDtId: *vp = (unsigned int)p->u.ul; break; case kLongDtId: *vp = (unsigned int)p->u.l; break; case kFloatDtId: *vp = (unsigned int)p->u.f; break; case kDoubleDtId: *vp = (unsigned int)p->u.d; break; default: return _cmDtErrMsg(p,kCvtErrDtRC,"Cannot convert '%s' to 'uint'.",cmDataTypeToLabel(p->tid)); } return kOkDtRC; } cmDtRC_t cmDataGetLong( const cmData_t* p, long* vp ) { if( p->cid != kScalarDtId ) return _cmDtErrMsg(p,kInvalidContDtRC,"Cannot convert a non-scalar value to a scalar value."); switch( p->tid ) { case kBoolDtId: *vp = (long)p->u.b; break; case kUCharDtId: *vp = (long)p->u.uc; break; case kCharDtId: *vp = (long)p->u.c; break; case kUShortDtId: *vp = (long)p->u.us; break; case kShortDtId: *vp = (long)p->u.s; break; case kUIntDtId: *vp = (long)p->u.ui; break; case kIntDtId: *vp = (long)p->u.i; break; case kULongDtId: *vp = (long)p->u.ul; break; case kLongDtId: *vp = p->u.l; break; case kFloatDtId: *vp = (long)p->u.f; break; case kDoubleDtId: *vp = (long)p->u.d; break; default: return _cmDtErrMsg(p,kCvtErrDtRC,"Cannot convert '%s' to 'long'.",cmDataTypeToLabel(p->tid)); } return kOkDtRC; } cmDtRC_t cmDataGetULong( const cmData_t* p, unsigned long* vp ) { if( p->cid != kScalarDtId ) return _cmDtErrMsg(p,kInvalidContDtRC,"Cannot convert a non-scalar value to a scalar value."); switch( p->tid ) { case kBoolDtId: *vp = (unsigned long)p->u.b; break; case kUCharDtId: *vp = (unsigned long)p->u.uc; break; case kCharDtId: *vp = (unsigned long)p->u.c; break; case kUShortDtId: *vp = (unsigned long)p->u.us; break; case kShortDtId: *vp = (unsigned long)p->u.s; break; case kUIntDtId: *vp = (unsigned long)p->u.ui; break; case kIntDtId: *vp = (unsigned long)p->u.i; break; case kULongDtId: *vp = p->u.ul; break; case kLongDtId: *vp = (unsigned long)p->u.l; break; case kFloatDtId: *vp = (unsigned long)p->u.f; break; case kDoubleDtId: *vp = (unsigned long)p->u.d; break; default: return _cmDtErrMsg(p,kCvtErrDtRC,"Cannot convert '%s' to 'ulong'.",cmDataTypeToLabel(p->tid)); } return kOkDtRC; } cmDtRC_t cmDataGetFloat( const cmData_t* p, float* vp ) { if( p->cid != kScalarDtId ) return _cmDtErrMsg(p,kInvalidContDtRC,"Cannot convert a non-scalar value to a scalar value."); switch( p->tid ) { case kBoolDtId: *vp = (float)p->u.b; break; case kUCharDtId: *vp = (float)p->u.uc; break; case kCharDtId: *vp = (float)p->u.c; break; case kUShortDtId: *vp = (float)p->u.us; break; case kShortDtId: *vp = (float)p->u.s; break; case kUIntDtId: *vp = (float)p->u.ui; break; case kIntDtId: *vp = (float)p->u.i; break; case kULongDtId: *vp = (float)p->u.ul; break; case kLongDtId: *vp = (float)p->u.l; break; case kFloatDtId: *vp = p->u.f; break; case kDoubleDtId: *vp = (float)p->u.d; break; default: return _cmDtErrMsg(p,kCvtErrDtRC,"Cannot convert '%s' to 'float'.",cmDataTypeToLabel(p->tid)); } return kOkDtRC; } cmDtRC_t cmDataGetDouble( const cmData_t* p, double* vp ) { if( p->cid != kScalarDtId ) return _cmDtErrMsg(p,kInvalidContDtRC,"Cannot convert a non-scalar value to a scalar value."); switch( p->tid ) { case kBoolDtId: *vp = (double)p->u.b; break; case kUCharDtId: *vp = (double)p->u.uc; break; case kCharDtId: *vp = (double)p->u.c; break; case kUShortDtId: *vp = (double)p->u.us; break; case kShortDtId: *vp = (double)p->u.s; break; case kUIntDtId: *vp = (double)p->u.ui; break; case kIntDtId: *vp = (double)p->u.i; break; case kULongDtId: *vp = (double)p->u.ul; break; case kLongDtId: *vp = (double)p->u.l; break; case kFloatDtId: *vp = (double)p->u.f; break; case kDoubleDtId: *vp = p->u.d; break; default: return _cmDtErrMsg(p,kCvtErrDtRC,"Cannot convert '%s' to 'double'.",cmDataTypeToLabel(p->tid)); } return kOkDtRC; } char cmDtGetChar( const cmData_t* p ) { char v; if( cmDataGetChar(p,&v) != kOkDtRC ) v = kInvalidDtChar; return v; } unsigned char cmDtGetUChar( const cmData_t* p ) { unsigned char v; if( cmDataGetUChar(p,&v) != kOkDtRC ) v = kInvalidDtChar; return v; } short cmDtGetShort( const cmData_t* p ) { short v; if( cmDataGetShort(p,&v) != kOkDtRC ) v = kInvalidDtShort; return v; } unsigned short cmDtGetUShort( const cmData_t* p ) { unsigned short v; if( cmDataGetUShort(p,&v) != kOkDtRC ) v = kInvalidDtShort; return v; } int cmDtGetInt( const cmData_t* p ) { int v; if( cmDataGetInt(p,&v) != kOkDtRC ) v = kInvalidDtInt; return v; } unsigned cmDtGetUInt( const cmData_t* p ) { unsigned v; if( cmDataGetUInt(p,&v) != kOkDtRC ) v = kInvalidDtInt; return v; } long cmDtGetLong( const cmData_t* p ) { long v; if( cmDataGetLong(p,&v) != kOkDtRC ) v = kInvalidDtLong; return v; } unsigned long cmDtGetULong( const cmData_t* p ) { unsigned long v; if( cmDataGetULong(p,&v) != kOkDtRC ) v = kInvalidDtLong; return v; } float cmDtGetFloat( const cmData_t* p ) { float v; if( cmDataGetFloat(p,&v) != kOkDtRC ) v = kInvalidDtFloat; return v; } double cmDtGetDouble( const cmData_t* p ) { double v; if( cmDataGetDouble(p,&v) != kOkDtRC ) v = kInvalidDtDouble; return v; } cmDtRC_t cmDataNewArray( cmData_t* parent, cmDataTypeId_t tid, void* vp, unsigned eleCnt, unsigned flags, cmData_t** ref ) { cmDtRC_t rc; if( ref != NULL ) *ref = NULL; // create a new 'null' object cmData_t* d = _cmDataNew(parent, kScalarDtId, kNullDtId ); // assign the value if((rc = cmDataSetArrayValue(d,tid,vp,eleCnt,flags)) != kOkDtRC ) return rc; // set the flags for the new object d->flags = cmSetFlag(d->flags, flags & (kConstValueDtFl | kConstObjDtFl | kNoCopyDtFl)); if( ref != NULL ) *ref = d; return rc; } cmDtRC_t cmDataNewBoolArray( cmData_t* parent, bool* v, unsigned eleCnt, unsigned flags, cmData_t** ref ) { return cmDataNewArray(parent, kBoolDtId, v, eleCnt, flags, ref ); } cmDtRC_t cmDataNewCharArray( cmData_t* parent, char* v, unsigned eleCnt, unsigned flags, cmData_t** ref ) { return cmDataNewArray(parent, kCharDtId, v, eleCnt, flags, ref ); } cmDtRC_t cmDataNewUCharArray( cmData_t* parent, unsigned char* v, unsigned eleCnt, unsigned flags, cmData_t** ref ) { return cmDataNewArray(parent, kUCharDtId, v, eleCnt, flags, ref ); } cmDtRC_t cmDataNewShortArray( cmData_t* parent, short* v, unsigned eleCnt, unsigned flags, cmData_t** ref ) { return cmDataNewArray(parent, kShortDtId, v, eleCnt, flags, ref ); } cmDtRC_t cmDataNewUShortArray( cmData_t* parent, unsigned short* v, unsigned eleCnt, unsigned flags, cmData_t** ref ) { return cmDataNewArray(parent, kUShortDtId, v, eleCnt, flags, ref ); } cmDtRC_t cmDataNewIntArray( cmData_t* parent, int* v, unsigned eleCnt, unsigned flags, cmData_t** ref ) { return cmDataNewArray(parent, kIntDtId, v, eleCnt, flags, ref ); } cmDtRC_t cmDataNewUIntArray( cmData_t* parent, unsigned int* v, unsigned eleCnt, unsigned flags, cmData_t** ref ) { return cmDataNewArray(parent, kUIntDtId, v, eleCnt, flags, ref ); } cmDtRC_t cmDataNewLongArray( cmData_t* parent, long* v, unsigned eleCnt, unsigned flags, cmData_t** ref ) { return cmDataNewArray(parent, kLongDtId, v, eleCnt, flags, ref ); } cmDtRC_t cmDataNewULongArray( cmData_t* parent, unsigned long* v, unsigned eleCnt, unsigned flags, cmData_t** ref ) { return cmDataNewArray(parent, kULongDtId, v, eleCnt, flags, ref ); } cmDtRC_t cmDataNewFloatArray( cmData_t* parent, float* v, unsigned eleCnt, unsigned flags, cmData_t** ref ) { return cmDataNewArray(parent, kFloatDtId, v, eleCnt, flags, ref ); } cmDtRC_t cmDataNewDoubleArray( cmData_t* parent, double* v, unsigned eleCnt, unsigned flags, cmData_t** ref ) { return cmDataNewArray(parent, kDoubleDtId, v, eleCnt, flags, ref ); } cmDtRC_t cmDataNewStrArray( cmData_t* parent, cmChar_t** v, unsigned eleCnt, unsigned flags, cmData_t** ref ) { return cmDataNewArray(parent, kStrDtId, v, eleCnt, flags, ref ); } cmDtRC_t cmDataNewConstStrArray( cmData_t* parent, const cmChar_t** v,unsigned eleCnt, unsigned flags, cmData_t** ref ) { return cmDataNewArray(parent, kStrDtId, (cmChar_t**)v, eleCnt, flags, ref ); } cmDtRC_t cmDataSetArrayValue( cmData_t* d, cmDataTypeId_t tid, void* vp, unsigned eleCnt, unsigned flags ) { cmDtRC_t rc = kOkDtRC; // if the type of the object is changing if( d->tid != tid || d->cid != kScalarDtId ) { // verify that it is legal to change the type of the object if( cmIsFlag(d->flags,kConstObjDtFl) ) return _cmDtErrMsg(d,kConstErrDtRC,"Const object violation."); // convert this to a scalar null object. if((rc = _cmDataFreeData(d)) != kOkDtRC ) return rc; } // verify that it is legal to change the value of this object if( cmIsFlag(d->flags,kConstValueDtFl) ) return _cmDtErrMsg(d,kConstErrDtRC,"Const value violation."); // if the array should be reallocated if( cmIsNotFlag(flags,kNoCopyDtFl) ) { unsigned byteCnt = cmDataByteWidth(tid) * eleCnt; // reallocate a new string if( d->cid == kArrayDtId && cmIsFlag(d->flags,kFreeValueDtFl) ) d->u.vp = cmMemResize(char,d->u.z,byteCnt); else d->u.vp = cmMemAlloc(char,byteCnt); memcpy(d->u.z,vp,byteCnt); d->flags |= kFreeValueDtFl; } else { // free the previous value ... if((rc = _cmDataFreeData(d)) != kOkDtRC ) return rc; // and assign the new value (without reallocating the array) d->u.vp = vp; d->flags = cmEnaFlag(d->flags,kFreeValueDtFl,cmIsFlag(flags,kFreeValueDtFl)); } // we can't set this above because the string type relies // on knowing the previous type of the object d->cid = kArrayDtId; d->tid = tid; d->cnt = eleCnt; return rc; } cmDtRC_t cmDataSetBoolArray( cmData_t* d, bool* v, unsigned eleCnt, unsigned flags ) { return cmDataSetArrayValue(d, kBoolDtId, v, eleCnt, flags ); } cmDtRC_t cmDataSetCharArray( cmData_t* d, char* v, unsigned eleCnt, unsigned flags ) { return cmDataSetArrayValue(d, kCharDtId, v, eleCnt, flags ); } cmDtRC_t cmDataSetUCharArray( cmData_t* d, unsigned char* v, unsigned eleCnt, unsigned flags ) { return cmDataSetArrayValue(d, kUCharDtId, v, eleCnt, flags ); } cmDtRC_t cmDataSetShortArray( cmData_t* d, short* v, unsigned eleCnt, unsigned flags ) { return cmDataSetArrayValue(d, kShortDtId, v, eleCnt, flags ); } cmDtRC_t cmDataSetUShortArray( cmData_t* d, unsigned short* v, unsigned eleCnt, unsigned flags ) { return cmDataSetArrayValue(d, kUShortDtId, v, eleCnt, flags ); } cmDtRC_t cmDataSetIntArray( cmData_t* d, int* v, unsigned eleCnt, unsigned flags ) { return cmDataSetArrayValue(d, kIntDtId, v, eleCnt, flags ); } cmDtRC_t cmDataSetUIntArray( cmData_t* d, unsigned int* v, unsigned eleCnt, unsigned flags ) { return cmDataSetArrayValue(d, kUIntDtId, v, eleCnt, flags ); } cmDtRC_t cmDataSetLongArray( cmData_t* d, long* v, unsigned eleCnt, unsigned flags ) { return cmDataSetArrayValue(d, kLongDtId, v, eleCnt, flags ); } cmDtRC_t cmDataSetULongArray( cmData_t* d, unsigned long* v, unsigned eleCnt, unsigned flags ) { return cmDataSetArrayValue(d, kULongDtId, v, eleCnt, flags ); } cmDtRC_t cmDataSetFloatArray( cmData_t* d, float* v, unsigned eleCnt, unsigned flags ) { return cmDataSetArrayValue(d, kFloatDtId, v, eleCnt, flags ); } cmDtRC_t cmDataSetDoubleArray( cmData_t* d, double* v, unsigned eleCnt, unsigned flags ) { return cmDataSetArrayValue(d, kDoubleDtId, v, eleCnt, flags ); } cmDtRC_t cmDataSetStrArray( cmData_t* d, cmChar_t** v, unsigned eleCnt, unsigned flags ) { return cmDataSetArrayValue(d, kStrDtId, v, eleCnt, flags ); } cmDtRC_t cmDataSetConstStrArray(cmData_t* d,const cmChar_t** v,unsigned eleCnt, unsigned flags ) { return cmDataSetArrayValue(d, kStrDtId, (cmChar_t**)v, eleCnt, flags ); } unsigned cmDataArrayEleCount( const cmData_t* d ) { return d->cid==kArrayDtId ? d->cnt : 0; } cmDtRC_t cmDataBoolArray( const cmData_t* d, bool** v ) { if( d->cid != kArrayDtId ) return _cmDtErrMsg(d,kInvalidContDtRC,"Cannot return an array base for a %s container.",cmDataContainerIdToLabel(d->cid)); *v = (bool*)d->u.vp; return kOkDtRC; } cmDtRC_t cmDataCharArray( const cmData_t* d, char** v ) { if( d->cid != kArrayDtId ) return _cmDtErrMsg(d,kInvalidContDtRC,"Cannot return an array base for a %s container.",cmDataContainerIdToLabel(d->cid)); *v = (char*)d->u.vp; return kOkDtRC; } cmDtRC_t cmDataUCharArray( const cmData_t* d, unsigned char** v ) { if( d->cid != kArrayDtId ) return _cmDtErrMsg(d,kInvalidContDtRC,"Cannot return an array base for a %s container.",cmDataContainerIdToLabel(d->cid)); *v = (unsigned char*)d->u.vp; return kOkDtRC; } cmDtRC_t cmDataShortArray( const cmData_t* d, short** v ) { if( d->cid != kArrayDtId ) return _cmDtErrMsg(d,kInvalidContDtRC,"Cannot return an array base for a %s container.",cmDataContainerIdToLabel(d->cid)); *v = (short*)d->u.vp; return kOkDtRC; } cmDtRC_t cmDataUShortArray( const cmData_t* d, unsigned short** v ) { if( d->cid != kArrayDtId ) return _cmDtErrMsg(d,kInvalidContDtRC,"Cannot return an array base for a %s container.",cmDataContainerIdToLabel(d->cid)); *v = (unsigned short*)d->u.vp; return kOkDtRC; } cmDtRC_t cmDataIntArray( const cmData_t* d, int** v ) { if( d->cid != kArrayDtId ) return _cmDtErrMsg(d,kInvalidContDtRC,"Cannot return an array base for a %s container.",cmDataContainerIdToLabel(d->cid)); *v = (int*)d->u.vp; return kOkDtRC; } cmDtRC_t cmDataUIntArray( const cmData_t* d, unsigned int** v ) { if( d->cid != kArrayDtId ) return _cmDtErrMsg(d,kInvalidContDtRC,"Cannot return an array base for a %s container.",cmDataContainerIdToLabel(d->cid)); *v = (unsigned int*)d->u.vp; return kOkDtRC; } cmDtRC_t cmDataLongArray( const cmData_t* d, long** v ) { if( d->cid != kArrayDtId ) return _cmDtErrMsg(d,kInvalidContDtRC,"Cannot return an array base for a %s container.",cmDataContainerIdToLabel(d->cid)); *v = (long*)d->u.vp; return kOkDtRC; } cmDtRC_t cmDataULongArray( const cmData_t* d, unsigned long** v ) { if( d->cid != kArrayDtId ) return _cmDtErrMsg(d,kInvalidContDtRC,"Cannot return an array base for a %s container.",cmDataContainerIdToLabel(d->cid)); *v = (unsigned long*)d->u.vp; return kOkDtRC; } cmDtRC_t cmDataFloatArray( const cmData_t* d, float** v ) { if( d->cid != kArrayDtId ) return _cmDtErrMsg(d,kInvalidContDtRC,"Cannot return an array base for a %s container.",cmDataContainerIdToLabel(d->cid)); *v = (float*)d->u.vp; return kOkDtRC; } cmDtRC_t cmDataDoubleArray( const cmData_t* d, double** v ) { if( d->cid != kArrayDtId ) return _cmDtErrMsg(d,kInvalidContDtRC,"Cannot return an array base for a %s container.",cmDataContainerIdToLabel(d->cid)); *v = (double*)d->u.vp; return kOkDtRC; } bool* cmDtBoolArray( const cmData_t* d ) { bool* v = NULL; if( cmDataBoolArray(d,&v) != kOkDtRC ) return NULL; return v; } char* cmDtCharArray( const cmData_t* d ) { char* v = NULL; if( cmDataCharArray(d,&v) != kOkDtRC ) return NULL; return v; } unsigned char* cmDtUCharArray( const cmData_t* d ) { unsigned char* v = NULL; if( cmDataUCharArray(d,&v) != kOkDtRC ) return NULL; return v; } short* cmDtShortArray( const cmData_t* d ) { short* v = NULL; if( cmDataShortArray(d,&v) != kOkDtRC ) return NULL; return v; } unsigned short* cmDtUShortArray( const cmData_t* d ) { unsigned short* v = NULL; if( cmDataUShortArray(d,&v) != kOkDtRC ) return NULL; return v; } int* cmDtIntArray( const cmData_t* d ) { int* v = NULL; if( cmDataIntArray(d,&v) != kOkDtRC ) return NULL; return v; } unsigned* cmDtUIntArray( const cmData_t* d ) { unsigned* v = NULL; if( cmDataUIntArray(d,&v) != kOkDtRC ) return NULL; return v; } long* cmDtLongArray( const cmData_t* d ) { long* v = NULL; if( cmDataLongArray(d,&v) != kOkDtRC ) return NULL; return v; } unsigned long* cmDtULongArray( const cmData_t* d ) { unsigned long* v = NULL; if( cmDataULongArray(d,&v) != kOkDtRC ) return NULL; return v; } float* cmDtFloatArray( const cmData_t* d ) { float* v = NULL; if( cmDataFloatArray(d,&v) != kOkDtRC ) return NULL; return v; } double* cmDtDoubleArray( const cmData_t* d ) { double* v = NULL; if( cmDataDoubleArray(d,&v) != kOkDtRC ) return NULL; return v; } //---------------------------------------------------------------------------- // Structure related functions // void cmDataFree( cmData_t* p ) { _cmDataFree(p); } cmData_t* cmDataUnlink( cmData_t* p ) { if( p->parent == NULL ) return p; assert( cmDataIsStruct(p->parent) ); cmData_t* cp = p->u.child; cmData_t* pp = NULL; for(; cp!=NULL; cp=cp->sibling) if( cp == p ) { if( pp == NULL ) p->parent->u.child = p->sibling; else pp->sibling = cp->sibling; } return p; } void cmDataUnlinkAndFree( cmData_t* p ) { cmDataUnlink(p); cmDataFree(p); } cmDtRC_t _cmDataDupl( const cmData_t* d, cmData_t* parent, cmData_t** ref ) { cmDtRC_t rc = kOkDtRC; cmData_t* rp = NULL; *ref = NULL; switch( d->cid ) { case kScalarDtId: if( d->tid == kBlobDtId || d->tid == kStrDtId ) rc = cmDataNewScalar(parent, d->tid, d->flags, d->u.vp, d->cnt, &rp ); else rc = cmDataNewScalar(parent, d->tid, d->flags, d->u.vp, 0, &rp ); break; case kArrayDtId: rc = cmDataNewArray(parent, d->tid, d->u.vp, d->cnt, d->flags, &rp ); break; case kListDtId: case kPairDtId: case kRecordDtId: { rp = _cmDataNew(parent,d->cid,d->tid); const cmData_t* cp = d->u.child; for(; cp!=NULL; cp=cp->sibling) { cmData_t* ncp = NULL; // duplicate the child (ncp) and append it to the parent (rp) if((rc = _cmDataDupl(cp,rp,&ncp)) == kOkDtRC ) cmDataAppendChild(rp,ncp); } } break; default: assert(0); break; } if( rp != NULL ) *ref = rp; return rc; } cmRC_t cmDataDupl( const cmData_t* p, cmData_t** ref ) { return _cmDataDupl(p,NULL,ref); } cmData_t* cmDataReplace( cmData_t* dst, cmData_t* src ) { if( dst->parent == NULL ) { cmDataUnlinkAndFree(dst); src->parent = NULL; return src; } cmData_t* parent = dst->parent; cmData_t* cp = parent->u.child; cmData_t* pp = NULL; unsigned i = 0; unsigned n = cmDataChildCount(parent); // locate dst's right sibling for(i=0; isibling) { if( cp == dst ) { // link in 'src' in place of 'dst' src->sibling = dst->sibling; // free dst cmDataUnlinkAndFree(dst); // update the sibling link to if( pp == NULL ) parent->u.child = src; else pp->sibling = src; src->parent = parent; break; } pp = cp; } return src; } unsigned cmDataChildCount( const cmData_t* p ) { if( !cmDataIsStruct(p) ) return 0; unsigned n = 0; const cmData_t* cp = p->u.child; for(; cp!=NULL; cp=cp->sibling) ++n; return n; } cmData_t* cmDataChild( cmData_t* p, unsigned index ) { if( !cmDataIsStruct(p) ) return NULL; unsigned n = 0; cmData_t* cp = p->u.child; for(; cp!=NULL; cp=cp->sibling) { if( n == index ) break; ++n; } return cp; } cmData_t* cmDataPrependChild(cmData_t* parent, cmData_t* p ) { assert( cmDataIsStruct(p) ); cmDataUnlink(p); p->u.child = parent->u.child; parent->u.child = p; p->parent = parent; return p; } cmData_t* cmDataAppendChild( cmData_t* parent, cmData_t* p ) { assert( cmDataIsStruct(parent) ); assert( parent->cid != kRecordDtId || (parent->cid == kRecordDtId && p->cid==kPairDtId)); cmDataUnlink(p); cmData_t* cp = parent->u.child; if( cp == NULL ) parent->u.child = p; else { for(; cp!=NULL; cp=cp->sibling) if( cp->sibling == NULL ) { cp->sibling = p; break; } } p->parent = parent; p->sibling = NULL; return p; } cmData_t* cmDataInsertChild( cmData_t* parent, unsigned index, cmData_t* p ) { if( !cmDataIsStruct(parent) ) return NULL; cmDataUnlink(p); unsigned n = 0; cmData_t* cp = parent->u.child; cmData_t* pp = NULL; for(; cp!=NULL; cp=cp->sibling) { if( n == index ) { if( pp == NULL ) { parent->u.child = p; p->sibling = NULL; } else { p->sibling = pp->sibling; pp->sibling = p; } break; } ++n; } p->parent = parent; return p; } //---------------------------------------------------------------------------- bool _cmDataPairIsValid( const cmData_t* p ) { assert( p->cid == kPairDtId && p->tid==kStructDtId ); bool fl = p->u.child == NULL || p->u.child->sibling == NULL || p->u.child->sibling->sibling!=NULL; return !fl; } // Get the key/value of a pair cmData_t* cmDataPairKey( cmData_t* p ) { assert( _cmDataPairIsValid(p) ); return p->u.child; } unsigned cmDataPairKeyId( cmData_t* p ) { assert( _cmDataPairIsValid(p) ); unsigned id = cmInvalidId; cmDataGetUInt(p->u.child,&id); return id; } const cmChar_t* cmDataPairKeyLabel( cmData_t* p ) { assert( _cmDataPairIsValid(p) ); const cmChar_t* label = NULL; cmDataConstStr(p->u.child,&label); return label; } cmData_t* cmDataPairValue( cmData_t* p ) { assert( _cmDataPairIsValid(p) ); return p->u.child->sibling; } // Set the key or value of an existing pair node. cmData_t* cmDataPairSetValue( cmData_t* p, cmData_t* value ) { assert( _cmDataPairIsValid(p) ); cmDataReplace( cmDataPairValue(p), value ); return p; } cmData_t* cmDataPairSetKey( cmData_t* p, cmData_t* key ) { assert( _cmDataPairIsValid(p) ); cmDataReplace( cmDataPairValue(p), key ); return p; } cmData_t* cmDataPairSetKeyId( cmData_t* p, unsigned id ) { assert( _cmDataPairIsValid(p) ); cmDataSetUInt(p->u.child,id); return p; } cmData_t* cmDataPairSetKeyLabel( cmData_t* p, const cmChar_t* label ) { assert( _cmDataPairIsValid(p) ); cmDataSetConstStr(p->u.child,kNoFlagsDtFl,label); return p; } cmData_t* cmDataPairMake( cmData_t* parent, cmData_t* p, cmData_t* key, cmData_t* value ) { cmDataUnlink(p); _cmDataFreeData(p); p->tid = kStructDtId; p->cid = kPairDtId; p->parent = parent; p->flags = cmIsFlag(p->flags,kFreeObjDtFl) ? kFreeObjDtFl : 0; p->u.child = NULL; cmDataAppendChild(p,key); cmDataAppendChild(p,value); return p; } // Dynamically allocate a pair node cmRC_t cmDataPairAlloc( cmData_t* parent, const cmData_t* key, const cmData_t* value, cmData_t** ref ) { cmRC_t rc = kOkDtRC; cmData_t* p = _cmDataNew(parent,kPairDtId,kStructDtId); cmData_t* kp = NULL; cmData_t* vp = NULL; if( ref != NULL ) *ref = NULL; if((rc = cmDataDupl(key,&kp)) != kOkDtRC ) goto errLabel; if((rc = cmDataDupl(value,&vp)) != kOkDtRC ) goto errLabel; cmDataPrependChild(p,vp); cmDataPrependChild(p,kp); if( ref != NULL ) *ref = p; errLabel: if( rc != kOkDtRC ) { cmDataFree(kp); cmDataFree(vp); cmDataFree(p); } return rc; } cmRC_t cmDataPairAllocId(cmData_t* parent, unsigned keyId, cmData_t* value, cmData_t** ref ) { cmRC_t rc = kOkDtRC; if( ref != NULL ) *ref = NULL; cmData_t* p = _cmDataNew(parent,kPairDtId,kStructDtId); if((rc = cmDataNewUInt(p,kNoFlagsDtFl,keyId,NULL)) != kOkDtRC ) goto errLabel; cmDataAppendChild(p,value); if( ref != NULL ) *ref = p; errLabel: if( rc != kOkDtRC ) cmDataFree(p); return rc; } cmRC_t cmDataPairAllocLabel( cmData_t* parent, const cmChar_t *label, cmData_t* value, cmData_t** ref ) { cmRC_t rc = kOkDtRC; cmData_t* p = _cmDataNew(parent,kPairDtId,kStructDtId); if( ref != NULL ) *ref = NULL; if((rc = cmDataNewConstStr(p,kNoFlagsDtFl,label,NULL)) != kOkDtRC ) goto errLabel; cmDataAppendChild(p,value); if( ref != NULL ) *ref = p; errLabel: if( rc != kOkDtRC ) cmDataFree(p); return rc; } cmRC_t cmDataPairAllocLabelN(cmData_t* parent, const cmChar_t* label, unsigned charCnt, cmData_t* value, cmData_t** ref) { cmRC_t rc = kOkDtRC; if( ref != NULL ) *ref = NULL; cmData_t* p = _cmDataNew(parent,kPairDtId,kStructDtId); if((rc = cmDataNewConstStrN(p,kNoFlagsDtFl,label,charCnt,NULL)) != kOkDtRC ) goto errLabel; cmDataAppendChild(p,value); if( ref != NULL ) *ref = p; errLabel: if( rc != kOkDtRC ) cmMemFree(p); return rc; } //---------------------------------------------------------------------------- unsigned cmDataListCount(const cmData_t* p ) { return cmDataChildCount(p); } cmData_t* cmDataListEle( cmData_t* p, unsigned index ) { return cmDataChild(p,index); } cmData_t* cmDataListMake( cmData_t* parent, cmData_t* p ) { cmDataUnlink(p); _cmDataFreeData(p); p->parent = parent; p->cid = kListDtId; p->tid = kStructDtId; p->flags = cmIsFlag(p->flags,kFreeObjDtFl) ? kFreeObjDtFl : 0; p->u.child = NULL; return p; } cmData_t* cmDataListAlloc( cmData_t* parent) { return _cmDataNew(parent,kListDtId,kStructDtId); } cmDtRC_t _cmDataParseArgV( cmData_t* parent, cmErr_t* err, cmRC_t errRC, va_list vl, cmData_t** vpp ) { cmDtRC_t rc = kOkDtRC; cmData_t* vp = NULL; cmDataTypeId_t tid = va_arg(vl,unsigned); cmDataContainerId_t cid = tid & kContainerDtMask; unsigned flags = tid & kFlagsDtMask; tid = cmClrFlag(tid,kContainerDtMask | kFlagsDtMask); // if no container flag was given assume a scalar container if( cid == 0 ) cid = kScalarDtId; switch(cid) { case kScalarDtId: switch(tid) { case kInvalidTypeDtId: rc = kEolDtRC; break; case kNullDtId: rc = cmDataNewNull( parent,flags,&vp); break; case kBoolDtId: rc = cmDataNewBool( parent,flags,va_arg(vl,int),&vp); break; case kUCharDtId: rc = cmDataNewUChar( parent,flags,va_arg(vl,int),&vp); break; case kCharDtId: rc = cmDataNewChar( parent,flags,va_arg(vl,int),&vp); break; case kUShortDtId: rc = cmDataNewUShort( parent,flags,va_arg(vl,int),&vp); break; case kShortDtId: rc = cmDataNewShort( parent,flags,va_arg(vl,int),&vp); break; case kUIntDtId: rc = cmDataNewUInt( parent,flags,va_arg(vl,unsigned int),&vp); break; case kIntDtId: rc = cmDataNewInt( parent,flags,va_arg(vl,int),&vp); break; case kULongDtId: rc = cmDataNewULong( parent,flags,va_arg(vl,unsigned long),&vp); break; case kLongDtId: rc = cmDataNewLong( parent,flags,va_arg(vl,long),&vp); break; case kFloatDtId: rc = cmDataNewFloat( parent,flags,va_arg(vl,double),&vp); break; case kDoubleDtId: rc = cmDataNewDouble( parent,flags,va_arg(vl,double),&vp); break; case kStrDtId: rc = cmDataNewStr( parent,flags,va_arg(vl,cmChar_t*),&vp); break; default: if( err != NULL ) cmErrMsg(err,errRC,"Unknown scalar data type id (%i) when parsing new object var-args list.",tid); else rc = kInvalidTypeDtRC; break; } break; case kArrayDtId: { void* svp = va_arg(vl,void*); unsigned cnt = va_arg(vl,unsigned); switch(tid) { case kBoolDtId: rc = cmDataNewBoolArray( parent,(bool*)svp, cnt,flags,&vp); break; case kUCharDtId: rc = cmDataNewUCharArray( parent,(unsigned char*)svp, cnt,flags,&vp); break; case kCharDtId: rc = cmDataNewCharArray( parent,(char*)svp, cnt,flags,&vp); break; case kUShortDtId: rc = cmDataNewUShortArray( parent,(unsigned short*)svp,cnt,flags,&vp); break; case kShortDtId: rc = cmDataNewShortArray( parent,(short*)svp, cnt,flags,&vp); break; case kUIntDtId: rc = cmDataNewUIntArray( parent,(unsigned int*)svp, cnt,flags,&vp); break; case kIntDtId: rc = cmDataNewIntArray( parent,(int*)svp, cnt,flags,&vp); break; case kULongDtId: rc = cmDataNewULongArray( parent,(unsigned long*)svp, cnt,flags,&vp); break; case kLongDtId: rc = cmDataNewLongArray( parent,(long*)svp, cnt,flags,&vp); break; case kFloatDtId: rc = cmDataNewFloatArray( parent,(float*)svp, cnt,flags,&vp); break; case kDoubleDtId: rc = cmDataNewDoubleArray( parent,(double*)svp, cnt,flags,&vp); break; case kStrDtId: rc = cmDataNewStrArray( parent,(cmChar_t**)svp, cnt,flags,&vp); break; default: if( err != NULL ) cmErrMsg(err,errRC,"Unknown array data type id (%i) when parsing new object var-args list.",tid); else rc = kInvalidTypeDtRC; break; } } break; case kListDtId: case kPairDtId: case kRecordDtId: cmDataAppendChild(parent,va_arg(vl,cmData_t*)); break; default: if( err != NULL ) cmErrMsg(err,errRC,"Unknown container type id (%i) when parsing new object var-args list.",cid); else rc = kInvalidContDtRC; break; } *vpp = vp; return rc; } cmDtRC_t _cmDataListParseV(cmData_t* parent, cmErr_t* err, cmRC_t errRC, va_list vl ) { cmDtRC_t rc = kOkDtRC; bool contFl = true; while( contFl ) { cmData_t* vp; rc = _cmDataParseArgV(parent,err,errRC,vl,&vp); if(rc != kOkDtRC ) { contFl = false; if( rc == kEolDtRC ) rc = kOkDtRC; } } return rc; } cmRC_t cmDataListAllocV(cmData_t* parent, cmErr_t* err, cmRC_t errRC, cmData_t** ref, va_list vl ) { cmData_t* p = cmDataListAlloc(parent); cmRC_t rc; if((rc = _cmDataListParseV(p,err,errRC,vl )) != kOkDtRC ) { cmDataUnlinkAndFree(p); return rc; } if( ref != NULL ) *ref = p; return rc; } cmRC_t cmDataListAllocA(cmData_t* parent, cmErr_t* err, cmRC_t errRC, cmData_t** ref, ... ) { va_list vl; va_start(vl,ref); cmRC_t rc = cmDataListAllocV(parent,err,errRC,ref,vl); va_end(vl); return rc; } cmData_t* cmDataListAppendEle( cmData_t* p, cmData_t* ele ) { assert(p->cid == kListDtId && p->tid==kStructDtId); return cmDataAppendChild(p,ele); } cmData_t* cmDataListAppendEleN(cmData_t* p, cmData_t* ele[], unsigned n ) { assert(p->cid == kListDtId && p->tid==kStructDtId); cmData_t* rp = NULL; unsigned i; for(i=0; icid == kRecordDtId && p->tid==kStructDtId ); return cmDataChildCount(p); } cmData_t* cmDataRecdEle( cmData_t* p, unsigned index ) { assert( p->cid == kRecordDtId && p->tid==kStructDtId ); cmData_t* cp = cmDataChild(p,index); assert( p->cid == kPairDtId ); return cp; } cmData_t* cmDataRecdValueFromIndex( cmData_t* p, unsigned index ) { assert( p->cid == kRecordDtId && p->tid==kStructDtId ); cmData_t* cp = cmDataChild(p,index); assert( p->cid == kPairDtId && p->tid==kStructDtId ); return cmDataPairValue(cp); } cmData_t* cmDataRecdValueFromId( cmData_t* p, unsigned id ) { assert( p->cid == kRecordDtId || p->tid==kStructDtId ); cmData_t* cp = p->u.child; for(; cp!=NULL; cp=cp->sibling) if( cmDataPairKeyId(cp) == id ) break; assert( cp!=NULL && cp->cid==kPairDtId && cp->tid==kStructDtId); return cmDataPairValue(cp); } cmData_t* cmDataRecdValueFromLabel( cmData_t* p, const cmChar_t* label ) { assert( p->cid == kRecordDtId && p->tid==kStructDtId); cmData_t* cp = p->u.child; for(; cp!=NULL; cp=cp->sibling) { const cmChar_t* lp = cmDataPairKeyLabel(cp); if( lp!=NULL && strcmp(lp,label)==0 ) break; } assert( cp!=NULL && cp->cid==kPairDtId && cp->tid==kStructDtId); return cmDataPairValue(cp); } cmData_t* cmDataRecdKey( cmData_t* p, unsigned index ) { assert( p->cid == kRecordDtId && p->tid==kStructDtId ); cmData_t* cp = cmDataChild(p,index); assert( cp->cid == kPairDtId && cp->tid==kStructDtId); return cmDataPairKey(cp); } unsigned cmDataRecdKeyId( cmData_t* p, unsigned index ) { cmData_t* kp = cmDataRecdKey(p,index); unsigned id = cmInvalidId; cmDataGetUInt(kp,&id); return id; } const cmChar_t* cmDataRecdKeyLabel( cmData_t* p, unsigned index ) { cmData_t* kp = cmDataRecdKey(p,index); const cmChar_t* label = NULL; cmDataConstStr(kp,&label); return label; } cmData_t* cmDataRecdMake( cmData_t* parent, cmData_t* p ) { cmDataUnlink(p); _cmDataFreeData(p); p->parent = parent; p->cid = kRecordDtId; p->tid = kStructDtId; p->flags = cmIsFlag(p->flags,kFreeObjDtFl) ? kFreeObjDtFl : 0; p->u.child = NULL; return p; } cmData_t* cmDataRecdAlloc(cmData_t* parent) { return _cmDataNew(parent,kRecordDtId,kStructDtId); } cmData_t* cmDataRecdAppendPair( cmData_t* p, cmData_t* pair ) { assert( p!=NULL && p->cid==kRecordDtId && p->tid==kStructDtId); cmDataAppendChild(p,pair); return p; } cmDtRC_t _cmDataRecdParseInputV(cmData_t* parent, cmErr_t* err, cmRC_t errRC, unsigned idFl, va_list vl ) { assert( parent != NULL && parent->cid == kRecordDtId && parent->tid == kStructDtId ); bool contFl = true; cmDtRC_t rc = kOkDtRC; // for each record field while( contFl ) { cmData_t* vp = NULL; unsigned id = cmInvalidId; const cmChar_t* label = NULL; // parse the field idenfier if( idFl ) id = va_arg(vl,unsigned); // numeric field identifier else label = va_arg(vl,const char*); // text field label identifier // validate the field identifier if( (idFl && id==cmInvalidId) || (!idFl && label==NULL) ) break; // parse the field data if((rc =_cmDataParseArgV( NULL, err, errRC, vl, &vp )) != kOkDtRC ) { contFl = false; } else { // create the field pair if( idFl ) rc = cmDataPairAllocId(parent,id,vp,NULL); else rc = cmDataPairAllocLabel(parent,label,vp,NULL); } } return rc; } cmData_t* cmDataRecdAllocLabelV( cmData_t* parent, cmErr_t* err, cmRC_t errRC, va_list vl ) { cmData_t* p = cmDataRecdAlloc(parent); cmDtRC_t rc = _cmDataRecdParseInputV(p, err, errRC, false, vl ); if( rc != kOkDtRC ) { cmDataFree(p); p = NULL; } return p; } cmData_t* cmDataRecdAllocLabelA( cmData_t* parent, cmErr_t* err, cmRC_t errRC, ... ) { va_list vl; va_start(vl,errRC); cmData_t* p = cmDataRecdAllocLabelV(parent,err,errRC,vl); va_end(vl); return p; } cmData_t* cmDataRecdAllocIdV( cmData_t* parent, cmErr_t* err, cmRC_t errRC, va_list vl ) { cmData_t* p = cmDataRecdAlloc(parent); cmDtRC_t rc = _cmDataRecdParseInputV(p, err, errRC, true, vl ); if( rc != kOkDtRC ) { cmDataFree(p); p = NULL; } return p; } cmData_t* cmDataRecdAllocIdA( cmData_t* parent, cmErr_t* err, cmRC_t errRC, ... ) { va_list vl; va_start(vl,errRC); cmData_t* p = cmDataRecdAllocIdV(parent,err,errRC,vl); va_end(vl); return p; } cmDtRC_t _cmDataRecdParseErrV( cmErr_t* err, unsigned rc, unsigned id, const cmChar_t* label, const cmChar_t* fmt, va_list vl ) { if( err != NULL ) { cmChar_t* s0 = NULL; cmChar_t* s1 = NULL; if( label == NULL ) s0 = cmTsPrintfP(s0,"Error parsing field id=%i.",id); else s0 = cmTsPrintfP(s0,"Error parsing field '%s'.",label); s1 = cmTsVPrintfP(s1,fmt,vl); cmErrMsg(err,rc,"%s %s",s0,s1); cmMemFree(s0); cmMemFree(s1); } return rc; } cmDtRC_t _cmDataRecdParseErr( cmErr_t* err, unsigned rc, unsigned id, const cmChar_t* label, const cmChar_t* fmt, ... ) { va_list vl; va_start(vl,fmt); rc = _cmDataRecdParseErrV(err,rc,id,label,fmt,vl); va_end(vl); return rc; } cmDtRC_t _cmDataRecdParseV(cmData_t* p, bool idFl, cmErr_t* err, unsigned errRC, va_list vl ) { bool contFl = true; cmDtRC_t rc = kOkDtRC; while( contFl && rc==kOkDtRC) { unsigned id = cmInvalidId; const char* label = NULL; // parse the field idenfier if( idFl ) id = va_arg(vl,unsigned); // numeric field identifier else label = va_arg(vl,const char*); // text field label identifier // validate the field identifier if( (idFl && id==cmInvalidId) || (!idFl && label==NULL) ) break; cmDataContainerId_t cid = va_arg(vl,unsigned); cmDataTypeId_t typeId = va_arg(vl,unsigned); void* v = va_arg(vl,void*); cmData_t* np = NULL; bool optFl = cmIsFlag(typeId,kOptArgDtFl); cmDtRC_t rc0 = kOkDtRC; unsigned* cntPtr = NULL; // arrays have an additional arg - the element count pointer if( cid == kArrayDtId ) cntPtr = va_arg(vl,unsigned*); // clear the optArgFl from the type id typeId = cmClrFlag(typeId,kOptArgDtFl); // attempt to locate the field if( idFl ) np = cmDataRecdValueFromLabel( p, label ); else np = cmDataRecdValueFromId( p, id ); // if the field was not found if( np == NULL ) { if(optFl) continue; _cmDataRecdParseErr(err, errRC, id, label, "The required field was missing." ); rc = kMissingFieldDtRC; continue; } // validate the container type if( cid != np->cid ) { _cmDataRecdParseErr(err, errRC, id, label, "The container for the field is a '%s' but the arg. list indicated it should be a '%s'.",cmStringNullGuard(cmDataContainerIdToLabel(np->cid)),cmStringNullGuard(cmDataContainerIdToLabel(cid))); rc = kInvalidContDtRC; continue; } switch(cid) { case kScalarDtId: switch(typeId) { case kNullDtId: break; case kBoolDtId: rc0 = cmDataGetBool(np,(bool*)v); break; case kUCharDtId: rc0 = cmDataGetUChar(np,(unsigned char*)v); break; case kCharDtId: rc0 = cmDataGetChar(np,(char*)v); break; case kUShortDtId: rc0 = cmDataGetUShort(np,(unsigned short*)v); break; case kShortDtId: rc0 = cmDataGetShort(np,(short*)v); break; case kUIntDtId: rc0 = cmDataGetUInt(np,(unsigned int*)v); break; case kIntDtId: rc0 = cmDataGetInt(np,(int*)v); break; case kULongDtId: rc0 = cmDataGetULong(np,(unsigned long*)v); break; case kLongDtId: rc0 = cmDataGetLong(np,(long*)v); break; case kFloatDtId: rc0 = cmDataGetFloat(np,(float*)v); break; case kDoubleDtId: rc0 = cmDataGetDouble(np,(double*)v); break; case kStrDtId: rc0 = cmDataStr(np,(char**)v); break; default: _cmDataRecdParseErr(err, errRC, id, label, "An invalid data type id=%i was encountered.",typeId); rc = kInvalidTypeDtRC; } if( rc0 != kOkDtRC) { _cmDataRecdParseErr(err, errRC, id, label,"Unable to convert the field value to the requested type:'%s'.",cmStringNullGuard(cmDataTypeToLabel(typeId))); rc = kCvtErrDtRC; } break; case kArrayDtId: { switch(typeId) { case kNullDtId: break; case kBoolDtId: case kUCharDtId: case kCharDtId: case kUShortDtId: case kShortDtId: case kUIntDtId: case kIntDtId: case kULongDtId: case kLongDtId: case kFloatDtId: case kDoubleDtId: *(void**)v = np->u.vp; *cntPtr = cmDataArrayEleCount(np); break; default: _cmDataRecdParseErr(err, errRC, id, label,"Invalid array type identifier (%s).", cmStringNullGuard(cmDataTypeToLabel(typeId))); rc = kInvalidTypeDtRC; } } break; case kListDtId: case kPairDtId: case kRecordDtId: *(cmData_t**)v = np; break; default: { _cmDataRecdParseErr(err, errRC, id, label,"An invalid cotainer id=%i was encountered.",cid); rc = kInvalidContDtRC; } } } return rc; } cmDtRC_t cmDataRecdParseLabelV(cmData_t* p, cmErr_t* err, unsigned errRC, va_list vl ) { return _cmDataRecdParseV(p,false,err,errRC,vl); } cmDtRC_t cmDataRecdParseLabel(cmData_t* p, cmErr_t* err, unsigned errRC, ... ) { va_list vl; va_start(vl,errRC); cmDtRC_t rc = cmDataRecdParseLabelV(p,err,errRC,vl); va_end(vl); return rc; } cmDtRC_t cmDataRecdParseIdV(cmData_t* p, cmErr_t* err, unsigned errRC, va_list vl ) { return _cmDataRecdParseV(p,true,err,errRC,vl); } cmDtRC_t cmDataRecdParseId(cmData_t* p, cmErr_t* err, unsigned errRC, ... ) { va_list vl; va_start(vl,errRC); cmDtRC_t rc = cmDataRecdParseIdV(p,err,errRC,vl); va_end(vl); return rc; } //============================================================================ //============================================================================ //============================================================================ #ifdef NOT_DEF unsigned _cmDataSerializeNodeByteCount( const cmData_t* p ) { unsigned n = 0; // all serialized data ele's begin with a cmDataFmtId_t n += sizeof(cmDataFmtId_t); // arrays then have a count of bytes and structures have a child count if( cmDataIsPtr(p) || cmDataIsStruct(p) ) n += sizeof(unsigned); // then the data itself takes a variable number of bytes n += _cmDataByteCount(p); return n; } 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->u.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 bn + _cmDataSerializeNodeByteCount(p); } char* _cmDataSerializeWriteArray( cmData_t* np, char* dp, const char* ep ) { unsigned byteCnt = _cmDataByteCount(np); *((unsigned*)dp) = byteCnt; dp += sizeof(unsigned); memcpy(dp,np->u.vp,byteCnt); dp += byteCnt; return dp; } char* _cmDataSerializeWriteStruct( cmData_t* np, char* dp, const char* ep ) { *((unsigned*)dp) = cmDataChildCount(np); dp += sizeof(unsigned); return dp; } char* _cmDataSerializeWrite( cmData_t* np, char* dp, const char* ep ) { assert( dp + _cmDataSerializeNodeByteCount(np) <= ep ); *((cmDataFmtId_t*)dp) = np->tid; dp += sizeof(cmDataFmtId_t); switch( np->tid ) { case kNullDtId: break; case kBoolDtId: *((bool*)dp) = cmDataBool(np); dp+=sizeof(bool); break; case kUCharDtId: *((unsigned char*)dp) = cmDataUChar(np); dp+=sizeof(unsigned char); break; case kCharDtId: *((char*)dp) = cmDataChar(np); dp+=sizeof(char); break; case kUShortDtId: *((unsigned short*)dp) = cmDataUShort(np); dp+=sizeof(unsigned short); break; case kShortDtId: *((short*)dp) = cmDataShort(np); dp+=sizeof(short); break; case kUIntDtId: *((unsigned int*)dp) = cmDataUInt(np); dp+=sizeof(unsigned int); break; case kIntDtId: *((int*)dp) = cmDataInt(np); dp+=sizeof(int); break; case kULongDtId: *((unsigned long*)dp) = cmDataULong(np); dp+=sizeof(unsigned long); break; case kLongDtId: *((long*)dp) = cmDataLong(np); dp+=sizeof(long); break; case kFloatDtId: *((float*)dp) = cmDataFloat(np); dp+=sizeof(float); break; case kDoubleDtId: *((double*)dp) = cmDataDouble(np); dp+=sizeof(double); break; case kStrDtId: dp = _cmDataSerializeWriteArray(np,dp,ep); break; case kConstStrDtId: dp = _cmDataSerializeWriteArray(np,dp,ep); break; case kUCharPtrDtId: dp = _cmDataSerializeWriteArray(np,dp,ep); break; case kCharPtrDtId: dp = _cmDataSerializeWriteArray(np,dp,ep); break; case kUShortPtrDtId: dp = _cmDataSerializeWriteArray(np,dp,ep); break; case kShortPtrDtId: dp = _cmDataSerializeWriteArray(np,dp,ep); break; case kUIntPtrDtId: dp = _cmDataSerializeWriteArray(np,dp,ep); break; case kIntPtrDtId: dp = _cmDataSerializeWriteArray(np,dp,ep); break; case kULongPtrDtId: dp = _cmDataSerializeWriteArray(np,dp,ep); break; case kLongPtrDtId: dp = _cmDataSerializeWriteArray(np,dp,ep); break; case kFloatPtrDtId: dp = _cmDataSerializeWriteArray(np,dp,ep); break; case kDoublePtrDtId: dp = _cmDataSerializeWriteArray(np,dp,ep); break; case kVoidPtrDtId: dp = _cmDataSerializeWriteArray(np,dp,ep); break; case kListDtId: dp = _cmDataSerializeWriteStruct(np,dp,ep); break; case kPairDtId: dp = _cmDataSerializeWriteStruct(np,dp,ep); break; case kRecordDtId: dp = _cmDataSerializeWriteStruct(np,dp,ep); break; default: { assert(0); } } return dp; } char* _cmDataSerialize( const cmData_t* p, char* buf, const char* ep ) { /* buf = _cmDataSerializeWrite(p,buf,ep); // if this data type has a child then write the child if( kMinStructDtId <= p->tid && p->tid <= kMaxStructDtId && p->u.child != NULL ) buf = _cmDataSerialize(p->u.child,buf,ep); // if this data type has siblings then write sibings cmData_t* dp = p->u.child; for(; dp != NULL; dp=dp->sibling ) buf = cmDataSerialize(dp->sibling,buf,ep); return buf; */ return NULL; } cmDtRC_t cmDataSerialize( const cmData_t* p, void* buf, unsigned bufByteCnt ) { /* const char* ep = (char*)p + bufByteCnt; buf = _cmDataSerialize(p,buf,bufByteCnt); assert( buf <= ep ); */ return kOkDtRC; } cmDtRC_t cmDataDeserialize( const void* buf, unsigned bufByteCnt, cmData_t** pp ) { return kOkDtRC; } #endif //============================================================================ //============================================================================ //============================================================================ enum { kLCurlyLexTId = kUserLexTId + 1, kRCurlyLexTId, kLParenLexTId, kRParenLexTId, kLBrackLexTId, kRBrackLexTId, kColonLexTId, kCommaLexTId, }; typedef struct { unsigned id; const cmChar_t* label; } cmDtToken_t; cmDtToken_t _cmDtTokenArray[] = { { kLCurlyLexTId, "{" }, { kRCurlyLexTId, "}" }, { kLBrackLexTId, "[" }, { kRBrackLexTId, "]" }, { kLParenLexTId, "(" }, { kRParenLexTId, ")" }, { kColonLexTId, ":" }, { kCommaLexTId, "," }, { kErrorLexTId,""} }; typedef struct { cmErr_t err; cmLexH lexH; cmStackH_t stH; } cmDataParser_t; cmDataParserH_t cmDataParserNullHandle = cmSTATIC_NULL_HANDLE; cmDataParser_t* _cmDataParserHandleToPtr( cmDataParserH_t h ) { cmDataParser_t* p = (cmDataParser_t*)h.h; assert( p!= NULL ); return p; } cmDtRC_t _cmDataParserDestroy( cmDataParser_t* p ) { if( cmLexFinal(&p->lexH) != kOkLexRC ) cmErrMsg(&p->err,kLexFailDtRC,"Lexer release failed."); if( cmStackFree(&p->stH) != kOkStRC ) cmErrMsg(&p->err,kParseStackFailDtRC,"The data object parser stack release failed."); cmMemFree(p); return kOkDtRC; } cmDtRC_t cmDataParserCreate( cmCtx_t* ctx, cmDataParserH_t* hp ) { cmDtRC_t rc; unsigned i; if((rc = cmDataParserDestroy(hp)) != kOkDtRC ) return rc; cmDataParser_t* p = cmMemAllocZ(cmDataParser_t,1); cmErrSetup(&p->err,&ctx->rpt,"Data Parser"); if(cmLexIsValid(p->lexH = cmLexInit(NULL,0,0,&ctx->rpt))==false) { rc = cmErrMsg(&p->err, kLexFailDtRC, "The data object parser lexer create failed."); goto errLabel; } for(i=0; _cmDtTokenArray[i].id != kErrorLexTId; ++i) if( cmLexRegisterToken(p->lexH, _cmDtTokenArray[i].id, _cmDtTokenArray[i].label) != kOkLexRC ) { rc = cmErrMsg(&p->err,kLexFailDtRC,"The data object parser lexer could not register the '%s' token.",_cmDtTokenArray[i].label); goto errLabel; } if( cmStackAlloc(ctx, &p->stH, 1024, 1024, sizeof(cmData_t*)) != kOkStRC ) { rc = cmErrMsg(&p->err,kParseStackFailDtRC,"The data object parser stack create failed."); goto errLabel; } hp->h = p; errLabel: if( rc != kOkDtRC ) _cmDataParserDestroy(p); return kOkDtRC; } cmDtRC_t cmDataParserDestroy( cmDataParserH_t* hp ) { cmDtRC_t rc=kOkDtRC; if( hp==NULL || cmDataParserIsValid(*hp)==false ) return rc; cmDataParser_t* p = _cmDataParserHandleToPtr(*hp); if((rc = _cmDataParserDestroy(p)) != kOkDtRC ) return rc; hp->h = NULL; return kOkDtRC; } bool cmDataParserIsValid( cmDataParserH_t h ) { return h.h != NULL; } // { // id0 : scalar_value // id1 : ( heterogenous, array, value ) // id2 : [ homogeneous array values ] // id3 : // } // flags describing the expected next token enum { kValueExpFl = 0x01, kIdExpFl = 0x02, kColonExpFl = 0x04, kCommaExpFl = 0x08 }; typedef struct { cmData_t* dp; } cmDataStEle_t; typedef struct { cmDataParser_t* p; cmData_t* cnp; unsigned flags; cmChar_t* tmpStr; unsigned arrayCnt; void* arrayMem; } cmDataParserCtx_t; cmDtRC_t _cmDpSyntaxErrV( cmDataParserCtx_t* c, const cmChar_t* fmt, va_list vl ) { cmChar_t* s0 = NULL; cmChar_t* s1 = NULL; s0 = cmTsVPrintfP(s0,fmt,vl); s1 = cmMemAllocStrN(cmLexTokenText(c->p->lexH),cmLexTokenCharCount(c->p->lexH)); cmDtRC_t rc = cmErrMsg(&c->p->err,kSyntaxErrDtRC,"Syntax error on line %i column:%i token:'%s'. %s",cmLexCurrentLineNumber(c->p->lexH),cmLexCurrentColumnNumber(c->p->lexH),s1,cmStringNullGuard(s0)); cmMemFree(s0); cmMemFree(s1); return rc; } cmDtRC_t _cmDpSyntaxErr( cmDataParserCtx_t* c, const cmChar_t* fmt, ... ) { va_list vl; va_start(vl,fmt); cmDtRC_t rc = _cmDpSyntaxErrV(c,fmt,vl); va_end(vl); return rc; } cmDtRC_t _cmDpPopStack( cmDataParserCtx_t* c, cmData_t** pp ) { const void* vp; if((vp = cmStackTop(c->p->stH)) == NULL ) return _cmDpSyntaxErr(c,"Stack underflow."); if( cmStackPop(c->p->stH,1) != kOkStRC ) return _cmDpSyntaxErr(c,"Stack pop failed."); *pp = *(cmData_t**)vp; //printf("pop: %p\n",*pp); return kOkDtRC; } cmDtRC_t _cmDpPushStack( cmDataParserCtx_t* c, cmData_t* np ) { //printf("push:%p\n",np); // store the current node if( cmStackPush(c->p->stH, &np, 1 ) != kOkStRC ) return _cmDpSyntaxErr(c,"Parser stack push failed."); return kOkDtRC; } cmDtRC_t _cmDpStoreArrayEle( cmDataParserCtx_t* c, void* dp, unsigned eleByteCnt, cmDataTypeId_t tid ) { if( c->cnp->tid == kBlobDtId ) c->cnp->tid = tid; else if( c->cnp->tid != tid ) return _cmDpSyntaxErr(c,"Mixed types were detected in an array list."); unsigned newByteCnt = (c->cnp->cnt+1)*eleByteCnt; char* vp = cmMemResizeP(char, c->cnp->u.vp, newByteCnt); memcpy(vp + c->cnp->cnt*eleByteCnt,dp,eleByteCnt); c->cnp->u.vp = vp; c->cnp->cnt += 1; c->cnp->cid = kArrayDtId; c->flags = kValueExpFl | kCommaExpFl; return kOkDtRC; } cmDtRC_t _cmDataParserOpenPair( cmDataParserCtx_t* c ) { cmDtRC_t rc = kOkDtRC; assert( c->cnp->cid==kRecordDtId && c->cnp->tid == kStructDtId ); // create a pair with a 'null' value which will be replaced when the pair's value is parsed cmData_t* nnp = NULL; if( cmDataNewNull(NULL,0,&nnp) != kOkDtRC ) return rc; cmData_t* pnp = NULL; if((rc = cmDataPairAllocLabelN( c->cnp, cmLexTokenText(c->p->lexH), cmLexTokenCharCount(c->p->lexH), nnp, &pnp )) != kOkDtRC ) { cmDataFree(nnp); return rc; } // store the current node if((rc = _cmDpPushStack(c,c->cnp)) != kOkDtRC ) return rc; // make the new pair the current node c->cnp = pnp; // pair openings must be followed by a colon. c->flags = kColonExpFl; return rc; } cmDtRC_t _cmDataParserClosePair( cmDataParserCtx_t* c ) { cmDtRC_t rc; // make the pair's parent record the current node if((rc = _cmDpPopStack(c, &c->cnp )) != kOkDtRC ) return rc; // pairs only occur in records if( c->cnp->cid != kRecordDtId ) return _cmDpSyntaxErr(c,"A 'pair' end was found outside of a 'record'."); // pairs must be followed by id's or comma's c->flags = kIdExpFl | kCommaExpFl; return rc; } cmDtRC_t _cmDpStoreValue( cmDataParserCtx_t* c, cmData_t* np, const cmChar_t* typeLabel ) { assert( np != NULL ); cmDtRC_t rc = kOkDtRC; switch( c->cnp->cid ) { case kPairDtId: // assign the new node as the value of the pair cmDataPairSetValue(c->cnp,np); // close the values parent pair rc = _cmDataParserClosePair(c); break; case kListDtId: cmDataAppendChild(c->cnp,np); c->flags = kValueExpFl; break; default: rc = _cmDpSyntaxErr(c,"A '%s' value was found outside of a valid container.",typeLabel); // Free the new data node because it was not attached and will // otherwise be lost cmDataFree(np); } c->flags |= kCommaExpFl; return rc; } cmDtRC_t _cmDataParserReal( cmDataParserCtx_t* c ) { cmDtRC_t rc = kOkDtRC; bool floatFl = cmLexTokenIsSinglePrecision(c->p->lexH); double dval; float fval; if( floatFl ) fval = cmLexTokenFloat(c->p->lexH); else dval = cmLexTokenDouble(c->p->lexH); if( c->cnp->cid == kArrayDtId ) { if( floatFl ) rc = _cmDpStoreArrayEle(c,&fval,sizeof(fval),kFloatDtId); else rc = _cmDpStoreArrayEle(c,&dval,sizeof(dval),kDoubleDtId); } else { cmData_t* np = NULL; if( floatFl ) rc = cmDataNewFloat(NULL,0,fval,&np); else rc = cmDataNewDouble(NULL,0,dval,&np); if( rc == kOkDtRC ) rc = _cmDpStoreValue(c,np,"real"); } return rc; } cmDtRC_t _cmDataParserInt( cmDataParserCtx_t* c ) { cmDtRC_t rc = kOkDtRC; int val = cmLexTokenInt(c->p->lexH); bool unsignedFl = cmLexTokenIsUnsigned(c->p->lexH); if( c->cnp->cid == kArrayDtId ) rc = _cmDpStoreArrayEle(c,&val,sizeof(val),unsignedFl ? kUIntDtId : kIntDtId); else { cmData_t* np = NULL; if(unsignedFl) rc = cmDataNewUInt(NULL,0,val,&np); else rc = cmDataNewInt(NULL,0,val,&np); if( rc == kOkDtRC ) rc = _cmDpStoreValue(c,np,"int"); } return rc; } cmDtRC_t _cmDataParserString( cmDataParserCtx_t* c ) { cmDtRC_t rc = kOkDtRC; // if we are expecting a pair label if( cmIsFlag(c->flags,kIdExpFl) ) return _cmDataParserOpenPair(c); // otherwise a 'value' must be expected if( cmIsNotFlag(c->flags,kValueExpFl) ) return _cmDpSyntaxErr(c,"Unexpected string."); cmData_t* np = NULL; if((rc = cmDataNewConstStrN(NULL,0,cmLexTokenText(c->p->lexH), cmLexTokenCharCount(c->p->lexH),&np)) != kOkDtRC ) return rc; return _cmDpStoreValue(c,np,"string"); } cmDtRC_t _cmDataParserOpenRecd( cmDataParserCtx_t* c ) { cmDtRC_t rc = kOkDtRC; // records are values - so we must be expecting a value if( cmIsFlag(c->flags,kValueExpFl) == false ) return _cmDpSyntaxErr(c,"Unexpected '{'."); // store the current node if((rc = _cmDpPushStack(c,c->cnp)) != kOkDtRC ) return rc; // alloc a new record and make it the current node if( (c->cnp = cmDataRecdAlloc(NULL)) == NULL ) return _cmDpSyntaxErr(c,"'recd' allocate failed."); // new records must be followed by an id token. c->flags = kIdExpFl; return rc; } cmDtRC_t _cmDataParserCloseContainer( cmDataParserCtx_t* c, const cmChar_t* typeLabelStr ) { cmDtRC_t rc; cmData_t* np = c->cnp; // make the parent node the new current node if((rc = _cmDpPopStack(c,&c->cnp)) != kOkDtRC ) return rc; return _cmDpStoreValue(c,np,typeLabelStr); } cmDtRC_t _cmDataParserCloseRecd( cmDataParserCtx_t* c ) { assert( c->cnp->cid == kRecordDtId ); return _cmDataParserCloseContainer(c,"record"); } cmDtRC_t _cmDataParserOpenList( cmDataParserCtx_t* c ) { cmDtRC_t rc = kOkDtRC; // lists are values - so we must be expecting a value if( cmIsFlag(c->flags,kValueExpFl) == false ) return _cmDpSyntaxErr(c,"Unexpected '('."); // store the current node if((rc = _cmDpPushStack(c,c->cnp)) != kOkDtRC ) return rc; // create a new list if( (c->cnp = cmDataListAlloc(NULL)) == NULL ) return _cmDpSyntaxErr(c,"'list' allocate failed."); // new lists must be followed by a value c->flags = kValueExpFl; return rc; } cmDtRC_t _cmDataParserCloseList( cmDataParserCtx_t* c ) { assert( c->cnp->cid == kListDtId ); return _cmDataParserCloseContainer(c,"list"); } cmDtRC_t _cmDataParserOpenArray( cmDataParserCtx_t* c ) { cmDtRC_t rc = kOkDtRC; // arrays are values - so we must be expecting a value if( cmIsFlag(c->flags,kValueExpFl) == false ) return _cmDpSyntaxErr(c,"Unexpected '['."); // store the current node if((rc = _cmDpPushStack(c,c->cnp)) != kOkDtRC ) return rc; // create a new array c->cnp = NULL; if( cmDataNewBlob(NULL, 0, NULL, 0,&c->cnp) != kOkDtRC ) return _cmDpSyntaxErr(c,"'array' allocate failed."); // new arrays must be followed by a value c->flags = kValueExpFl; // Idicate that the object is an array by setting c->cnp->cid to kArrayDtId. // (ALTHOUGH the c->cnp->tid==kBlobDtId which is only legal for scalar containers - // but this will be fixed up when the first element is stored in // _cmDpStoreArrayEle(). ) c->cnp->cid = kArrayDtId; return rc; } cmDtRC_t _cmDataParserCloseArray( cmDataParserCtx_t* c ) { assert( c->cnp->cid == kArrayDtId ); return _cmDataParserCloseContainer(c,"array"); } cmDtRC_t _cmDataParserOnColon( cmDataParserCtx_t* c ) { // colons only follow field identifiers and are always followed by values. if( cmIsFlag(c->flags,kColonExpFl) == false ) return _cmDpSyntaxErr(c,"Unexpected colon."); c->flags = kValueExpFl; return kOkDtRC; } cmDtRC_t _cmDataParserOnComma( cmDataParserCtx_t* c ) { // comma's may be found in three places: // 1) following field values // 2) between list values // 3) between array values // comma's are always followed by values if( cmIsFlag(c->flags,kCommaExpFl) == false ) return _cmDpSyntaxErr(c, "Unexpected comma."); c->flags = kValueExpFl; return kOkDtRC; } cmDtRC_t cmDataParserExec( cmDataParserH_t h, const cmChar_t* text, cmData_t** pp ) { cmDtRC_t rc = kOkDtRC; cmDataParser_t* p = _cmDataParserHandleToPtr(h); unsigned tokenId; cmDataParserCtx_t ctx; cmData_t* root = cmDataRecdAlloc(NULL); ctx.cnp = root; ctx.p = p; ctx.flags = kIdExpFl; if( cmLexSetTextBuffer(p->lexH,text,strlen(text)) != kOkLexRC ) return cmErrMsg(&p->err,kLexFailDtRC,"The data object lexer failed during reset."); cmStackClear(p->stH,false); while(rc==kOkDtRC && (tokenId = cmLexGetNextToken(p->lexH)) != kEofLexTId ) { switch(tokenId) { case kRealLexTId: // real number (contains a decimal point or is in scientific notation) rc = _cmDataParserReal(&ctx); break; case kIntLexTId: // decimal integer case kHexLexTId: // hexidecimal integer rc = _cmDataParserInt(&ctx); break; case kIdentLexTId: // identifiers are treated as strings case kQStrLexTId: // quoted string rc = _cmDataParserString(&ctx); break; case kLCurlyLexTId: // a new record is starting rc = _cmDataParserOpenRecd(&ctx); break; case kRCurlyLexTId: // the current record is finished rc = _cmDataParserCloseRecd(&ctx); break; case kLParenLexTId: // a list is starting rc = _cmDataParserOpenList(&ctx); break; case kRParenLexTId: // a list is finished rc = _cmDataParserCloseList(&ctx); break; case kLBrackLexTId: // an array is starting rc = _cmDataParserOpenArray(&ctx); break; case kRBrackLexTId: // an array is ending rc = _cmDataParserCloseArray(&ctx); break; case kColonLexTId: // the previous id was a field id rc = _cmDataParserOnColon(&ctx); break; case kCommaLexTId: // comma sep. for array or fields rc = _cmDataParserOnComma(&ctx); break; case kBlockCmtLexTId: // block comment case kLineCmtLexTId: // line comment case kErrorLexTId: // the lexer was unable to identify the current token case kUnknownLexTId: // the token is of an unknown type (only used when kReturnUnknownLexFl is set) case kEofLexTId: // the lexer reached the end of input case kSpaceLexTId: // white space { rc = cmErrMsg(&p->err,kLexFailDtRC,"The data object lexer failed with an unexpected token '%s' on line '%i'.",cmLexIdToLabel(p->lexH,tokenId),cmLexCurrentLineNumber(p->lexH)); goto errLabel; } } } errLabel: if( rc == kOkDtRC ) *pp = ctx.cnp; else { if( ctx.cnp != root ) cmDataUnlinkAndFree(ctx.cnp); cmDataUnlinkAndFree(root); } return rc; } //============================================================================ //============================================================================ //============================================================================ #define parr(rpt,fmt,arr,n) do{int i=0; cmRptPrintf(rpt,"[ "); for(;icid) { case kScalarDtId: switch(p->tid) { case kNullDtId: cmRptPrintf(rpt,""); break; case kBoolDtId: cmRptPrintf(rpt,"%i", cmDtBool(p)); break; case kUCharDtId: cmRptPrintf(rpt,"%c ",cmDtUChar(p)); break; case kCharDtId: cmRptPrintf(rpt,"%c ",cmDtChar(p)); break; case kUShortDtId: cmRptPrintf(rpt,"%i ",cmDtUShort(p)); break; case kShortDtId: cmRptPrintf(rpt,"%i ",cmDtShort(p)); break; case kUIntDtId: cmRptPrintf(rpt,"%i ",cmDtUInt(p)); break; case kIntDtId: cmRptPrintf(rpt,"%i ",cmDtInt(p)); break; case kULongDtId: cmRptPrintf(rpt,"%i ",cmDtULong(p)); break; case kLongDtId: cmRptPrintf(rpt,"%i ",cmDtLong(p)); break; case kFloatDtId: cmRptPrintf(rpt,"%f ",cmDtFloat(p)); break; case kDoubleDtId: cmRptPrintf(rpt,"%f ",cmDtDouble(p)); break; case kStrDtId: cmRptPrintf(rpt,"%s ",cmDtConstStr(p)); break; default: {assert(0); } } break; case kArrayDtId: { switch(p->tid) { case kBoolDtId: parr(rpt,"%i ", cmDtBoolArray(p), p->cnt ); break; case kUCharDtId: parr(rpt,"%c ", cmDtCharArray(p), p->cnt ); break; case kCharDtId: parr(rpt,"%c ", cmDtCharArray(p), p->cnt ); break; case kUShortDtId: parr(rpt,"%i ", cmDtUShortArray(p), p->cnt ); break; case kShortDtId: parr(rpt,"%i ", cmDtShortArray(p), p->cnt ); break; case kUIntDtId: parr(rpt,"%i ", cmDtUIntArray(p), p->cnt ); break; case kIntDtId: parr(rpt,"%i ", cmDtIntArray(p), p->cnt ); break; case kULongDtId: parr(rpt,"%i ", cmDtULongArray(p), p->cnt ); break; case kLongDtId: parr(rpt,"%i ", cmDtLongArray(p), p->cnt ); break; case kFloatDtId: parr(rpt,"%f ", cmDtFloatArray(p), p->cnt ); break; case kDoubleDtId: parr(rpt,"%f ", cmDtDoubleArray(p), p->cnt ); break; default: {assert(0);} } } break; case kPairDtId: _cmDataPrint(p->u.child,rpt,indent); cmRptPrintf(rpt," : "); _cmDataPrint(p->u.child->sibling,rpt,indent); cmRptPrintf(rpt,"\n"); break; case kListDtId: cmRptPrintf(rpt,"(\n"); indent += 2; cp = p->u.child; for(; cp!=NULL; cp=cp->sibling) { _cmDataPrintIndent(rpt,indent); _cmDataPrint(cp,rpt,indent); cmRptPrintf(rpt,"\n"); } indent -= 2; _cmDataPrintIndent(rpt,indent); cmRptPrintf(rpt,")\n"); break; case kRecordDtId: cmRptPrintf(rpt,"{\n"); indent += 2; cp = p->u.child; for(; cp!=NULL; cp=cp->sibling) { _cmDataPrintIndent(rpt,indent); _cmDataPrint(cp,rpt, indent); } indent -= 2; _cmDataPrintIndent(rpt,indent); cmRptPrintf(rpt,"}\n"); break; default: break; } } void cmDataPrint( const cmData_t* p, cmRpt_t* rpt ) { _cmDataPrint(p,rpt,0); } cmDtRC_t cmDataParserTest( cmCtx_t* ctx ) { cmDtRC_t rc = kOkDtRC; cmDataParserH_t h = cmDataParserNullHandle; cmErr_t err; cmData_t* dp = NULL; const cmChar_t text[] = { //0 1 2 3 //0123456789012345678901234567890123 "f0:1.23 f1:\"hey\" f2:( a b c ) f3:[ 0f 1f 2f ]" //"f0:1.23 f1:\"hey\"" }; cmErrSetup(&err,&ctx->rpt,"Data Parser Tester"); if((rc = cmDataParserCreate(ctx, &h )) != kOkDtRC ) { rc = cmErrMsg(&err,rc,"Data parser create failed."); goto errLabel; } if( cmDataParserExec(h,text,&dp) != kOkDtRC ) rc = cmErrMsg(&err,rc,"Data parser exec failed."); else if( dp != NULL ) cmDataPrint(dp,&ctx->rpt); errLabel: if( cmDataParserDestroy( &h ) != kOkDtRC ) { rc = cmErrMsg(&err,rc,"Data parser destroy failed."); goto errLabel; } cmDataFree(dp); return rc; } void cmDataTest( cmCtx_t* ctx ) { float farr[] = { 1.23, 45.6, 7.89 }; if( cmDataParserTest(ctx) != kOkDtRC ) return; cmData_t* d0 = cmDataRecdAllocLabelA(NULL,&ctx->err,0, "name", kStrDtId,"This is a string.", "id", kUIntDtId, 21, "real",kFloatDtId, 1.23, "arr", kArrayDtId | kFloatDtId, farr, 3, NULL); //cmDataPrint(d0,&ctx->rpt); cmData_t* d1 = NULL; cmDataListAllocA(NULL,&ctx->err,0,&d1, kUIntDtId, 53, kStrDtId, "Blah blah", kArrayDtId | kFloatDtId, farr, 3, kRecordDtId, d0, kInvalidCntDtId ); cmDataPrint(d1,&ctx->rpt); cmDataFree(d1); cmRptPrintf(&ctx->rpt,"Done!.\n"); }