libcm is a C development framework with an emphasis on audio signal processing applications.
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.

cmData.c 56KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188
  1. #include "cmGlobal.h"
  2. #include "cmRpt.h"
  3. #include "cmErr.h"
  4. #include "cmCtx.h"
  5. #include "cmMem.h"
  6. #include "cmMallocDebug.h"
  7. #include "cmData.h"
  8. cmDtRC_t _cmDataErrNo = kOkDtRC;
  9. cmData_t cmDataNull = { kInvalidDtId,0,NULL,NULL,0 };
  10. typedef struct
  11. {
  12. cmDataFmtId_t tid;
  13. unsigned cnt;
  14. } cmDataSerialHdr_t;
  15. cmDtRC_t _cmDataSetError( unsigned err )
  16. {
  17. _cmDataErrNo = err;
  18. return err;
  19. }
  20. void _cmDataFreeArray( cmData_t* p )
  21. {
  22. if(cmIsFlag(p->flags,kDynPtrDtFl))
  23. {
  24. cmMemFree(p->u.vp);
  25. p->u.vp = NULL;
  26. p->flags = cmClrFlag(p->flags,kDynPtrDtFl);
  27. }
  28. p->tid = kInvalidDtId;
  29. p->cnt = 0;
  30. }
  31. void _cmDataFree( cmData_t* p )
  32. {
  33. if( cmDataIsStruct(p) )
  34. {
  35. cmData_t* cp = p->u.child;
  36. for(; cp!=NULL; cp=cp->sibling)
  37. _cmDataFree(cp);
  38. }
  39. _cmDataFreeArray(p);
  40. if( cmIsFlag(p->flags,kDynObjDtFl) )
  41. cmMemFree(p);
  42. }
  43. cmData_t* _cmDataAllocNode( cmData_t* parent, cmDataFmtId_t tid )
  44. {
  45. cmData_t* p = cmMemAllocZ(cmData_t,1);
  46. p->tid = tid;
  47. p->flags = kDynObjDtFl;
  48. p->parent = parent;
  49. if( parent != NULL )
  50. return cmDataAppendChild(parent,p);
  51. return p;
  52. }
  53. unsigned _cmDataByteCount( const cmData_t* p )
  54. {
  55. unsigned n = sizeof(cmDataSerialHdr_t);
  56. switch( p->tid )
  57. {
  58. case kInvalidDtId: return 0;
  59. case kNullDtId: return n;
  60. case kUCharDtId: return n + sizeof(unsigned char);
  61. case kCharDtId: return n + sizeof(char);
  62. case kUShortDtId: return n + sizeof(unsigned short);
  63. case kShortDtId: return n + sizeof(short);
  64. case kUIntDtId: return n + sizeof(unsigned int);
  65. case kIntDtId: return n + sizeof(int);
  66. case kULongDtId: return n + sizeof(unsigned long);
  67. case kLongDtId: return n + sizeof(long);
  68. case kFloatDtId: return n + sizeof(float);
  69. case kDoubleDtId: return n + sizeof(double);
  70. case kStrDtId: return n + (p->u.z ==NULL ? 0 : strlen(p->u.z) + 1);
  71. case kConstStrDtId: return n + (p->u.cz==NULL ? 0 : strlen(p->u.cz) + 1);
  72. case kUCharPtrDtId: return n + p->cnt * sizeof(unsigned char);
  73. case kCharPtrDtId: return n + p->cnt * sizeof(char);
  74. case kUShortPtrDtId: return n + p->cnt * sizeof(unsigned short);
  75. case kShortPtrDtId: return n + p->cnt * sizeof(short);
  76. case kUIntPtrDtId: return n + p->cnt * sizeof(unsigned int);
  77. case kIntPtrDtId: return n + p->cnt * sizeof(int);
  78. case kULongPtrDtId: return n + p->cnt * sizeof(unsigned long);
  79. case kLongPtrDtId: return n + p->cnt * sizeof(long);
  80. case kFloatPtrDtId: return n + p->cnt * sizeof(float);
  81. case kDoublePtrDtId: return n + p->cnt * sizeof(double);
  82. case kVoidPtrDtId: return n + p->cnt * sizeof(char);
  83. default:
  84. return n;
  85. }
  86. assert(0);
  87. return 0;
  88. }
  89. bool cmDataIsValue( const cmData_t* p )
  90. { return kMinValDtId <= p->tid && p->tid <= kMaxValDtId; }
  91. bool cmDataIsPtr( const cmData_t* p )
  92. { return kMinPtrDtId <= p->tid && p->tid <= kMaxPtrDtId; }
  93. bool cmDataIsStruct( const cmData_t* p )
  94. { return kMinStructDtId <= p->tid && p->tid <= kMaxStructDtId; }
  95. char cmDataChar( const cmData_t* p ) { assert(p->tid==kCharDtId); return p->u.c; }
  96. unsigned char cmDataUChar( const cmData_t* p ) { assert(p->tid==kUCharDtId); return p->u.uc; }
  97. short cmDataShort( const cmData_t* p ) { assert(p->tid==kShortDtId); return p->u.s; }
  98. unsigned short cmDataUShort( const cmData_t* p ) { assert(p->tid==kUShortDtId); return p->u.us; }
  99. int cmDataInt( const cmData_t* p ) { assert(p->tid==kIntDtId); return p->u.i; }
  100. unsigned int cmDataUInt( const cmData_t* p ) { assert(p->tid==kUIntDtId); return p->u.ui; }
  101. long cmDataLong( const cmData_t* p ) { assert(p->tid==kLongDtId); return p->u.l; }
  102. unsigned long cmDataULong( const cmData_t* p ) { assert(p->tid==kULongDtId); return p->u.ul; }
  103. float cmDataFloat( const cmData_t* p ) { assert(p->tid==kFloatDtId); return p->u.f; }
  104. double cmDataDouble( const cmData_t* p ) { assert(p->tid==kDoubleDtId); return p->u.d; }
  105. cmChar_t* cmDataStr( const cmData_t* p ) { assert(p->tid==kStrDtId); return p->u.z; }
  106. const cmChar_t* cmDataConstStr( const cmData_t* p ) { assert(p->tid==kConstStrDtId); return p->u.cz; }
  107. void* cmDataVoidPtr( const cmData_t* p ) { assert(p->tid==kVoidPtrDtId); return p->u.vp; }
  108. char* cmDataCharPtr( const cmData_t* p ) { assert(p->tid==kCharPtrDtId); return p->u.cp; }
  109. unsigned char* cmDataUCharPtr( const cmData_t* p ) { assert(p->tid==kUCharPtrDtId); return p->u.ucp; }
  110. short* cmDataShortPtr( const cmData_t* p ) { assert(p->tid==kShortPtrDtId); return p->u.sp; }
  111. unsigned short* cmDataUShortPtr( const cmData_t* p ) { assert(p->tid==kUShortPtrDtId); return p->u.usp; }
  112. int* cmDataIntPtr( const cmData_t* p ) { assert(p->tid==kIntPtrDtId); return p->u.ip; }
  113. unsigned int* cmDataUIntPtr( const cmData_t* p ) { assert(p->tid==kUIntPtrDtId); return p->u.uip; }
  114. long* cmDataLongPtr( const cmData_t* p ) { assert(p->tid==kLongPtrDtId); return p->u.lp; }
  115. unsigned long* cmDataULongPtr( const cmData_t* p ) { assert(p->tid==kULongPtrDtId); return p->u.ulp; }
  116. float* cmDataFloatPtr( const cmData_t* p ) { assert(p->tid==kFloatPtrDtId); return p->u.fp; }
  117. double* cmDataDoublePtr( const cmData_t* p ) { assert(p->tid==kDoublePtrDtId); return p->u.dp; }
  118. cmDtRC_t cmDataGetUChar( const cmData_t* p, unsigned char* vp )
  119. {
  120. switch( p->tid )
  121. {
  122. case kUCharDtId: *vp = p->u.uc; break;
  123. case kCharDtId: *vp = (unsigned char)p->u.c; break;
  124. case kUShortDtId: *vp = (unsigned char)p->u.us; break;
  125. case kShortDtId: *vp = (unsigned char)p->u.s; break;
  126. case kUIntDtId: *vp = (unsigned char)p->u.ui; break;
  127. case kIntDtId: *vp = (unsigned char)p->u.i; break;
  128. case kULongDtId: *vp = (unsigned char)p->u.ul; break;
  129. case kLongDtId: *vp = (unsigned char)p->u.l; break;
  130. case kFloatDtId: *vp = (unsigned char)p->u.f; break;
  131. case kDoubleDtId: *vp = (unsigned char)p->u.d; break;
  132. default:
  133. return _cmDataSetError(kCvtErrDtRC);
  134. }
  135. return kOkDtRC;
  136. }
  137. cmDtRC_t cmDataGetChar( const cmData_t* p, char* vp )
  138. {
  139. switch( p->tid )
  140. {
  141. case kUCharDtId: *vp = (char)p->u.uc; break;
  142. case kCharDtId: *vp = p->u.c; break;
  143. case kUShortDtId: *vp = (char)p->u.us; break;
  144. case kShortDtId: *vp = (char)p->u.s; break;
  145. case kUIntDtId: *vp = (char)p->u.ui; break;
  146. case kIntDtId: *vp = (char)p->u.i; break;
  147. case kULongDtId: *vp = (char)p->u.ul; break;
  148. case kLongDtId: *vp = (char)p->u.l; break;
  149. case kFloatDtId: *vp = (char)p->u.f; break;
  150. case kDoubleDtId: *vp = (char)p->u.d; break;
  151. default:
  152. return _cmDataSetError(kCvtErrDtRC);
  153. }
  154. return kOkDtRC;
  155. }
  156. cmDtRC_t cmDataGetShort( const cmData_t* p, short* vp )
  157. {
  158. switch( p->tid )
  159. {
  160. case kUCharDtId: *vp = (short)p->u.uc; break;
  161. case kCharDtId: *vp = (short)p->u.c; break;
  162. case kUShortDtId: *vp = (short)p->u.us; break;
  163. case kShortDtId: *vp = p->u.s; break;
  164. case kUIntDtId: *vp = (short)p->u.ui; break;
  165. case kIntDtId: *vp = (short)p->u.i; break;
  166. case kULongDtId: *vp = (short)p->u.ul; break;
  167. case kLongDtId: *vp = (short)p->u.l; break;
  168. case kFloatDtId: *vp = (short)p->u.f; break;
  169. case kDoubleDtId: *vp = (short)p->u.d; break;
  170. default:
  171. return _cmDataSetError(kCvtErrDtRC);
  172. }
  173. return kOkDtRC;
  174. }
  175. cmDtRC_t cmDataGetUShort( const cmData_t* p, unsigned short* vp )
  176. {
  177. switch( p->tid )
  178. {
  179. case kUCharDtId: *vp = (unsigned short)p->u.uc; break;
  180. case kCharDtId: *vp = (unsigned short)p->u.c; break;
  181. case kUShortDtId: *vp = p->u.us; break;
  182. case kShortDtId: *vp = (unsigned short)p->u.s; break;
  183. case kUIntDtId: *vp = (unsigned short)p->u.ui; break;
  184. case kIntDtId: *vp = (unsigned short)p->u.i; break;
  185. case kULongDtId: *vp = (unsigned short)p->u.ul; break;
  186. case kLongDtId: *vp = (unsigned short)p->u.l; break;
  187. case kFloatDtId: *vp = (unsigned short)p->u.f; break;
  188. case kDoubleDtId: *vp = (unsigned short)p->u.d; break;
  189. default:
  190. return _cmDataSetError(kCvtErrDtRC);
  191. }
  192. return kOkDtRC;
  193. }
  194. cmDtRC_t cmDataGetInt( const cmData_t* p, int* vp )
  195. {
  196. switch( p->tid )
  197. {
  198. case kUCharDtId: *vp = (int)p->u.uc; break;
  199. case kCharDtId: *vp = (int)p->u.c; break;
  200. case kUShortDtId: *vp = (int)p->u.us; break;
  201. case kShortDtId: *vp = (int)p->u.s; break;
  202. case kUIntDtId: *vp = (int)p->u.ui; break;
  203. case kIntDtId: *vp = p->u.i; break;
  204. case kULongDtId: *vp = (int)p->u.ul; break;
  205. case kLongDtId: *vp = (int)p->u.l; break;
  206. case kFloatDtId: *vp = (int)p->u.f; break;
  207. case kDoubleDtId: *vp = (int)p->u.d; break;
  208. default:
  209. return _cmDataSetError(kCvtErrDtRC);
  210. }
  211. return kOkDtRC;
  212. }
  213. cmDtRC_t cmDataGetUInt( const cmData_t* p, unsigned int* vp )
  214. {
  215. switch( p->tid )
  216. {
  217. case kUCharDtId: *vp = (unsigned int)p->u.uc; break;
  218. case kCharDtId: *vp = (unsigned int)p->u.c; break;
  219. case kUShortDtId: *vp = (unsigned int)p->u.us; break;
  220. case kShortDtId: *vp = (unsigned int)p->u.s; break;
  221. case kUIntDtId: *vp = p->u.ui; break;
  222. case kIntDtId: *vp = (unsigned int)p->u.i; break;
  223. case kULongDtId: *vp = (unsigned int)p->u.ul; break;
  224. case kLongDtId: *vp = (unsigned int)p->u.l; break;
  225. case kFloatDtId: *vp = (unsigned int)p->u.f; break;
  226. case kDoubleDtId: *vp = (unsigned int)p->u.d; break;
  227. default:
  228. return _cmDataSetError(kCvtErrDtRC);
  229. }
  230. return kOkDtRC;
  231. }
  232. cmDtRC_t cmDataGetLong( const cmData_t* p, long* vp )
  233. {
  234. switch( p->tid )
  235. {
  236. case kUCharDtId: *vp = (long)p->u.uc; break;
  237. case kCharDtId: *vp = (long)p->u.c; break;
  238. case kUShortDtId: *vp = (long)p->u.us; break;
  239. case kShortDtId: *vp = (long)p->u.s; break;
  240. case kUIntDtId: *vp = (long)p->u.ui; break;
  241. case kIntDtId: *vp = (long)p->u.i; break;
  242. case kULongDtId: *vp = (long)p->u.ul; break;
  243. case kLongDtId: *vp = p->u.l; break;
  244. case kFloatDtId: *vp = (long)p->u.f; break;
  245. case kDoubleDtId: *vp = (long)p->u.d; break;
  246. default:
  247. return _cmDataSetError(kCvtErrDtRC);
  248. }
  249. return kOkDtRC;
  250. }
  251. cmDtRC_t cmDataGetULong( const cmData_t* p, unsigned long* vp )
  252. {
  253. switch( p->tid )
  254. {
  255. case kUCharDtId: *vp = (unsigned long)p->u.uc; break;
  256. case kCharDtId: *vp = (unsigned long)p->u.c; break;
  257. case kUShortDtId: *vp = (unsigned long)p->u.us; break;
  258. case kShortDtId: *vp = (unsigned long)p->u.s; break;
  259. case kUIntDtId: *vp = (unsigned long)p->u.ui; break;
  260. case kIntDtId: *vp = (unsigned long)p->u.i; break;
  261. case kULongDtId: *vp = p->u.ul; break;
  262. case kLongDtId: *vp = (unsigned long)p->u.l; break;
  263. case kFloatDtId: *vp = (unsigned long)p->u.f; break;
  264. case kDoubleDtId: *vp = (unsigned long)p->u.d; break;
  265. default:
  266. return _cmDataSetError(kCvtErrDtRC);
  267. }
  268. return kOkDtRC;
  269. }
  270. cmDtRC_t cmDataGetFloat( const cmData_t* p, float* vp )
  271. {
  272. switch( p->tid )
  273. {
  274. case kUCharDtId: *vp = (float)p->u.uc; break;
  275. case kCharDtId: *vp = (float)p->u.c; break;
  276. case kUShortDtId: *vp = (float)p->u.us; break;
  277. case kShortDtId: *vp = (float)p->u.s; break;
  278. case kUIntDtId: *vp = (float)p->u.ui; break;
  279. case kIntDtId: *vp = (float)p->u.i; break;
  280. case kULongDtId: *vp = (float)p->u.ul; break;
  281. case kLongDtId: *vp = (float)p->u.l; break;
  282. case kFloatDtId: *vp = p->u.f; break;
  283. case kDoubleDtId: *vp = (float)p->u.d; break;
  284. default:
  285. return _cmDataSetError(kCvtErrDtRC);
  286. }
  287. return kOkDtRC;
  288. }
  289. cmDtRC_t cmDataGetDouble( const cmData_t* p, double* vp )
  290. {
  291. switch( p->tid )
  292. {
  293. case kUCharDtId: *vp = (double)p->u.uc; break;
  294. case kCharDtId: *vp = (double)p->u.c; break;
  295. case kUShortDtId: *vp = (double)p->u.us; break;
  296. case kShortDtId: *vp = (double)p->u.s; break;
  297. case kUIntDtId: *vp = (double)p->u.ui; break;
  298. case kIntDtId: *vp = (double)p->u.i; break;
  299. case kULongDtId: *vp = (double)p->u.ul; break;
  300. case kLongDtId: *vp = (double)p->u.l; break;
  301. case kFloatDtId: *vp = (double)p->u.f; break;
  302. case kDoubleDtId: *vp = p->u.d; break;
  303. default:
  304. return _cmDataSetError(kCvtErrDtRC);
  305. }
  306. return kOkDtRC;
  307. }
  308. cmDtRC_t cmDataGetStr( const cmData_t* p, cmChar_t** vp )
  309. {
  310. if( p->tid == kStrDtId || p->tid == kConstStrDtId)
  311. {
  312. *vp = (p->tid == kStrDtId || p->tid == kConstStrDtId) ? p->u.z : NULL;
  313. return kOkDtRC;
  314. }
  315. return _cmDataSetError(kCvtErrDtRC);
  316. }
  317. cmDtRC_t cmDataGetConstStr( const cmData_t* p, const cmChar_t** vp )
  318. {
  319. if( p->tid == kStrDtId || p->tid == kConstStrDtId)
  320. {
  321. *vp = (p->tid == kStrDtId || p->tid == kConstStrDtId) ? p->u.cz : NULL;
  322. return kOkDtRC;
  323. }
  324. return _cmDataSetError(kCvtErrDtRC);
  325. }
  326. cmDtRC_t cmDataGetVoidPtr( const cmData_t* p, void** vp )
  327. {
  328. if( kMinPtrDtId <= p->tid && p->tid <= kMaxPtrDtId )
  329. {
  330. *vp = ( kMinPtrDtId <= p->tid && p->tid <= kMaxPtrDtId ) ? p->u.vp : NULL;
  331. return kOkDtRC;
  332. }
  333. return _cmDataSetError(kCvtErrDtRC);
  334. }
  335. cmDtRC_t cmDataGetCharPtr( const cmData_t* p, char** vp )
  336. {
  337. if( p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId )
  338. {
  339. *vp = (p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId) ? p->u.cp : NULL;
  340. return kOkDtRC;
  341. }
  342. return _cmDataSetError(kCvtErrDtRC);
  343. }
  344. cmDtRC_t cmDataGetUCharPtr( const cmData_t* p, unsigned char** vp )
  345. {
  346. if( p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId )
  347. {
  348. *vp = (p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId) ? p->u.ucp : NULL;
  349. return kOkDtRC;
  350. }
  351. return _cmDataSetError(kCvtErrDtRC);
  352. }
  353. cmDtRC_t cmDataGetShortPtr( const cmData_t* p, short** vp )
  354. {
  355. if( p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId )
  356. {
  357. *vp = (p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId ) ? p->u.sp : NULL;
  358. return kOkDtRC;
  359. }
  360. return _cmDataSetError(kCvtErrDtRC);
  361. }
  362. cmDtRC_t cmDataGetUShortPtr( const cmData_t* p, unsigned short** vp )
  363. {
  364. if( p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId )
  365. {
  366. *vp = (p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId ) ? p->u.usp : NULL;
  367. return kOkDtRC;
  368. }
  369. return _cmDataSetError(kCvtErrDtRC);
  370. }
  371. cmDtRC_t cmDataGetIntPtr( const cmData_t* p, int** vp )
  372. {
  373. if( p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId )
  374. {
  375. *vp = (p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId ) ? p->u.ip : NULL;
  376. return kOkDtRC;
  377. }
  378. return _cmDataSetError(kCvtErrDtRC);
  379. }
  380. cmDtRC_t cmDataGetUIntPtr( const cmData_t* p, unsigned int** vp )
  381. {
  382. if( p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId )
  383. {
  384. *vp = (p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId ) ? p->u.uip : NULL;
  385. return kOkDtRC;
  386. }
  387. return _cmDataSetError(kCvtErrDtRC);
  388. }
  389. cmDtRC_t cmDataGetLongPtr( const cmData_t* p, long** vp )
  390. {
  391. if( p->tid == kLongPtrDtId || p->tid == kULongPtrDtId )
  392. {
  393. *vp = (p->tid == kLongPtrDtId || p->tid == kULongPtrDtId ) ? p->u.lp : NULL;
  394. return kOkDtRC;
  395. }
  396. return _cmDataSetError(kCvtErrDtRC);
  397. }
  398. cmDtRC_t cmDataGetULongPtr( const cmData_t* p, unsigned long** vp )
  399. {
  400. if( p->tid == kLongPtrDtId || p->tid == kULongPtrDtId )
  401. {
  402. *vp = (p->tid == kLongPtrDtId || p->tid == kULongPtrDtId ) ? p->u.ulp : NULL;
  403. return kOkDtRC;
  404. }
  405. return _cmDataSetError(kCvtErrDtRC);
  406. }
  407. cmDtRC_t cmDataGetFloatPtr( const cmData_t* p, float** vp )
  408. {
  409. if( p->tid == kFloatPtrDtId )
  410. {
  411. *vp = p->u.fp;
  412. return kOkDtRC;
  413. }
  414. return _cmDataSetError(kCvtErrDtRC);
  415. }
  416. cmDtRC_t cmDataGetDoublePtr( const cmData_t* p, double** vp )
  417. {
  418. if( p->tid == kDoublePtrDtId )
  419. {
  420. *vp = p->u.dp;
  421. return kOkDtRC;
  422. }
  423. return _cmDataSetError(kCvtErrDtRC);
  424. }
  425. // Set the value of an existing data object.
  426. cmData_t* cmDataSetNull( cmData_t* p )
  427. {
  428. _cmDataFreeArray(p);
  429. p->tid = kNullDtId;
  430. return p;
  431. }
  432. cmData_t* cmDataSetChar( cmData_t* p, char v )
  433. {
  434. _cmDataFreeArray(p);
  435. p->tid = kCharDtId;
  436. p->u.c = v;
  437. return p;
  438. }
  439. cmData_t* cmDataSetUChar( cmData_t* p, unsigned char v )
  440. {
  441. _cmDataFreeArray(p);
  442. p->tid = kUCharDtId;
  443. p->u.uc = v;
  444. return p;
  445. }
  446. cmData_t* cmDataSetShort( cmData_t* p, short v )
  447. {
  448. _cmDataFreeArray(p);
  449. p->tid = kShortDtId;
  450. p->u.s = v;
  451. return p;
  452. }
  453. cmData_t* cmDataSetUShort( cmData_t* p, unsigned short v )
  454. {
  455. _cmDataFreeArray(p);
  456. p->tid = kUShortDtId;
  457. p->u.us = v;
  458. return p;
  459. }
  460. cmData_t* cmDataSetInt( cmData_t* p, int v )
  461. {
  462. _cmDataFreeArray(p);
  463. p->tid = kCharDtId;
  464. p->u.c = v;
  465. return p;
  466. }
  467. cmData_t* cmDataSetUInt( cmData_t* p, unsigned int v )
  468. {
  469. _cmDataFreeArray(p);
  470. p->tid = kUIntDtId;
  471. p->u.ui = v;
  472. return p;
  473. }
  474. cmData_t* cmDataSetLong( cmData_t* p, long v )
  475. {
  476. _cmDataFreeArray(p);
  477. p->tid = kLongDtId;
  478. p->u.l = v;
  479. return p;
  480. }
  481. cmData_t* cmDataSetULong( cmData_t* p, unsigned long v )
  482. {
  483. _cmDataFreeArray(p);
  484. p->tid = kULongDtId;
  485. p->u.ul = v;
  486. return p;
  487. }
  488. cmData_t* cmDataSetFloat( cmData_t* p, float v )
  489. {
  490. _cmDataFreeArray(p);
  491. p->tid = kFloatDtId;
  492. p->u.f = v;
  493. return p;
  494. }
  495. cmData_t* cmDataSetDouble( cmData_t* p, double v )
  496. {
  497. _cmDataFreeArray(p);
  498. p->tid = kDoubleDtId;
  499. p->u.d = v;
  500. return p;
  501. }
  502. cmData_t* cmDataSetStr( cmData_t* p, cmChar_t* s )
  503. {
  504. _cmDataFreeArray(p);
  505. p->tid = kStrDtId;
  506. p->u.z = s;
  507. return p;
  508. }
  509. cmData_t* cmDataSetConstStr( cmData_t* p, const cmChar_t* s )
  510. {
  511. _cmDataFreeArray(p);
  512. p->tid = kConstStrDtId;
  513. p->u.cz = s;
  514. return p;
  515. }
  516. // Set the value of an existing data object to an external array.
  517. // The array is not copied.
  518. cmData_t* cmDataSetVoidPtr( cmData_t* p, void* vp, unsigned cnt )
  519. {
  520. cmDataSetCharPtr(p,(char*)vp,cnt);
  521. p->tid = kVoidPtrDtId;
  522. return p;
  523. }
  524. cmData_t* cmDataSetCharPtr( cmData_t* p, char* vp, unsigned cnt )
  525. {
  526. _cmDataFreeArray(p);
  527. p->tid = kCharPtrDtId;
  528. p->u.cp = vp;
  529. p->cnt = cnt;
  530. return p;
  531. }
  532. cmData_t* cmDataSetUCharPtr( cmData_t* p, unsigned char* vp, unsigned cnt )
  533. {
  534. _cmDataFreeArray(p);
  535. p->tid = kUCharPtrDtId;
  536. p->u.ucp = vp;
  537. p->cnt = cnt;
  538. return p;
  539. }
  540. cmData_t* cmDataSetShortPtr( cmData_t* p, short* vp, unsigned cnt )
  541. {
  542. _cmDataFreeArray(p);
  543. p->tid = kShortPtrDtId;
  544. p->u.sp = vp;
  545. p->cnt = cnt;
  546. return p;
  547. }
  548. cmData_t* cmDataSetUShortPtr( cmData_t* p, unsigned short* vp, unsigned cnt )
  549. {
  550. _cmDataFreeArray(p);
  551. p->tid = kUShortPtrDtId;
  552. p->u.usp = vp;
  553. p->cnt = cnt;
  554. return p;
  555. }
  556. cmData_t* cmDataSetIntPtr( cmData_t* p, int* vp, unsigned cnt )
  557. {
  558. _cmDataFreeArray(p);
  559. p->tid = kCharPtrDtId;
  560. p->u.ip = vp;
  561. p->cnt = cnt;
  562. return p;
  563. }
  564. cmData_t* cmDataSetUIntPtr( cmData_t* p, unsigned int* vp, unsigned cnt )
  565. {
  566. _cmDataFreeArray(p);
  567. p->tid = kUIntPtrDtId;
  568. p->u.uip = vp;
  569. p->cnt = cnt;
  570. return p;
  571. }
  572. cmData_t* cmDataSetLongPtr( cmData_t* p, long* vp, unsigned cnt )
  573. {
  574. _cmDataFreeArray(p);
  575. p->tid = kLongPtrDtId;
  576. p->u.lp = vp;
  577. p->cnt = cnt;
  578. return p;
  579. }
  580. cmData_t* cmDataSetULongPtr( cmData_t* p, unsigned long* vp, unsigned cnt )
  581. {
  582. _cmDataFreeArray(p);
  583. p->tid = kULongPtrDtId;
  584. p->u.ulp = vp;
  585. p->cnt = cnt;
  586. return p;
  587. }
  588. cmData_t* cmDataSetFloatPtr( cmData_t* p, float* vp, unsigned cnt )
  589. {
  590. _cmDataFreeArray(p);
  591. p->tid = kFloatPtrDtId;
  592. p->u.fp = vp;
  593. p->cnt = cnt;
  594. return p;
  595. }
  596. cmData_t* cmDataSetDoublePtr( cmData_t* p, double* vp, unsigned cnt )
  597. {
  598. _cmDataFreeArray(p);
  599. p->tid = kDoublePtrDtId;
  600. p->u.dp = vp;
  601. p->cnt = cnt;
  602. return p;
  603. }
  604. // Set the value of an existing array based data object.
  605. // Allocate the internal array and copy the array into it.
  606. cmData_t* cmDataSetStrAlloc( cmData_t* p, const cmChar_t* s )
  607. {
  608. if( cmIsFlag(p->flags,kDynPtrDtFl) )
  609. cmMemResizeStr(p->u.z,s);
  610. else
  611. {
  612. _cmDataFreeArray(p);
  613. p->u.z = cmMemAllocStr(s);
  614. }
  615. p->tid = kStrDtId;
  616. p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
  617. return p;
  618. }
  619. cmData_t* cmDataSetConstStrAlloc( cmData_t* p, const cmChar_t* s )
  620. { return cmDataSetStrAlloc(p,s); }
  621. cmData_t* cmDataSetVoidAllocPtr( cmData_t* p, const void* vp, unsigned cnt )
  622. { return cmDataSetCharAllocPtr(p,(char*)vp,cnt); }
  623. cmData_t* cmDataSetCharAllocPtr( cmData_t* p, const char* vp, unsigned cnt )
  624. {
  625. if( cmIsFlag(p->flags,kDynPtrDtFl) )
  626. p->u.cp = cmMemResize(char, p->u.cp, cnt );
  627. else
  628. {
  629. _cmDataFreeArray(p);
  630. p->u.cp = cmMemAlloc(char, cnt );
  631. }
  632. memcpy(p->u.cp,vp,sizeof(char)*cnt);
  633. p->tid = kCharPtrDtId;
  634. p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
  635. p->cnt = cnt;
  636. return p;
  637. }
  638. cmData_t* cmDataSetUCharAllocPtr( cmData_t* p, const unsigned char* vp, unsigned cnt )
  639. {
  640. if( cmIsFlag(p->flags,kDynPtrDtFl) )
  641. p->u.ucp = cmMemResize(unsigned char, p->u.ucp, cnt );
  642. else
  643. {
  644. _cmDataFreeArray(p);
  645. p->u.ucp = cmMemAlloc(unsigned char, cnt );
  646. }
  647. memcpy(p->u.ucp,vp,sizeof(unsigned char)*cnt);
  648. p->tid = kUCharPtrDtId;
  649. p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
  650. p->cnt = cnt;
  651. return p;
  652. }
  653. cmData_t* cmDataSetShortAllocPtr( cmData_t* p, const short* vp, unsigned cnt )
  654. {
  655. if( cmIsFlag(p->flags,kDynPtrDtFl) )
  656. p->u.sp = cmMemResize(short, p->u.sp, cnt );
  657. else
  658. {
  659. _cmDataFreeArray(p);
  660. p->u.sp = cmMemAlloc(short, cnt );
  661. }
  662. memcpy(p->u.sp,vp,sizeof(short)*cnt);
  663. p->tid = kShortPtrDtId;
  664. p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
  665. p->cnt = cnt;
  666. return p;
  667. }
  668. cmData_t* cmDataSetUShortAllocPtr( cmData_t* p, const unsigned short* vp, unsigned cnt )
  669. {
  670. if( cmIsFlag(p->flags,kDynPtrDtFl) )
  671. p->u.usp = cmMemResize(unsigned short, p->u.usp, cnt );
  672. else
  673. {
  674. _cmDataFreeArray(p);
  675. p->u.usp = cmMemAlloc(unsigned short, cnt );
  676. }
  677. memcpy(p->u.usp,vp,sizeof(unsigned short)*cnt);
  678. p->tid = kUShortPtrDtId;
  679. p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
  680. p->cnt = cnt;
  681. return p;
  682. }
  683. cmData_t* cmDataSetIntAllocPtr( cmData_t* p, const int* vp, unsigned cnt )
  684. {
  685. if( cmIsFlag(p->flags,kDynPtrDtFl) )
  686. p->u.ip = cmMemResize(int, p->u.ip, cnt );
  687. else
  688. {
  689. _cmDataFreeArray(p);
  690. p->u.ip = cmMemAlloc(int, cnt );
  691. }
  692. memcpy(p->u.ip,vp,sizeof(int)*cnt);
  693. p->tid = kIntPtrDtId;
  694. p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
  695. p->cnt = cnt;
  696. return p;
  697. }
  698. cmData_t* cmDataSetUIntAllocPtr( cmData_t* p, const unsigned int* vp, unsigned cnt )
  699. {
  700. if( cmIsFlag(p->flags,kDynPtrDtFl) )
  701. p->u.uip = cmMemResize(unsigned int, p->u.uip, cnt );
  702. else
  703. {
  704. _cmDataFreeArray(p);
  705. p->u.uip = cmMemAlloc(unsigned int, cnt );
  706. }
  707. memcpy(p->u.uip,vp,sizeof(unsigned int)*cnt);
  708. p->tid = kUIntPtrDtId;
  709. p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
  710. p->cnt = cnt;
  711. return p;
  712. }
  713. cmData_t* cmDataSetLongAllocPtr( cmData_t* p, const long* vp, unsigned cnt )
  714. {
  715. if( cmIsFlag(p->flags,kDynPtrDtFl) )
  716. p->u.lp = cmMemResize(long, p->u.lp, cnt );
  717. else
  718. {
  719. _cmDataFreeArray(p);
  720. p->u.lp = cmMemAlloc(long, cnt );
  721. }
  722. memcpy(p->u.lp,vp,sizeof(long)*cnt);
  723. p->tid = kLongPtrDtId;
  724. p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
  725. p->cnt = cnt;
  726. return p;
  727. }
  728. cmData_t* cmDataSetULongAllocPtr( cmData_t* p, const unsigned long* vp, unsigned cnt )
  729. {
  730. if( cmIsFlag(p->flags,kDynPtrDtFl) )
  731. p->u.ulp = cmMemResize(unsigned long, p->u.ulp, cnt );
  732. else
  733. {
  734. _cmDataFreeArray(p);
  735. p->u.ulp = cmMemAlloc(unsigned long, cnt );
  736. }
  737. memcpy(p->u.ulp,vp,sizeof(unsigned long)*cnt);
  738. p->tid = kULongPtrDtId;
  739. p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
  740. p->cnt = cnt;
  741. return p;
  742. }
  743. cmData_t* cmDataSetFloatAllocPtr( cmData_t* p, const float* vp, unsigned cnt )
  744. {
  745. if( cmIsFlag(p->flags,kDynPtrDtFl) )
  746. p->u.fp = cmMemResize(float, p->u.fp, cnt );
  747. else
  748. {
  749. _cmDataFreeArray(p);
  750. p->u.fp = cmMemAlloc(float, cnt );
  751. }
  752. memcpy(p->u.fp,vp,sizeof(float)*cnt);
  753. p->tid = kFloatPtrDtId;
  754. p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
  755. p->cnt = cnt;
  756. return p;
  757. }
  758. cmData_t* cmDataSetDoubleAllocPtr( cmData_t* p, const double* vp, unsigned cnt )
  759. {
  760. if( cmIsFlag(p->flags,kDynPtrDtFl) )
  761. p->u.dp = cmMemResize(double, p->u.dp, cnt );
  762. else
  763. {
  764. _cmDataFreeArray(p);
  765. p->u.dp = cmMemAlloc(double, cnt );
  766. }
  767. memcpy(p->u.dp,vp,sizeof(double)*cnt);
  768. p->tid = kDoublePtrDtId;
  769. p->flags = cmSetFlag(p->flags,kDynPtrDtFl);
  770. p->cnt = cnt;
  771. return p;
  772. }
  773. // Dynamically allocate a data object and set it's value.
  774. cmData_t* cmDataAllocNull( cmData_t* parent )
  775. { return _cmDataAllocNode(parent,kNullDtId); }
  776. cmData_t* cmDataAllocChar( cmData_t* parent, char v )
  777. {
  778. cmData_t* p = _cmDataAllocNode(parent,kCharDtId);
  779. cmDataSetChar(p,v);
  780. return p;
  781. }
  782. cmData_t* cmDataAllocUChar( cmData_t* parent, unsigned char v )
  783. {
  784. cmData_t* p = _cmDataAllocNode(parent,kUCharDtId);
  785. cmDataSetUChar(p,v);
  786. return p;
  787. }
  788. cmData_t* cmDataAllocShort( cmData_t* parent, short v )
  789. {
  790. cmData_t* p = _cmDataAllocNode(parent,kShortDtId);
  791. cmDataSetShort(p,v);
  792. return p;
  793. }
  794. cmData_t* cmDataAllocUShort( cmData_t* parent, unsigned short v )
  795. {
  796. cmData_t* p = _cmDataAllocNode(parent,kUShortDtId);
  797. cmDataSetUShort(p,v);
  798. return p;
  799. }
  800. cmData_t* cmDataAllocInt( cmData_t* parent, int v )
  801. {
  802. cmData_t* p = _cmDataAllocNode(parent,kIntDtId);
  803. cmDataSetInt(p,v);
  804. return p;
  805. }
  806. cmData_t* cmDataAllocUInt( cmData_t* parent, unsigned int v )
  807. {
  808. cmData_t* p = _cmDataAllocNode(parent,kUIntDtId);
  809. cmDataSetUInt(p,v);
  810. return p;
  811. }
  812. cmData_t* cmDataAllocLong( cmData_t* parent, long v )
  813. {
  814. cmData_t* p = _cmDataAllocNode(parent,kLongDtId);
  815. cmDataSetLong(p,v);
  816. return p;
  817. }
  818. cmData_t* cmDataAllocULong( cmData_t* parent, unsigned long v )
  819. {
  820. cmData_t* p = _cmDataAllocNode(parent,kULongDtId);
  821. cmDataSetULong(p,v);
  822. return p;
  823. }
  824. cmData_t* cmDataAllocFloat( cmData_t* parent, float v )
  825. {
  826. cmData_t* p = _cmDataAllocNode(parent,kFloatDtId);
  827. cmDataSetFloat(p,v);
  828. return p;
  829. }
  830. cmData_t* cmDataAllocDouble( cmData_t* parent, double v )
  831. {
  832. cmData_t* p = _cmDataAllocNode(parent,kDoubleDtId);
  833. cmDataSetDouble(p,v);
  834. return p;
  835. }
  836. // Dynamically allocate a data object and set its array value to an external
  837. // array. The data is not copied.
  838. cmData_t* cmDataAllocStr( cmData_t* parent, cmChar_t* str )
  839. {
  840. cmData_t* p = _cmDataAllocNode(parent,kStrDtId);
  841. cmDataSetStr(p,str);
  842. return p;
  843. }
  844. cmData_t* cmDataAllocConstStr( cmData_t* parent, const cmChar_t* str )
  845. {
  846. cmData_t* p = _cmDataAllocNode(parent,kConstStrDtId);
  847. cmDataSetConstStr(p,str);
  848. return p;
  849. }
  850. cmData_t* cmDataAllocCharPtr( cmData_t* parent, char* v, unsigned cnt )
  851. {
  852. cmData_t* p = _cmDataAllocNode(parent,kCharPtrDtId);
  853. cmDataSetCharPtr(p,(char*)v,cnt);
  854. return p;
  855. }
  856. cmData_t* cmDataAllocUCharPtr( cmData_t* parent, unsigned char* v, unsigned cnt )
  857. {
  858. cmData_t* p = _cmDataAllocNode(parent,kUCharPtrDtId);
  859. cmDataSetUCharPtr(p,(unsigned char*)v,cnt);
  860. return p;
  861. }
  862. cmData_t* cmDataAllocShortPtr( cmData_t* parent, short* v, unsigned cnt )
  863. {
  864. cmData_t* p = _cmDataAllocNode(parent,kShortPtrDtId);
  865. cmDataSetShortPtr(p,(short*)v,cnt);
  866. return p;
  867. }
  868. cmData_t* cmDataAllocUShortPtr( cmData_t* parent, unsigned short* v, unsigned cnt )
  869. {
  870. cmData_t* p = _cmDataAllocNode(parent,kUShortPtrDtId);
  871. cmDataSetUShortPtr(p,(unsigned short*)v,cnt);
  872. return p;
  873. }
  874. cmData_t* cmDataAllocIntPtr( cmData_t* parent, int* v, unsigned cnt )
  875. {
  876. cmData_t* p = _cmDataAllocNode(parent,kIntPtrDtId);
  877. cmDataSetIntPtr(p,(int*)v,cnt);
  878. return p;
  879. }
  880. cmData_t* cmDataAllocUIntPtr( cmData_t* parent, unsigned int* v, unsigned cnt )
  881. {
  882. cmData_t* p = _cmDataAllocNode(parent,kUIntPtrDtId);
  883. cmDataSetUIntPtr(p,(unsigned int*)v,cnt);
  884. return p;
  885. }
  886. cmData_t* cmDataAllocLongPtr( cmData_t* parent, long* v, unsigned cnt )
  887. {
  888. cmData_t* p = _cmDataAllocNode(parent,kLongPtrDtId);
  889. cmDataSetLongPtr(p,(long*)v,cnt);
  890. return p;
  891. }
  892. cmData_t* cmDataAllocULongPtr( cmData_t* parent, unsigned long* v, unsigned cnt )
  893. {
  894. cmData_t* p = _cmDataAllocNode(parent,kULongPtrDtId);
  895. cmDataSetULongPtr(p,(unsigned long*)v,cnt);
  896. return p;
  897. }
  898. cmData_t* cmDataAllocFloatPtr( cmData_t* parent, float* v, unsigned cnt )
  899. {
  900. cmData_t* p = _cmDataAllocNode(parent,kFloatPtrDtId);
  901. cmDataSetFloatPtr(p,(float*)v,cnt);
  902. return p;
  903. }
  904. cmData_t* cmDataAllocDoublePtr( cmData_t* parent, double* v, unsigned cnt )
  905. {
  906. cmData_t* p = _cmDataAllocNode(parent,kDoublePtrDtId);
  907. cmDataSetDoublePtr(p,(double*)v,cnt);
  908. return p;
  909. }
  910. cmData_t* cmDataAllocVoidPtr( cmData_t* parent, void* v, unsigned cnt )
  911. {
  912. cmData_t* p = _cmDataAllocNode(parent,kVoidPtrDtId);
  913. cmDataSetCharPtr(p,(char*)v,cnt);
  914. p->tid = kVoidPtrDtId;
  915. return p;
  916. }
  917. // Dynamically allocate a data object and its array value.
  918. // v[cnt] is copied into the allocated array.
  919. cmData_t* cmDataStrAlloc( cmData_t* parent, cmChar_t* str )
  920. {
  921. cmData_t* p = _cmDataAllocNode(parent,kStrDtId);
  922. cmDataSetStrAlloc(p,str);
  923. return p;
  924. }
  925. cmData_t* cmDataConstStrAlloc( cmData_t* parent, const cmChar_t* str )
  926. {
  927. cmData_t* p = _cmDataAllocNode(parent,kConstStrDtId);
  928. cmDataSetConstStrAlloc(p,str);
  929. return p;
  930. }
  931. cmData_t* cmDataCharAllocPtr( cmData_t* parent, const char* v, unsigned cnt )
  932. {
  933. cmData_t* p = _cmDataAllocNode(parent,kCharPtrDtId);
  934. cmDataSetCharAllocPtr(p, v, cnt );
  935. return p;
  936. }
  937. cmData_t* cmDataUCharAllocPtr( cmData_t* parent, const unsigned char* v, unsigned cnt )
  938. {
  939. cmData_t* p = _cmDataAllocNode(parent,kUCharPtrDtId);
  940. cmDataSetUCharAllocPtr(p, v, cnt );
  941. return p;
  942. }
  943. cmData_t* cmDataShortAllocPtr( cmData_t* parent, const short* v, unsigned cnt )
  944. {
  945. cmData_t* p = _cmDataAllocNode(parent,kShortPtrDtId);
  946. cmDataSetShortAllocPtr(p, v, cnt );
  947. return p;
  948. }
  949. cmData_t* cmDataUShortAllocPtr( cmData_t* parent, const unsigned short* v, unsigned cnt )
  950. {
  951. cmData_t* p = _cmDataAllocNode(parent,kUShortPtrDtId);
  952. cmDataSetUShortAllocPtr(p, v, cnt );
  953. return p;
  954. }
  955. cmData_t* cmDataIntAllocPtr( cmData_t* parent, const int* v, unsigned cnt )
  956. {
  957. cmData_t* p = _cmDataAllocNode(parent,kIntPtrDtId);
  958. cmDataSetIntAllocPtr(p, v, cnt );
  959. return p;
  960. }
  961. cmData_t* cmDataUIntAllocPtr( cmData_t* parent, const unsigned int* v, unsigned cnt )
  962. {
  963. cmData_t* p = _cmDataAllocNode(parent,kUIntPtrDtId);
  964. cmDataSetUIntAllocPtr(p, v, cnt );
  965. return p;
  966. }
  967. cmData_t* cmDataLongAllocPtr( cmData_t* parent, const long* v, unsigned cnt )
  968. {
  969. cmData_t* p = _cmDataAllocNode(parent,kLongPtrDtId);
  970. cmDataSetLongAllocPtr(p, v, cnt );
  971. return p;
  972. }
  973. cmData_t* cmDataULongAllocPtr( cmData_t* parent, const unsigned long* v, unsigned cnt )
  974. {
  975. cmData_t* p = _cmDataAllocNode(parent,kULongPtrDtId);
  976. cmDataSetULongAllocPtr(p, v, cnt );
  977. return p;
  978. }
  979. cmData_t* cmDataFloatAllocPtr( cmData_t* parent, const float* v, unsigned cnt )
  980. {
  981. cmData_t* p = _cmDataAllocNode(parent,kFloatPtrDtId);
  982. cmDataSetFloatAllocPtr(p, v, cnt );
  983. return p;
  984. }
  985. cmData_t* cmDataDoubleAllocPtr( cmData_t* parent, const double* v, unsigned cnt )
  986. {
  987. cmData_t* p = _cmDataAllocNode(parent,kDoublePtrDtId);
  988. cmDataSetDoubleAllocPtr(p, v, cnt );
  989. return p;
  990. }
  991. cmData_t* cmDataVoidAllocPtr( cmData_t* parent, const void* v, unsigned cnt )
  992. {
  993. cmData_t* p = _cmDataAllocNode(parent,kVoidPtrDtId);
  994. cmDataSetCharAllocPtr(p, (const char*)v, cnt );
  995. p->tid = kVoidPtrDtId;
  996. return p;
  997. }
  998. void cmDataFree( cmData_t* p )
  999. {
  1000. _cmDataFree(p);
  1001. }
  1002. cmData_t* cmDataUnlink( cmData_t* p )
  1003. {
  1004. if( p->parent == NULL )
  1005. return p;
  1006. assert( cmDataIsStruct(p->parent) );
  1007. cmData_t* cp = p->u.child;
  1008. cmData_t* pp = NULL;
  1009. for(; cp!=NULL; cp=cp->sibling)
  1010. if( cp == p )
  1011. {
  1012. if( pp == NULL )
  1013. p->parent->u.child = p->sibling;
  1014. else
  1015. pp->sibling = cp->sibling;
  1016. }
  1017. return p;
  1018. }
  1019. void cmDataUnlinkAndFree( cmData_t* p )
  1020. {
  1021. cmDataUnlink(p);
  1022. cmDataFree(p);
  1023. }
  1024. cmData_t* _cmDataDupl( const cmData_t* p, cmData_t* parent )
  1025. {
  1026. cmData_t* rp = NULL;
  1027. switch( p->tid )
  1028. {
  1029. case kNullDtId: rp = cmDataAllocNull(parent); break;
  1030. case kUCharDtId: rp = cmDataAllocUChar(parent,p->u.uc); break;
  1031. case kCharDtId: rp = cmDataAllocChar(parent,p->u.c); break;
  1032. case kUShortDtId: rp = cmDataAllocShort(parent,p->u.us); break;
  1033. case kShortDtId: rp = cmDataAllocUShort(parent,p->u.s); break;
  1034. case kUIntDtId: rp = cmDataAllocUInt(parent,p->u.i); break;
  1035. case kIntDtId: rp = cmDataAllocInt(parent,p->u.ui); break;
  1036. case kULongDtId: rp = cmDataAllocULong(parent,p->u.ul); break;
  1037. case kLongDtId: rp = cmDataAllocLong(parent,p->u.l); break;
  1038. case kFloatDtId: rp = cmDataAllocFloat(parent,p->u.f); break;
  1039. case kDoubleDtId: rp = cmDataAllocDouble(parent,p->u.d); break;
  1040. case kStrDtId: rp = cmDataStrAlloc(parent,p->u.z); break;
  1041. case kConstStrDtId: rp = cmDataConstStrAlloc(parent,p->u.cz); break;
  1042. case kUCharPtrDtId: rp = cmDataUCharAllocPtr(parent,p->u.ucp,p->cnt); break;
  1043. case kCharPtrDtId: rp = cmDataCharAllocPtr(parent,p->u.cp,p->cnt); break;
  1044. case kUShortPtrDtId: rp = cmDataUShortAllocPtr(parent,p->u.usp,p->cnt); break;
  1045. case kShortPtrDtId: rp = cmDataShortAllocPtr(parent,p->u.sp,p->cnt); break;
  1046. case kUIntPtrDtId: rp = cmDataUIntAllocPtr(parent,p->u.uip,p->cnt); break;
  1047. case kIntPtrDtId: rp = cmDataIntAllocPtr(parent,p->u.ip,p->cnt); break;
  1048. case kULongPtrDtId: rp = cmDataULongAllocPtr(parent,p->u.ulp,p->cnt); break;
  1049. case kLongPtrDtId: rp = cmDataLongAllocPtr(parent,p->u.lp,p->cnt); break;
  1050. case kFloatPtrDtId: rp = cmDataFloatAllocPtr(parent,p->u.fp,p->cnt); break;
  1051. case kDoublePtrDtId: rp = cmDataDoubleAllocPtr(parent,p->u.dp,p->cnt); break;
  1052. case kVoidPtrDtId: rp = cmDataVoidAllocPtr(parent,p->u.vp,p->cnt); break;
  1053. case kListDtId:
  1054. case kPairDtId:
  1055. case kRecordDtId:
  1056. {
  1057. rp = _cmDataAllocNode(parent,p->tid);
  1058. cmData_t* cp = p->u.child;
  1059. for(; cp!=NULL; cp=cp->sibling)
  1060. cmDataAppendChild(rp,_cmDataDupl(cp,rp));
  1061. }
  1062. break;
  1063. default:
  1064. assert(0);
  1065. }
  1066. return rp;
  1067. }
  1068. cmData_t* cmDataDupl( const cmData_t* p )
  1069. { return _cmDataDupl(p,NULL); }
  1070. cmData_t* cmDataReplace( cmData_t* dst, cmData_t* src )
  1071. {
  1072. if( dst->parent == NULL )
  1073. {
  1074. cmDataUnlinkAndFree(dst);
  1075. src->parent = NULL;
  1076. return src;
  1077. }
  1078. cmData_t* parent = dst->parent;
  1079. cmData_t* cp = parent->u.child;
  1080. cmData_t* pp = NULL;
  1081. unsigned i = 0;
  1082. unsigned n = cmDataChildCount(parent);
  1083. // locate dst's right sibling
  1084. for(i=0; i<n; ++i,cp=cp->sibling)
  1085. {
  1086. if( cp == dst )
  1087. {
  1088. // link in 'src' in place of 'dst'
  1089. src->sibling = dst->sibling;
  1090. // free dst
  1091. cmDataUnlinkAndFree(dst);
  1092. // update the sibling link to
  1093. if( pp == NULL )
  1094. parent->u.child = src;
  1095. else
  1096. pp->sibling = src;
  1097. src->parent = parent;
  1098. break;
  1099. }
  1100. pp = cp;
  1101. }
  1102. return src;
  1103. }
  1104. unsigned cmDataChildCount( const cmData_t* p )
  1105. {
  1106. if( !cmDataIsStruct(p) )
  1107. return 0;
  1108. unsigned n = 0;
  1109. const cmData_t* cp = p->u.child;
  1110. for(; cp!=NULL; cp=cp->sibling)
  1111. ++n;
  1112. return n;
  1113. }
  1114. cmData_t* cmDataChild( cmData_t* p, unsigned index )
  1115. {
  1116. if( !cmDataIsStruct(p) )
  1117. return NULL;
  1118. unsigned n = 0;
  1119. cmData_t* cp = p->u.child;
  1120. for(; cp!=NULL; cp=cp->sibling)
  1121. {
  1122. if( n == index )
  1123. break;
  1124. ++n;
  1125. }
  1126. return cp;
  1127. }
  1128. cmData_t* cmDataPrependChild(cmData_t* parent, cmData_t* p )
  1129. {
  1130. assert( cmDataIsStruct(p) );
  1131. cmDataUnlink(p);
  1132. p->u.child = parent->u.child;
  1133. parent->u.child = p;
  1134. p->parent = parent;
  1135. return p;
  1136. }
  1137. cmData_t* cmDataAppendChild( cmData_t* parent, cmData_t* p )
  1138. {
  1139. assert( cmDataIsStruct(parent) );
  1140. assert( parent->tid != kRecordDtId || (parent->tid == kRecordDtId && p->tid==kPairDtId));
  1141. cmDataUnlink(p);
  1142. cmData_t* cp = parent->u.child;
  1143. if( cp == NULL )
  1144. parent->u.child = p;
  1145. else
  1146. {
  1147. for(; cp!=NULL; cp=cp->sibling)
  1148. if( cp->sibling == NULL )
  1149. {
  1150. cp->sibling = p;
  1151. break;
  1152. }
  1153. }
  1154. p->parent = parent;
  1155. p->sibling = NULL;
  1156. return p;
  1157. }
  1158. cmData_t* cmDataInsertChild( cmData_t* parent, unsigned index, cmData_t* p )
  1159. {
  1160. if( !cmDataIsStruct(parent) )
  1161. return NULL;
  1162. cmDataUnlink(p);
  1163. unsigned n = 0;
  1164. cmData_t* cp = parent->u.child;
  1165. cmData_t* pp = NULL;
  1166. for(; cp!=NULL; cp=cp->sibling)
  1167. {
  1168. if( n == index )
  1169. {
  1170. if( pp == NULL )
  1171. {
  1172. parent->u.child = p;
  1173. p->sibling = NULL;
  1174. }
  1175. else
  1176. {
  1177. p->sibling = pp->sibling;
  1178. pp->sibling = p;
  1179. }
  1180. break;
  1181. }
  1182. ++n;
  1183. }
  1184. p->parent = parent;
  1185. return p;
  1186. }
  1187. //----------------------------------------------------------------------------
  1188. bool _cmDataPairIsValid( const cmData_t* p )
  1189. {
  1190. assert( p->tid == kPairDtId );
  1191. const cmData_t* cp = p->u.child;
  1192. bool fl = cp->u.child == NULL || cp->u.child->sibling == NULL || cp->u.child->sibling->sibling!=NULL;
  1193. return !fl;
  1194. }
  1195. // Get the key/value of a pair
  1196. cmData_t* cmDataPairKey( cmData_t* p )
  1197. {
  1198. assert( _cmDataPairIsValid(p) );
  1199. return p->u.child;
  1200. }
  1201. unsigned cmDataPairKeyId( cmData_t* p )
  1202. {
  1203. assert( _cmDataPairIsValid(p) );
  1204. unsigned id = cmInvalidId;
  1205. cmDataGetUInt(p->u.child,&id);
  1206. return id;
  1207. }
  1208. const cmChar_t* cmDataPairKeyLabel( cmData_t* p )
  1209. {
  1210. assert( _cmDataPairIsValid(p) );
  1211. const cmChar_t* label = NULL;
  1212. cmDataGetConstStr(p->u.child,&label);
  1213. return label;
  1214. }
  1215. cmData_t* cmDataPairValue( cmData_t* p )
  1216. {
  1217. assert( _cmDataPairIsValid(p) );
  1218. return p->u.child->sibling;
  1219. }
  1220. // Set the key or value of an existing pair node.
  1221. cmData_t* cmDataPairSetValue( cmData_t* p, cmData_t* value )
  1222. {
  1223. assert( _cmDataPairIsValid(p) );
  1224. cmDataReplace( cmDataPairValue(p), value );
  1225. return p;
  1226. }
  1227. cmData_t* cmDataPairSetKey( cmData_t* p, cmData_t* key )
  1228. {
  1229. assert( _cmDataPairIsValid(p) );
  1230. cmDataReplace( cmDataPairValue(p), key );
  1231. return p;
  1232. }
  1233. cmData_t* cmDataPairSetKeyId( cmData_t* p, unsigned id )
  1234. {
  1235. assert( _cmDataPairIsValid(p) );
  1236. cmDataSetUInt(p->u.child,id);
  1237. return p;
  1238. }
  1239. cmData_t* cmDataPairSetKeyLabel( cmData_t* p, const cmChar_t* label )
  1240. {
  1241. assert( _cmDataPairIsValid(p) );
  1242. cmDataSetConstStrAlloc(p->u.child,label);
  1243. return p;
  1244. }
  1245. cmData_t* cmDataMakePair( cmData_t* parent, cmData_t* p, cmData_t* key, cmData_t* value )
  1246. {
  1247. _cmDataFree(p);
  1248. p->tid = kPairDtId;
  1249. p->parent = parent;
  1250. p->flags = 0;
  1251. p->u.child = NULL;
  1252. cmDataAppendChild(p,key);
  1253. cmDataAppendChild(p,value);
  1254. return p;
  1255. }
  1256. // Dynamically allocate a pair node
  1257. cmData_t* cmDataAllocPair( cmData_t* parent, const cmData_t* key, const cmData_t* value )
  1258. {
  1259. cmData_t* p = _cmDataAllocNode(parent,kPairDtId);
  1260. cmData_t* kp = cmDataDupl(key);
  1261. cmData_t* vp = cmDataDupl(value);
  1262. cmDataPrependChild(p,vp);
  1263. cmDataPrependChild(p,kp);
  1264. return p;
  1265. }
  1266. cmData_t* cmDataAllocPairId(cmData_t* parent, unsigned keyId, cmData_t* value )
  1267. {
  1268. cmData_t* p = _cmDataAllocNode(parent,kPairDtId);
  1269. cmDataAllocUInt(p,keyId);
  1270. cmDataAppendChild(p,value);
  1271. return p;
  1272. }
  1273. cmData_t* cmDataAllocPairLabel( cmData_t* parent, const cmChar_t *label, cmData_t* value )
  1274. {
  1275. cmData_t* p = _cmDataAllocNode(parent,kPairDtId);
  1276. cmDataConstStrAlloc(p,label);
  1277. cmDataAppendChild(p,value);
  1278. return p;
  1279. }
  1280. //----------------------------------------------------------------------------
  1281. unsigned cmDataListCount(const cmData_t* p )
  1282. { return cmDataChildCount(p); }
  1283. cmData_t* cmDataListEle( cmData_t* p, unsigned index )
  1284. { return cmDataChild(p,index); }
  1285. cmData_t* cmDataListMake( cmData_t* parent, cmData_t* p )
  1286. {
  1287. _cmDataFree(p);
  1288. p->parent = parent;
  1289. p->tid = kListDtId;
  1290. p->flags = 0;
  1291. p->u.child = NULL;
  1292. return p;
  1293. }
  1294. cmData_t* cmDataListAlloc( cmData_t* parent)
  1295. { return _cmDataAllocNode(parent,kListDtId); }
  1296. cmDtRC_t _cmDataParseArgV( cmData_t* parent, va_list vl, cmData_t** vpp )
  1297. {
  1298. cmDtRC_t rc = kOkDtRC;
  1299. cmData_t* vp = NULL;
  1300. unsigned tid = va_arg(vl,unsigned);
  1301. switch(tid)
  1302. {
  1303. case kInvalidDtId: rc = kEolDtRC; break;
  1304. case kNullDtId: vp = cmDataAllocNull(parent); break;
  1305. case kUCharDtId: vp = cmDataAllocUChar( parent,va_arg(vl,int)); break;
  1306. case kCharDtId: vp = cmDataAllocChar( parent,va_arg(vl,int)); break;
  1307. case kUShortDtId: vp = cmDataAllocUShort( parent,va_arg(vl,int)); break;
  1308. case kShortDtId: vp = cmDataAllocShort( parent,va_arg(vl,int)); break;
  1309. case kUIntDtId: vp = cmDataAllocUInt( parent,va_arg(vl,unsigned int)); break;
  1310. case kIntDtId: vp = cmDataAllocInt( parent,va_arg(vl,int)); break;
  1311. case kULongDtId: vp = cmDataAllocULong( parent,va_arg(vl,unsigned long)); break;
  1312. case kLongDtId: vp = cmDataAllocLong( parent,va_arg(vl,long)); break;
  1313. case kFloatDtId: vp = cmDataAllocFloat( parent,va_arg(vl,double)); break;
  1314. case kDoubleDtId: vp = cmDataAllocDouble( parent,va_arg(vl,double)); break;
  1315. case kStrDtId: vp = cmDataStrAlloc( parent,va_arg(vl,cmChar_t*)); break;
  1316. case kConstStrDtId: vp = cmDataConstStrAlloc( parent,va_arg(vl,const cmChar_t*)); break;
  1317. case kUCharPtrDtId:
  1318. {
  1319. unsigned char* p = va_arg(vl,unsigned char*);
  1320. vp = cmDataUCharAllocPtr(parent, p, va_arg(vl,unsigned));
  1321. }
  1322. break;
  1323. case kCharPtrDtId:
  1324. {
  1325. char* p = va_arg(vl,char*);
  1326. vp = cmDataCharAllocPtr(parent, p, va_arg(vl,unsigned));
  1327. }
  1328. break;
  1329. case kUShortPtrDtId:
  1330. {
  1331. unsigned short* p = va_arg(vl,unsigned short*);
  1332. vp = cmDataUShortAllocPtr(parent, p, va_arg(vl,unsigned));
  1333. }
  1334. break;
  1335. case kShortPtrDtId:
  1336. {
  1337. short* p = va_arg(vl,short*);
  1338. vp = cmDataShortAllocPtr(parent, p, va_arg(vl,unsigned));
  1339. }
  1340. break;
  1341. case kUIntPtrDtId:
  1342. {
  1343. unsigned int* p = va_arg(vl,unsigned int*);
  1344. vp = cmDataUIntAllocPtr(parent, p, va_arg(vl,unsigned));
  1345. }
  1346. break;
  1347. case kIntPtrDtId:
  1348. {
  1349. int * p = va_arg(vl,int*);
  1350. vp = cmDataIntAllocPtr(parent, p, va_arg(vl,unsigned));
  1351. }
  1352. break;
  1353. case kULongPtrDtId:
  1354. {
  1355. unsigned long* p = va_arg(vl,unsigned long*);
  1356. vp = cmDataULongAllocPtr(parent, p, va_arg(vl,unsigned));
  1357. }
  1358. break;
  1359. case kLongPtrDtId:
  1360. {
  1361. long* p = va_arg(vl,long*);
  1362. vp = cmDataLongAllocPtr(parent, p, va_arg(vl,unsigned));
  1363. }
  1364. break;
  1365. case kFloatPtrDtId:
  1366. {
  1367. float* p = va_arg(vl,float*);
  1368. vp = cmDataFloatAllocPtr(parent, p, va_arg(vl,unsigned));
  1369. }
  1370. break;
  1371. case kDoublePtrDtId:
  1372. {
  1373. double* p = va_arg(vl,double*);
  1374. vp = cmDataDoubleAllocPtr(parent,p, va_arg(vl,unsigned));
  1375. }
  1376. break;
  1377. case kVoidPtrDtId:
  1378. {
  1379. void* p = va_arg(vl,void*);
  1380. vp = cmDataVoidAllocPtr(parent, p, va_arg(vl,unsigned));
  1381. }
  1382. break;
  1383. case kListDtId:
  1384. case kPairDtId:
  1385. case kRecordDtId:
  1386. vp = _cmDataAllocNode(parent,tid);
  1387. break;
  1388. default:
  1389. _cmDataSetError(kVarArgErrDtRC);
  1390. break;
  1391. }
  1392. *vpp = vp;
  1393. return rc;
  1394. }
  1395. cmData_t* _cmDataListParseV(cmData_t* parent, va_list vl )
  1396. {
  1397. cmData_t* p = NULL;
  1398. bool contFl = true;
  1399. while( contFl )
  1400. {
  1401. cmData_t* vp;
  1402. cmDtRC_t rc = _cmDataParseArgV(parent, vl, &vp);
  1403. if(rc != kOkDtRC || cmDataAppendChild(parent,vp)==NULL )
  1404. contFl = false;
  1405. }
  1406. return p;
  1407. }
  1408. cmData_t* cmDataListAllocV(cmData_t* parent, va_list vl )
  1409. {
  1410. cmData_t* p = cmDataListAlloc(parent);
  1411. _cmDataListParseV(p, vl );
  1412. return p;
  1413. }
  1414. cmData_t* cmDataListAllocA(cmData_t* parent, ... )
  1415. {
  1416. va_list vl;
  1417. va_start(vl,parent);
  1418. cmData_t* p = cmDataListAllocV(parent,vl);
  1419. va_end(vl);
  1420. return p;
  1421. }
  1422. cmData_t* cmDataListAppendEle( cmData_t* p, cmData_t* ele )
  1423. {
  1424. assert(p->tid == kListDtId);
  1425. return cmDataAppendChild(p,ele);
  1426. }
  1427. cmData_t* cmDataListAppendEleN(cmData_t* p, cmData_t* ele[], unsigned n )
  1428. {
  1429. assert(p->tid == kListDtId);
  1430. cmData_t* rp = NULL;
  1431. unsigned i;
  1432. for(i=0; i<n; ++i)
  1433. {
  1434. cmData_t* ep = cmDataAppendChild(p,ele[i]);
  1435. if( rp == NULL )
  1436. rp = ep;
  1437. }
  1438. return rp;
  1439. }
  1440. cmDtRC_t cmDataListAppendV( cmData_t* p, va_list vl )
  1441. {
  1442. if( _cmDataListParseV(p, vl ) == NULL )
  1443. return _cmDataErrNo;
  1444. return kOkDtRC;
  1445. }
  1446. cmDtRC_t cmDataListAppend( cmData_t* p, ... )
  1447. {
  1448. va_list vl;
  1449. va_start(vl,p);
  1450. cmDtRC_t rc = cmDataListAppendV(p,vl);
  1451. va_end(vl);
  1452. return rc;
  1453. }
  1454. cmData_t* cmDataListInsertEle( cmData_t* p, unsigned index, cmData_t* ele )
  1455. { return cmDataInsertChild(p,index,ele); }
  1456. cmData_t* cmDataListInsertEleN(cmData_t* p, unsigned index, cmData_t* ele[], unsigned n )
  1457. {
  1458. unsigned i;
  1459. for(i=0; i<n; ++i)
  1460. cmDataListInsertEle(p,index+i,ele[i]);
  1461. return p;
  1462. }
  1463. //----------------------------------------------------------------------------
  1464. unsigned cmDataRecdCount( const cmData_t* p )
  1465. {
  1466. assert( p->tid == kRecordDtId );
  1467. return cmDataChildCount(p);
  1468. }
  1469. cmData_t* cmDataRecdEle( cmData_t* p, unsigned index )
  1470. {
  1471. assert( p->tid == kRecordDtId );
  1472. cmData_t* cp = cmDataChild(p,index);
  1473. assert( p->tid == kPairDtId );
  1474. return cp;
  1475. }
  1476. cmData_t* cmDataRecdValueFromIndex( cmData_t* p, unsigned index )
  1477. {
  1478. assert( p->tid == kRecordDtId );
  1479. cmData_t* cp = cmDataChild(p,index);
  1480. assert( p->tid == kPairDtId );
  1481. return cmDataPairValue(cp);
  1482. }
  1483. cmData_t* cmDataRecdValueFromId( cmData_t* p, unsigned id )
  1484. {
  1485. assert( p->tid == kRecordDtId );
  1486. cmData_t* cp = p->u.child;
  1487. for(; cp!=NULL; cp=cp->sibling)
  1488. if( cmDataPairKeyId(cp) == id )
  1489. break;
  1490. assert( cp!=NULL && cp->tid==kPairDtId );
  1491. return cmDataPairValue(cp);
  1492. }
  1493. cmData_t* cmDataRecdValueFromLabel( cmData_t* p, const cmChar_t* label )
  1494. {
  1495. assert( p->tid == kRecordDtId );
  1496. cmData_t* cp = p->u.child;
  1497. for(; cp!=NULL; cp=cp->sibling)
  1498. {
  1499. const cmChar_t* lp = cmDataPairKeyLabel(cp);
  1500. if( lp!=NULL && strcmp(lp,label)==0 )
  1501. break;
  1502. }
  1503. assert( cp!=NULL && cp->tid==kPairDtId );
  1504. return cmDataPairValue(cp);
  1505. }
  1506. cmData_t* cmDataRecdKey( cmData_t* p, unsigned index )
  1507. {
  1508. assert( p->tid == kRecordDtId );
  1509. cmData_t* cp = cmDataChild(p,index);
  1510. assert( p->tid == kPairDtId );
  1511. return cmDataPairKey(cp);
  1512. }
  1513. unsigned cmDataRecdKeyId( cmData_t* p, unsigned index )
  1514. {
  1515. cmData_t* kp = cmDataRecdKey(p,index);
  1516. unsigned id = cmInvalidId;
  1517. cmDataGetUInt(kp,&id);
  1518. return id;
  1519. }
  1520. const cmChar_t* cmDataRecdKeyLabel( cmData_t* p, unsigned index )
  1521. {
  1522. cmData_t* kp = cmDataRecdKey(p,index);
  1523. const cmChar_t* label = NULL;
  1524. cmDataGetConstStr(kp,&label);
  1525. return label;
  1526. }
  1527. cmData_t* cmRecdMake( cmData_t* parent, cmData_t* p )
  1528. {
  1529. _cmDataFree(p);
  1530. p->parent = parent;
  1531. p->tid = kRecordDtId;
  1532. p->flags = 0;
  1533. p->u.child = NULL;
  1534. return p;
  1535. }
  1536. cmData_t* cmRecdAlloc(cmData_t* parent)
  1537. { return _cmDataAllocNode(parent,kRecordDtId); }
  1538. cmData_t* cmRecdAppendPair( cmData_t* p, cmData_t* pair )
  1539. {
  1540. assert( p!=NULL && p->tid==kRecordDtId);
  1541. cmDataAppendChild(p,pair);
  1542. return p;
  1543. }
  1544. cmDtRC_t _cmDataRecdParseInputV(cmData_t* parent, unsigned idFl, va_list vl )
  1545. {
  1546. assert( parent != NULL && parent->tid == kRecordDtId );
  1547. bool contFl = true;
  1548. cmDtRC_t rc = kOkDtRC;
  1549. // for each record field
  1550. while( contFl )
  1551. {
  1552. cmData_t* vp = NULL;
  1553. unsigned id = cmInvalidId;
  1554. const cmChar_t* label = NULL;
  1555. // parse the field idenfier
  1556. if( idFl )
  1557. id = va_arg(vl,unsigned); // numeric field identifier
  1558. else
  1559. label = va_arg(vl,const char*); // text field label identifier
  1560. // validate the field identifier
  1561. if( (idFl && id==kInvalidDtId) || (!idFl && label==NULL) )
  1562. break;
  1563. // parse the field data
  1564. if((rc =_cmDataParseArgV( NULL, vl, &vp )) != kOkDtRC )
  1565. {
  1566. contFl = false;
  1567. }
  1568. else
  1569. {
  1570. // create the field pair
  1571. if( idFl )
  1572. cmDataAllocPairId(parent,id,vp);
  1573. else
  1574. cmDataAllocPairLabel(parent,label,vp);
  1575. }
  1576. }
  1577. return rc;
  1578. }
  1579. cmData_t* cmDataRecdAllocLabelV( cmData_t* parent, va_list vl )
  1580. {
  1581. cmData_t* p = cmRecdAlloc(parent);
  1582. cmDtRC_t rc = _cmDataRecdParseInputV(p, false, vl );
  1583. if( rc != kOkDtRC )
  1584. {
  1585. cmDataFree(p);
  1586. p = NULL;
  1587. }
  1588. return p;
  1589. }
  1590. cmData_t* cmDataRecdAllocLabelA( cmData_t* parent, ... )
  1591. {
  1592. va_list vl;
  1593. va_start(vl,parent);
  1594. cmData_t* p = cmDataRecdAllocLabelV(parent,vl);
  1595. va_end(vl);
  1596. return p;
  1597. }
  1598. cmData_t* cmDataRecdAllocIdV( cmData_t* parent, va_list vl )
  1599. {
  1600. cmData_t* p = cmRecdAlloc(parent);
  1601. cmDtRC_t rc = _cmDataRecdParseInputV(p, true, vl );
  1602. if( rc != kOkDtRC )
  1603. {
  1604. cmDataFree(p);
  1605. p = NULL;
  1606. }
  1607. return p;
  1608. }
  1609. cmData_t* cmDataRecdAllocIdA( cmData_t* parent, ... )
  1610. {
  1611. va_list vl;
  1612. va_start(vl,parent);
  1613. cmData_t* p = cmDataRecdAllocIdV(parent,vl);
  1614. va_end(vl);
  1615. return p;
  1616. }
  1617. cmDtRC_t _cmDataRecdParseV(cmData_t* p, bool idFl, cmErr_t* err, va_list vl )
  1618. {
  1619. bool contFl = true;
  1620. cmDtRC_t rc = kOkDtRC;
  1621. while( contFl )
  1622. {
  1623. unsigned id;
  1624. const char* label;
  1625. // parse the field idenfier
  1626. if( idFl )
  1627. id = va_arg(vl,unsigned); // numeric field identifier
  1628. else
  1629. label = va_arg(vl,const char*); // text field label identifier
  1630. // validate the field identifier
  1631. if( (idFl && id==kInvalidDtId) || (!idFl && label==NULL) )
  1632. break;
  1633. cmDataFmtId_t typeId = va_arg(vl,unsigned);
  1634. void* v = va_arg(vl,void*);
  1635. cmData_t* np = NULL;
  1636. if( idFl )
  1637. np = cmDataRecdValueFromLabel( p, label );
  1638. else
  1639. np = cmDataRecdValueFromId( p, id );
  1640. switch(typeId)
  1641. {
  1642. case kNullDtId:
  1643. break;
  1644. case kUCharDtId:
  1645. rc = cmDataGetUChar(np,(unsigned char*)v);
  1646. break;
  1647. case kCharDtId:
  1648. rc = cmDataGetChar(np,(char*)v);
  1649. break;
  1650. case kUShortDtId:
  1651. rc = cmDataGetUShort(np,(unsigned short*)v);
  1652. break;
  1653. case kShortDtId:
  1654. rc = cmDataGetShort(np,(short*)v);
  1655. break;
  1656. case kUIntDtId:
  1657. rc = cmDataGetUInt(np,(unsigned int*)v);
  1658. break;
  1659. case kIntDtId:
  1660. rc = cmDataGetInt(np,(int*)v);
  1661. break;
  1662. case kULongDtId:
  1663. rc = cmDataGetULong(np,(unsigned long*)v);
  1664. break;
  1665. case kLongDtId:
  1666. rc = cmDataGetLong(np,(long*)v);
  1667. break;
  1668. case kFloatDtId:
  1669. rc = cmDataGetFloat(np,(float*)v);
  1670. break;
  1671. case kDoubleDtId:
  1672. rc = cmDataGetDouble(np,(double*)v);
  1673. break;
  1674. case kStrDtId:
  1675. rc = cmDataGetStr(np,(char**)v);
  1676. break;
  1677. case kConstStrDtId:
  1678. rc = cmDataGetConstStr(np,(const char**)v);
  1679. break;
  1680. case kUCharPtrDtId:
  1681. rc = cmDataGetUCharPtr(np,(unsigned char**)v);
  1682. break;
  1683. case kCharPtrDtId:
  1684. rc = cmDataGetCharPtr(np,(char**)v);
  1685. break;
  1686. case kUShortPtrDtId:
  1687. rc = cmDataGetUShortPtr(np,(unsigned short**)v);
  1688. break;
  1689. case kShortPtrDtId:
  1690. rc = cmDataGetShortPtr(np,(short**)v);
  1691. break;
  1692. case kUIntPtrDtId:
  1693. rc = cmDataGetUIntPtr(np,(unsigned int**)v);
  1694. break;
  1695. case kIntPtrDtId:
  1696. rc = cmDataGetIntPtr(np,(int**)v);
  1697. break;
  1698. case kULongPtrDtId:
  1699. rc = cmDataGetULongPtr(np,(unsigned long**)v);
  1700. break;
  1701. case kLongPtrDtId:
  1702. rc = cmDataGetLongPtr(np,(long**)v);
  1703. break;
  1704. case kFloatPtrDtId:
  1705. rc = cmDataGetFloatPtr(np,(float**)v);
  1706. break;
  1707. case kDoublePtrDtId:
  1708. rc = cmDataGetDoublePtr(np,(double**)v);
  1709. break;
  1710. case kVoidPtrDtId:
  1711. rc = cmDataGetVoidPtr(np,(void**)v);
  1712. break;
  1713. case kListDtId:
  1714. case kPairDtId:
  1715. case kRecordDtId:
  1716. if( np->tid != typeId )
  1717. _cmDataSetError(kCvtErrDtRC);
  1718. else
  1719. *(cmData_t**)v = np;
  1720. break;
  1721. default:
  1722. _cmDataSetError(kVarArgErrDtRC);
  1723. assert(0);
  1724. }
  1725. }
  1726. return rc;
  1727. }
  1728. cmDtRC_t cmDataRecdParseLabelV(cmData_t* p, cmErr_t* err, va_list vl )
  1729. { return _cmDataRecdParseV(p,false,err,vl); }
  1730. cmDtRC_t cmDataRecdParseLabel(cmData_t* p, cmErr_t* err, ... )
  1731. {
  1732. va_list vl;
  1733. va_start(vl,err);
  1734. cmDtRC_t rc = cmDataRecdParseLabelV(p,err,vl);
  1735. va_end(vl);
  1736. return rc;
  1737. }
  1738. cmDtRC_t cmDataRecdParseIdV(cmData_t* p, cmErr_t* err, va_list vl )
  1739. { return _cmDataRecdParseV(p,true,err,vl); }
  1740. cmDtRC_t cmDataRecdParseId(cmData_t* p, cmErr_t* err, ... )
  1741. {
  1742. va_list vl;
  1743. va_start(vl,err);
  1744. cmDtRC_t rc = cmDataRecdParseIdV(p,err,vl);
  1745. va_end(vl);
  1746. return rc;
  1747. }
  1748. //----------------------------------------------------------------------------
  1749. unsigned cmDataSerializeByteCount( const cmData_t* p )
  1750. {
  1751. unsigned bn = 0;
  1752. // if this data type has a child then calculate it's size
  1753. if( kMinStructDtId <= p->tid && p->tid <= kMaxStructDtId && p->u.child != NULL )
  1754. bn = cmDataSerializeByteCount(p->u.child);
  1755. // if this data type has siblings get their type
  1756. cmData_t* dp = p->u.child;
  1757. for(; dp != NULL; dp=dp->sibling )
  1758. bn += cmDataSerializeByteCount(dp->sibling);
  1759. //
  1760. return _cmDataByteCount(p) + bn;
  1761. }
  1762. cmDtRC_t cmDataSerialize( const cmData_t* p, void* buf, unsigned bufByteCnt )
  1763. {
  1764. return kOkDtRC;
  1765. }
  1766. cmDtRC_t cmDataDeserialize( const void* buf, unsigned bufByteCnt, cmData_t** pp )
  1767. {
  1768. return kOkDtRC;
  1769. }
  1770. #define parr(rpt,fmt,arr,n) do{int i=0; cmRptPrintf(rpt,"[ "); for(;i<n;++i) cmRptPrintf(rpt,fmt,arr[i]); cmRptPrintf(rpt," ]"); }while(0)
  1771. void _cmDataPrintIndent( cmRpt_t* rpt, unsigned indent )
  1772. {
  1773. unsigned j=0;
  1774. for(; j<indent; ++j)
  1775. cmRptPrintf(rpt," ");
  1776. }
  1777. void _cmDataPrint( const cmData_t* p, cmRpt_t* rpt, unsigned indent )
  1778. {
  1779. cmData_t* cp;
  1780. //_cmDataPrintIndent(rpt,indent);
  1781. switch(p->tid)
  1782. {
  1783. case kNullDtId: cmRptPrintf(rpt,"<null>"); break;
  1784. case kUCharDtId: cmRptPrintf(rpt,"%c ",cmDataUChar(p)); break;
  1785. case kCharDtId: cmRptPrintf(rpt,"%c ",cmDataChar(p)); break;
  1786. case kUShortDtId: cmRptPrintf(rpt,"%i ",cmDataUShort(p)); break;
  1787. case kShortDtId: cmRptPrintf(rpt,"%i ",cmDataShort(p)); break;
  1788. case kUIntDtId: cmRptPrintf(rpt,"%i ",cmDataUInt(p)); break;
  1789. case kIntDtId: cmRptPrintf(rpt,"%i ",cmDataInt(p)); break;
  1790. case kULongDtId: cmRptPrintf(rpt,"%i ",cmDataULong(p)); break;
  1791. case kLongDtId: cmRptPrintf(rpt,"%i ",cmDataLong(p)); break;
  1792. case kFloatDtId: cmRptPrintf(rpt,"%f ",cmDataFloat(p)); break;
  1793. case kDoubleDtId: cmRptPrintf(rpt,"%f ",cmDataDouble(p)); break;
  1794. case kStrDtId: cmRptPrintf(rpt,"%s ",cmDataStr(p)); break;
  1795. case kConstStrDtId: cmRptPrintf(rpt,"%s ",cmDataConstStr(p)); break;
  1796. case kUCharPtrDtId: parr(rpt,"%c ",cmDataUCharPtr(p), p->cnt); break;
  1797. case kCharPtrDtId: parr(rpt,"%c ",cmDataCharPtr(p), p->cnt); break;
  1798. case kUShortPtrDtId: parr(rpt,"%i ",cmDataUShortPtr(p),p->cnt); break;
  1799. case kShortPtrDtId: parr(rpt,"%i ",cmDataShortPtr(p), p->cnt); break;
  1800. case kUIntPtrDtId: parr(rpt,"%i ",cmDataUIntPtr(p), p->cnt); break;
  1801. case kIntPtrDtId: parr(rpt,"%i ",cmDataIntPtr(p), p->cnt); break;
  1802. case kULongPtrDtId: parr(rpt,"%i ",cmDataULongPtr(p), p->cnt); break;
  1803. case kLongPtrDtId: parr(rpt,"%i ",cmDataLongPtr(p), p->cnt); break;
  1804. case kFloatPtrDtId: parr(rpt,"%f ",cmDataFloatPtr(p), p->cnt); break;
  1805. case kDoublePtrDtId: parr(rpt,"%f ",cmDataDoublePtr(p),p->cnt); break;
  1806. case kVoidPtrDtId: cmRptPrintf(rpt,"<void:%i>",p->cnt); break;
  1807. case kPairDtId:
  1808. _cmDataPrint(p->u.child,rpt,indent);
  1809. cmRptPrintf(rpt," : ");
  1810. _cmDataPrint(p->u.child->sibling,rpt,indent);
  1811. cmRptPrintf(rpt,"\n");
  1812. break;
  1813. case kListDtId:
  1814. cmRptPrintf(rpt,"(\n");
  1815. indent += 2;
  1816. cp = p->u.child;
  1817. for(; cp!=NULL; cp=cp->sibling)
  1818. {
  1819. _cmDataPrintIndent(rpt,indent);
  1820. _cmDataPrint(cp,rpt,indent);
  1821. cmRptPrintf(rpt,"\n");
  1822. }
  1823. indent -= 2;
  1824. _cmDataPrintIndent(rpt,indent);
  1825. cmRptPrintf(rpt,")\n");
  1826. break;
  1827. case kRecordDtId:
  1828. cmRptPrintf(rpt,"{\n");
  1829. indent += 2;
  1830. cp = p->u.child;
  1831. for(; cp!=NULL; cp=cp->sibling)
  1832. {
  1833. _cmDataPrintIndent(rpt,indent);
  1834. _cmDataPrint(cp,rpt, indent);
  1835. }
  1836. indent -= 2;
  1837. _cmDataPrintIndent(rpt,indent);
  1838. cmRptPrintf(rpt,"}\n");
  1839. break;
  1840. default:
  1841. break;
  1842. }
  1843. }
  1844. void cmDataPrint( const cmData_t* p, cmRpt_t* rpt )
  1845. { _cmDataPrint(p,rpt,0); }
  1846. void cmDataTest( cmCtx_t* ctx )
  1847. {
  1848. float farr[] = { 1.23, 45.6, 7.89 };
  1849. cmData_t* d0 = cmDataRecdAllocLabelA(NULL,
  1850. "name",kConstStrDtId,"This is a string.",
  1851. "id", kUIntDtId, 21,
  1852. "real",kFloatDtId, 1.23,
  1853. "arr", kFloatPtrDtId, farr, 3,
  1854. NULL);
  1855. cmDataPrint(d0,&ctx->rpt);
  1856. cmDataFree(d0);
  1857. cmData_t* d1 = cmDataListAllocA(NULL,
  1858. kUIntDtId, 53,
  1859. kStrDtId, "Blah blah",
  1860. kFloatPtrDtId, farr, 3,
  1861. kInvalidDtId );
  1862. cmDataPrint(d1,&ctx->rpt);
  1863. cmDataFree(d1);
  1864. cmRptPrintf(&ctx->rpt,"Done!.\n");
  1865. }