|
@@ -16,9 +16,10 @@ typedef struct
|
16
|
16
|
unsigned cnt;
|
17
|
17
|
} cmDataSerialHdr_t;
|
18
|
18
|
|
19
|
|
-void _cmDataSetError( unsigned err )
|
|
19
|
+cmDtRC_t _cmDataSetError( unsigned err )
|
20
|
20
|
{
|
21
|
21
|
_cmDataErrNo = err;
|
|
22
|
+ return err;
|
22
|
23
|
}
|
23
|
24
|
|
24
|
25
|
void _cmDataFreeArray( cmData_t* p )
|
|
@@ -133,306 +134,338 @@ unsigned long* cmDataULongPtr( const cmData_t* p ) { assert(p->tid==kULongPtrD
|
133
|
134
|
float* cmDataFloatPtr( const cmData_t* p ) { assert(p->tid==kFloatPtrDtId); return p->u.fp; }
|
134
|
135
|
double* cmDataDoublePtr( const cmData_t* p ) { assert(p->tid==kDoublePtrDtId); return p->u.dp; }
|
135
|
136
|
|
136
|
|
-unsigned char cmDataGetUChar( const cmData_t* p )
|
|
137
|
+cmDtRC_t cmDataGetUChar( const cmData_t* p, unsigned char* vp )
|
137
|
138
|
{
|
138
|
|
- unsigned char v = kInvalidDtUChar;
|
139
|
|
-
|
140
|
139
|
switch( p->tid )
|
141
|
140
|
{
|
142
|
|
- case kUCharDtId: v = p->u.uc; break;
|
143
|
|
- case kCharDtId: v = (unsigned char)p->u.c; break;
|
144
|
|
- case kUShortDtId: v = (unsigned char)p->u.us; break;
|
145
|
|
- case kShortDtId: v = (unsigned char)p->u.s; break;
|
146
|
|
- case kUIntDtId: v = (unsigned char)p->u.ui; break;
|
147
|
|
- case kIntDtId: v = (unsigned char)p->u.i; break;
|
148
|
|
- case kULongDtId: v = (unsigned char)p->u.ul; break;
|
149
|
|
- case kLongDtId: v = (unsigned char)p->u.l; break;
|
150
|
|
- case kFloatDtId: v = (unsigned char)p->u.f; break;
|
151
|
|
- case kDoubleDtId: v = (unsigned char)p->u.d; break;
|
|
141
|
+ case kUCharDtId: *vp = p->u.uc; break;
|
|
142
|
+ case kCharDtId: *vp = (unsigned char)p->u.c; break;
|
|
143
|
+ case kUShortDtId: *vp = (unsigned char)p->u.us; break;
|
|
144
|
+ case kShortDtId: *vp = (unsigned char)p->u.s; break;
|
|
145
|
+ case kUIntDtId: *vp = (unsigned char)p->u.ui; break;
|
|
146
|
+ case kIntDtId: *vp = (unsigned char)p->u.i; break;
|
|
147
|
+ case kULongDtId: *vp = (unsigned char)p->u.ul; break;
|
|
148
|
+ case kLongDtId: *vp = (unsigned char)p->u.l; break;
|
|
149
|
+ case kFloatDtId: *vp = (unsigned char)p->u.f; break;
|
|
150
|
+ case kDoubleDtId: *vp = (unsigned char)p->u.d; break;
|
152
|
151
|
default:
|
153
|
|
- _cmDataSetError(kCvtErrDtRC);
|
|
152
|
+ return _cmDataSetError(kCvtErrDtRC);
|
154
|
153
|
}
|
155
|
|
- return v;
|
|
154
|
+ return kOkDtRC;
|
156
|
155
|
}
|
157
|
156
|
|
158
|
|
-char cmDataGetChar( const cmData_t* p )
|
|
157
|
+cmDtRC_t cmDataGetChar( const cmData_t* p, char* vp )
|
159
|
158
|
{
|
160
|
|
- char v = kInvalidDtChar;
|
161
|
|
-
|
162
|
159
|
switch( p->tid )
|
163
|
160
|
{
|
164
|
|
- case kUCharDtId: v = (char)p->u.uc; break;
|
165
|
|
- case kCharDtId: v = p->u.c; break;
|
166
|
|
- case kUShortDtId: v = (char)p->u.us; break;
|
167
|
|
- case kShortDtId: v = (char)p->u.s; break;
|
168
|
|
- case kUIntDtId: v = (char)p->u.ui; break;
|
169
|
|
- case kIntDtId: v = (char)p->u.i; break;
|
170
|
|
- case kULongDtId: v = (char)p->u.ul; break;
|
171
|
|
- case kLongDtId: v = (char)p->u.l; break;
|
172
|
|
- case kFloatDtId: v = (char)p->u.f; break;
|
173
|
|
- case kDoubleDtId: v = (char)p->u.d; break;
|
|
161
|
+ case kUCharDtId: *vp = (char)p->u.uc; break;
|
|
162
|
+ case kCharDtId: *vp = p->u.c; break;
|
|
163
|
+ case kUShortDtId: *vp = (char)p->u.us; break;
|
|
164
|
+ case kShortDtId: *vp = (char)p->u.s; break;
|
|
165
|
+ case kUIntDtId: *vp = (char)p->u.ui; break;
|
|
166
|
+ case kIntDtId: *vp = (char)p->u.i; break;
|
|
167
|
+ case kULongDtId: *vp = (char)p->u.ul; break;
|
|
168
|
+ case kLongDtId: *vp = (char)p->u.l; break;
|
|
169
|
+ case kFloatDtId: *vp = (char)p->u.f; break;
|
|
170
|
+ case kDoubleDtId: *vp = (char)p->u.d; break;
|
174
|
171
|
default:
|
175
|
|
- _cmDataSetError(kCvtErrDtRC);
|
|
172
|
+ return _cmDataSetError(kCvtErrDtRC);
|
176
|
173
|
}
|
177
|
|
- return v;
|
|
174
|
+ return kOkDtRC;
|
178
|
175
|
}
|
179
|
176
|
|
180
|
|
-short cmDataGetShort( const cmData_t* p )
|
|
177
|
+cmDtRC_t cmDataGetShort( const cmData_t* p, short* vp )
|
181
|
178
|
{
|
182
|
|
- short v = kInvalidDtShort;
|
183
|
|
-
|
184
|
179
|
switch( p->tid )
|
185
|
180
|
{
|
186
|
|
- case kUCharDtId: v = (short)p->u.uc; break;
|
187
|
|
- case kCharDtId: v = (short)p->u.c; break;
|
188
|
|
- case kUShortDtId: v = (short)p->u.us; break;
|
189
|
|
- case kShortDtId: v = p->u.s; break;
|
190
|
|
- case kUIntDtId: v = (short)p->u.ui; break;
|
191
|
|
- case kIntDtId: v = (short)p->u.i; break;
|
192
|
|
- case kULongDtId: v = (short)p->u.ul; break;
|
193
|
|
- case kLongDtId: v = (short)p->u.l; break;
|
194
|
|
- case kFloatDtId: v = (short)p->u.f; break;
|
195
|
|
- case kDoubleDtId: v = (short)p->u.d; break;
|
|
181
|
+ case kUCharDtId: *vp = (short)p->u.uc; break;
|
|
182
|
+ case kCharDtId: *vp = (short)p->u.c; break;
|
|
183
|
+ case kUShortDtId: *vp = (short)p->u.us; break;
|
|
184
|
+ case kShortDtId: *vp = p->u.s; break;
|
|
185
|
+ case kUIntDtId: *vp = (short)p->u.ui; break;
|
|
186
|
+ case kIntDtId: *vp = (short)p->u.i; break;
|
|
187
|
+ case kULongDtId: *vp = (short)p->u.ul; break;
|
|
188
|
+ case kLongDtId: *vp = (short)p->u.l; break;
|
|
189
|
+ case kFloatDtId: *vp = (short)p->u.f; break;
|
|
190
|
+ case kDoubleDtId: *vp = (short)p->u.d; break;
|
196
|
191
|
default:
|
197
|
|
- _cmDataSetError(kCvtErrDtRC);
|
|
192
|
+ return _cmDataSetError(kCvtErrDtRC);
|
198
|
193
|
}
|
199
|
|
-
|
200
|
|
- return v;
|
|
194
|
+ return kOkDtRC;
|
201
|
195
|
}
|
202
|
196
|
|
203
|
197
|
|
204
|
|
-unsigned short cmDataGetUShort( const cmData_t* p )
|
|
198
|
+cmDtRC_t cmDataGetUShort( const cmData_t* p, unsigned short* vp )
|
205
|
199
|
{
|
206
|
|
- unsigned short v = kInvalidDtUShort;
|
207
|
|
-
|
208
|
200
|
switch( p->tid )
|
209
|
201
|
{
|
210
|
|
- case kUCharDtId: v = (unsigned short)p->u.uc; break;
|
211
|
|
- case kCharDtId: v = (unsigned short)p->u.c; break;
|
212
|
|
- case kUShortDtId: v = p->u.us; break;
|
213
|
|
- case kShortDtId: v = (unsigned short)p->u.s; break;
|
214
|
|
- case kUIntDtId: v = (unsigned short)p->u.ui; break;
|
215
|
|
- case kIntDtId: v = (unsigned short)p->u.i; break;
|
216
|
|
- case kULongDtId: v = (unsigned short)p->u.ul; break;
|
217
|
|
- case kLongDtId: v = (unsigned short)p->u.l; break;
|
218
|
|
- case kFloatDtId: v = (unsigned short)p->u.f; break;
|
219
|
|
- case kDoubleDtId: v = (unsigned short)p->u.d; break;
|
|
202
|
+ case kUCharDtId: *vp = (unsigned short)p->u.uc; break;
|
|
203
|
+ case kCharDtId: *vp = (unsigned short)p->u.c; break;
|
|
204
|
+ case kUShortDtId: *vp = p->u.us; break;
|
|
205
|
+ case kShortDtId: *vp = (unsigned short)p->u.s; break;
|
|
206
|
+ case kUIntDtId: *vp = (unsigned short)p->u.ui; break;
|
|
207
|
+ case kIntDtId: *vp = (unsigned short)p->u.i; break;
|
|
208
|
+ case kULongDtId: *vp = (unsigned short)p->u.ul; break;
|
|
209
|
+ case kLongDtId: *vp = (unsigned short)p->u.l; break;
|
|
210
|
+ case kFloatDtId: *vp = (unsigned short)p->u.f; break;
|
|
211
|
+ case kDoubleDtId: *vp = (unsigned short)p->u.d; break;
|
220
|
212
|
default:
|
221
|
|
- _cmDataSetError(kCvtErrDtRC);
|
|
213
|
+ return _cmDataSetError(kCvtErrDtRC);
|
222
|
214
|
}
|
223
|
|
-
|
224
|
|
- return v;
|
|
215
|
+ return kOkDtRC;
|
225
|
216
|
}
|
226
|
217
|
|
227
|
|
-int cmDataGetInt( const cmData_t* p )
|
|
218
|
+cmDtRC_t cmDataGetInt( const cmData_t* p, int* vp )
|
228
|
219
|
{
|
229
|
|
- int v = kInvalidDtInt;
|
230
|
220
|
|
231
|
221
|
switch( p->tid )
|
232
|
222
|
{
|
233
|
|
- case kUCharDtId: v = (int)p->u.uc; break;
|
234
|
|
- case kCharDtId: v = (int)p->u.c; break;
|
235
|
|
- case kUShortDtId: v = (int)p->u.us; break;
|
236
|
|
- case kShortDtId: v = (int)p->u.s; break;
|
237
|
|
- case kUIntDtId: v = (int)p->u.ui; break;
|
238
|
|
- case kIntDtId: v = p->u.i; break;
|
239
|
|
- case kULongDtId: v = (int)p->u.ul; break;
|
240
|
|
- case kLongDtId: v = (int)p->u.l; break;
|
241
|
|
- case kFloatDtId: v = (int)p->u.f; break;
|
242
|
|
- case kDoubleDtId: v = (int)p->u.d; break;
|
|
223
|
+ case kUCharDtId: *vp = (int)p->u.uc; break;
|
|
224
|
+ case kCharDtId: *vp = (int)p->u.c; break;
|
|
225
|
+ case kUShortDtId: *vp = (int)p->u.us; break;
|
|
226
|
+ case kShortDtId: *vp = (int)p->u.s; break;
|
|
227
|
+ case kUIntDtId: *vp = (int)p->u.ui; break;
|
|
228
|
+ case kIntDtId: *vp = p->u.i; break;
|
|
229
|
+ case kULongDtId: *vp = (int)p->u.ul; break;
|
|
230
|
+ case kLongDtId: *vp = (int)p->u.l; break;
|
|
231
|
+ case kFloatDtId: *vp = (int)p->u.f; break;
|
|
232
|
+ case kDoubleDtId: *vp = (int)p->u.d; break;
|
243
|
233
|
default:
|
244
|
|
- _cmDataSetError(kCvtErrDtRC);
|
|
234
|
+ return _cmDataSetError(kCvtErrDtRC);
|
245
|
235
|
}
|
246
|
|
-
|
247
|
|
- return v;
|
|
236
|
+ return kOkDtRC;
|
248
|
237
|
}
|
249
|
238
|
|
250
|
|
-unsigned int cmDataGetUInt( const cmData_t* p )
|
|
239
|
+cmDtRC_t cmDataGetUInt( const cmData_t* p, unsigned int* vp )
|
251
|
240
|
{
|
252
|
|
- unsigned int v = kInvalidDtUInt;
|
253
|
|
-
|
254
|
241
|
switch( p->tid )
|
255
|
242
|
{
|
256
|
|
- case kUCharDtId: v = (unsigned int)p->u.uc; break;
|
257
|
|
- case kCharDtId: v = (unsigned int)p->u.c; break;
|
258
|
|
- case kUShortDtId: v = (unsigned int)p->u.us; break;
|
259
|
|
- case kShortDtId: v = (unsigned int)p->u.s; break;
|
260
|
|
- case kUIntDtId: v = p->u.ui; break;
|
261
|
|
- case kIntDtId: v = (unsigned int)p->u.i; break;
|
262
|
|
- case kULongDtId: v = (unsigned int)p->u.ul; break;
|
263
|
|
- case kLongDtId: v = (unsigned int)p->u.l; break;
|
264
|
|
- case kFloatDtId: v = (unsigned int)p->u.f; break;
|
265
|
|
- case kDoubleDtId: v = (unsigned int)p->u.d; break;
|
|
243
|
+ case kUCharDtId: *vp = (unsigned int)p->u.uc; break;
|
|
244
|
+ case kCharDtId: *vp = (unsigned int)p->u.c; break;
|
|
245
|
+ case kUShortDtId: *vp = (unsigned int)p->u.us; break;
|
|
246
|
+ case kShortDtId: *vp = (unsigned int)p->u.s; break;
|
|
247
|
+ case kUIntDtId: *vp = p->u.ui; break;
|
|
248
|
+ case kIntDtId: *vp = (unsigned int)p->u.i; break;
|
|
249
|
+ case kULongDtId: *vp = (unsigned int)p->u.ul; break;
|
|
250
|
+ case kLongDtId: *vp = (unsigned int)p->u.l; break;
|
|
251
|
+ case kFloatDtId: *vp = (unsigned int)p->u.f; break;
|
|
252
|
+ case kDoubleDtId: *vp = (unsigned int)p->u.d; break;
|
266
|
253
|
default:
|
267
|
|
- _cmDataSetError(kCvtErrDtRC);
|
|
254
|
+ return _cmDataSetError(kCvtErrDtRC);
|
268
|
255
|
}
|
269
|
|
-
|
270
|
|
- return v;
|
|
256
|
+ return kOkDtRC;
|
271
|
257
|
}
|
272
|
258
|
|
273
|
|
-long cmDataGetLong( const cmData_t* p )
|
|
259
|
+cmDtRC_t cmDataGetLong( const cmData_t* p, long* vp )
|
274
|
260
|
{
|
275
|
|
- long v = kInvalidDtLong;
|
276
|
|
-
|
277
|
261
|
switch( p->tid )
|
278
|
262
|
{
|
279
|
|
- case kUCharDtId: v = (long)p->u.uc; break;
|
280
|
|
- case kCharDtId: v = (long)p->u.c; break;
|
281
|
|
- case kUShortDtId: v = (long)p->u.us; break;
|
282
|
|
- case kShortDtId: v = (long)p->u.s; break;
|
283
|
|
- case kUIntDtId: v = (long)p->u.ui; break;
|
284
|
|
- case kIntDtId: v = (long)p->u.i; break;
|
285
|
|
- case kULongDtId: v = (long)p->u.ul; break;
|
286
|
|
- case kLongDtId: v = p->u.l; break;
|
287
|
|
- case kFloatDtId: v = (long)p->u.f; break;
|
288
|
|
- case kDoubleDtId: v = (long)p->u.d; break;
|
|
263
|
+ case kUCharDtId: *vp = (long)p->u.uc; break;
|
|
264
|
+ case kCharDtId: *vp = (long)p->u.c; break;
|
|
265
|
+ case kUShortDtId: *vp = (long)p->u.us; break;
|
|
266
|
+ case kShortDtId: *vp = (long)p->u.s; break;
|
|
267
|
+ case kUIntDtId: *vp = (long)p->u.ui; break;
|
|
268
|
+ case kIntDtId: *vp = (long)p->u.i; break;
|
|
269
|
+ case kULongDtId: *vp = (long)p->u.ul; break;
|
|
270
|
+ case kLongDtId: *vp = p->u.l; break;
|
|
271
|
+ case kFloatDtId: *vp = (long)p->u.f; break;
|
|
272
|
+ case kDoubleDtId: *vp = (long)p->u.d; break;
|
289
|
273
|
default:
|
290
|
|
- _cmDataSetError(kCvtErrDtRC);
|
|
274
|
+ return _cmDataSetError(kCvtErrDtRC);
|
291
|
275
|
}
|
292
|
|
-
|
293
|
|
- return v;
|
|
276
|
+ return kOkDtRC;
|
294
|
277
|
}
|
295
|
278
|
|
296
|
|
-unsigned long cmDataGetULong( const cmData_t* p )
|
|
279
|
+cmDtRC_t cmDataGetULong( const cmData_t* p, unsigned long* vp )
|
297
|
280
|
{
|
298
|
|
- unsigned long v = kInvalidDtULong;
|
299
|
|
-
|
300
|
281
|
switch( p->tid )
|
301
|
282
|
{
|
302
|
|
- case kUCharDtId: v = (unsigned long)p->u.uc; break;
|
303
|
|
- case kCharDtId: v = (unsigned long)p->u.c; break;
|
304
|
|
- case kUShortDtId: v = (unsigned long)p->u.us; break;
|
305
|
|
- case kShortDtId: v = (unsigned long)p->u.s; break;
|
306
|
|
- case kUIntDtId: v = (unsigned long)p->u.ui; break;
|
307
|
|
- case kIntDtId: v = (unsigned long)p->u.i; break;
|
308
|
|
- case kULongDtId: v = p->u.ul; break;
|
309
|
|
- case kLongDtId: v = (unsigned long)p->u.l; break;
|
310
|
|
- case kFloatDtId: v = (unsigned long)p->u.f; break;
|
311
|
|
- case kDoubleDtId: v = (unsigned long)p->u.d; break;
|
|
283
|
+ case kUCharDtId: *vp = (unsigned long)p->u.uc; break;
|
|
284
|
+ case kCharDtId: *vp = (unsigned long)p->u.c; break;
|
|
285
|
+ case kUShortDtId: *vp = (unsigned long)p->u.us; break;
|
|
286
|
+ case kShortDtId: *vp = (unsigned long)p->u.s; break;
|
|
287
|
+ case kUIntDtId: *vp = (unsigned long)p->u.ui; break;
|
|
288
|
+ case kIntDtId: *vp = (unsigned long)p->u.i; break;
|
|
289
|
+ case kULongDtId: *vp = p->u.ul; break;
|
|
290
|
+ case kLongDtId: *vp = (unsigned long)p->u.l; break;
|
|
291
|
+ case kFloatDtId: *vp = (unsigned long)p->u.f; break;
|
|
292
|
+ case kDoubleDtId: *vp = (unsigned long)p->u.d; break;
|
312
|
293
|
default:
|
313
|
|
- _cmDataSetError(kCvtErrDtRC);
|
|
294
|
+ return _cmDataSetError(kCvtErrDtRC);
|
314
|
295
|
}
|
315
|
|
-
|
316
|
|
- return v;
|
|
296
|
+ return kOkDtRC;
|
317
|
297
|
}
|
318
|
298
|
|
319
|
|
-float cmDataGetFloat( const cmData_t* p )
|
|
299
|
+cmDtRC_t cmDataGetFloat( const cmData_t* p, float* vp )
|
320
|
300
|
{
|
321
|
|
- float v = FLT_MAX;
|
322
|
301
|
|
323
|
302
|
switch( p->tid )
|
324
|
303
|
{
|
325
|
|
- case kUCharDtId: v = (float)p->u.uc; break;
|
326
|
|
- case kCharDtId: v = (float)p->u.c; break;
|
327
|
|
- case kUShortDtId: v = (float)p->u.us; break;
|
328
|
|
- case kShortDtId: v = (float)p->u.s; break;
|
329
|
|
- case kUIntDtId: v = (float)p->u.ui; break;
|
330
|
|
- case kIntDtId: v = (float)p->u.i; break;
|
331
|
|
- case kULongDtId: v = (float)p->u.ul; break;
|
332
|
|
- case kLongDtId: v = (float)p->u.l; break;
|
333
|
|
- case kFloatDtId: v = p->u.f; break;
|
334
|
|
- case kDoubleDtId: v = (float)p->u.d; break;
|
|
304
|
+ case kUCharDtId: *vp = (float)p->u.uc; break;
|
|
305
|
+ case kCharDtId: *vp = (float)p->u.c; break;
|
|
306
|
+ case kUShortDtId: *vp = (float)p->u.us; break;
|
|
307
|
+ case kShortDtId: *vp = (float)p->u.s; break;
|
|
308
|
+ case kUIntDtId: *vp = (float)p->u.ui; break;
|
|
309
|
+ case kIntDtId: *vp = (float)p->u.i; break;
|
|
310
|
+ case kULongDtId: *vp = (float)p->u.ul; break;
|
|
311
|
+ case kLongDtId: *vp = (float)p->u.l; break;
|
|
312
|
+ case kFloatDtId: *vp = p->u.f; break;
|
|
313
|
+ case kDoubleDtId: *vp = (float)p->u.d; break;
|
335
|
314
|
default:
|
336
|
|
- _cmDataSetError(kCvtErrDtRC);
|
|
315
|
+ return _cmDataSetError(kCvtErrDtRC);
|
337
|
316
|
}
|
338
|
|
-
|
339
|
|
- return v;
|
|
317
|
+ return kOkDtRC;
|
340
|
318
|
}
|
341
|
319
|
|
342
|
|
-double cmDataGetDouble( const cmData_t* p )
|
|
320
|
+cmDtRC_t cmDataGetDouble( const cmData_t* p, double* vp )
|
343
|
321
|
{
|
344
|
|
- double v = DBL_MAX;
|
345
|
|
-
|
346
|
322
|
switch( p->tid )
|
347
|
323
|
{
|
348
|
|
- case kUCharDtId: v = (double)p->u.uc; break;
|
349
|
|
- case kCharDtId: v = (double)p->u.c; break;
|
350
|
|
- case kUShortDtId: v = (double)p->u.us; break;
|
351
|
|
- case kShortDtId: v = (double)p->u.s; break;
|
352
|
|
- case kUIntDtId: v = (double)p->u.ui; break;
|
353
|
|
- case kIntDtId: v = (double)p->u.i; break;
|
354
|
|
- case kULongDtId: v = (double)p->u.ul; break;
|
355
|
|
- case kLongDtId: v = (double)p->u.l; break;
|
356
|
|
- case kFloatDtId: v = (double)p->u.f; break;
|
357
|
|
- case kDoubleDtId: v = p->u.d; break;
|
|
324
|
+ case kUCharDtId: *vp = (double)p->u.uc; break;
|
|
325
|
+ case kCharDtId: *vp = (double)p->u.c; break;
|
|
326
|
+ case kUShortDtId: *vp = (double)p->u.us; break;
|
|
327
|
+ case kShortDtId: *vp = (double)p->u.s; break;
|
|
328
|
+ case kUIntDtId: *vp = (double)p->u.ui; break;
|
|
329
|
+ case kIntDtId: *vp = (double)p->u.i; break;
|
|
330
|
+ case kULongDtId: *vp = (double)p->u.ul; break;
|
|
331
|
+ case kLongDtId: *vp = (double)p->u.l; break;
|
|
332
|
+ case kFloatDtId: *vp = (double)p->u.f; break;
|
|
333
|
+ case kDoubleDtId: *vp = p->u.d; break;
|
358
|
334
|
default:
|
359
|
|
- _cmDataSetError(kCvtErrDtRC);
|
|
335
|
+ return _cmDataSetError(kCvtErrDtRC);
|
360
|
336
|
}
|
361
|
|
-
|
362
|
|
- return v;
|
|
337
|
+ return kOkDtRC;
|
363
|
338
|
}
|
364
|
339
|
|
365
|
|
-cmChar_t* cmDataGetStr( const cmData_t* p )
|
|
340
|
+cmDtRC_t cmDataGetStr( const cmData_t* p, cmChar_t** vp )
|
366
|
341
|
{
|
367
|
|
- assert( p->tid == kStrDtId || p->tid == kConstStrDtId);
|
368
|
|
- return (p->tid == kStrDtId || p->tid == kConstStrDtId) ? p->u.z : NULL;
|
|
342
|
+ if( p->tid == kStrDtId || p->tid == kConstStrDtId)
|
|
343
|
+ {
|
|
344
|
+ *vp = (p->tid == kStrDtId || p->tid == kConstStrDtId) ? p->u.z : NULL;
|
|
345
|
+ return kOkDtRC;
|
|
346
|
+ }
|
|
347
|
+ return _cmDataSetError(kCvtErrDtRC);
|
369
|
348
|
}
|
370
|
349
|
|
371
|
|
-const cmChar_t* cmDataGetConstStr( const cmData_t* p )
|
|
350
|
+cmDtRC_t cmDataGetConstStr( const cmData_t* p, const cmChar_t** vp )
|
372
|
351
|
{
|
373
|
|
- assert( p->tid == kStrDtId || p->tid == kConstStrDtId);
|
374
|
|
- return (p->tid == kStrDtId || p->tid == kConstStrDtId) ? p->u.cz : NULL;
|
|
352
|
+ if( p->tid == kStrDtId || p->tid == kConstStrDtId)
|
|
353
|
+ {
|
|
354
|
+ *vp = (p->tid == kStrDtId || p->tid == kConstStrDtId) ? p->u.cz : NULL;
|
|
355
|
+ return kOkDtRC;
|
|
356
|
+ }
|
|
357
|
+ return _cmDataSetError(kCvtErrDtRC);
|
375
|
358
|
}
|
376
|
359
|
|
377
|
|
-void* cmDataGetVoidPtr( const cmData_t* p )
|
|
360
|
+cmDtRC_t cmDataGetVoidPtr( const cmData_t* p, void** vp )
|
378
|
361
|
{
|
379
|
|
- assert( kMinPtrDtId <= p->tid && p->tid <= kMaxPtrDtId );
|
380
|
|
- return ( kMinPtrDtId <= p->tid && p->tid <= kMaxPtrDtId ) ? p->u.vp : NULL;
|
|
362
|
+ if( kMinPtrDtId <= p->tid && p->tid <= kMaxPtrDtId )
|
|
363
|
+ {
|
|
364
|
+ *vp = ( kMinPtrDtId <= p->tid && p->tid <= kMaxPtrDtId ) ? p->u.vp : NULL;
|
|
365
|
+ return kOkDtRC;
|
|
366
|
+ }
|
|
367
|
+ return _cmDataSetError(kCvtErrDtRC);
|
381
|
368
|
}
|
382
|
369
|
|
383
|
|
-char* cmDataGetCharPtr( const cmData_t* p )
|
|
370
|
+cmDtRC_t cmDataGetCharPtr( const cmData_t* p, char** vp )
|
384
|
371
|
{
|
385
|
|
- assert( p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId );
|
386
|
|
- return (p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId) ? p->u.cp : NULL;
|
|
372
|
+ if( p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId )
|
|
373
|
+ {
|
|
374
|
+ *vp = (p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId) ? p->u.cp : NULL;
|
|
375
|
+ return kOkDtRC;
|
|
376
|
+ }
|
|
377
|
+ return _cmDataSetError(kCvtErrDtRC);
|
387
|
378
|
}
|
388
|
379
|
|
389
|
|
-unsigned char* cmDataGetUCharPtr( const cmData_t* p )
|
|
380
|
+cmDtRC_t cmDataGetUCharPtr( const cmData_t* p, unsigned char** vp )
|
390
|
381
|
{
|
391
|
|
- assert( p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId );
|
392
|
|
- return (p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId) ? p->u.ucp : NULL;
|
|
382
|
+ if( p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId )
|
|
383
|
+ {
|
|
384
|
+ *vp = (p->tid == kCharPtrDtId || p->tid == kUCharPtrDtId) ? p->u.ucp : NULL;
|
|
385
|
+ return kOkDtRC;
|
|
386
|
+ }
|
|
387
|
+ return _cmDataSetError(kCvtErrDtRC);
|
393
|
388
|
}
|
394
|
389
|
|
395
|
|
-short* cmDataGetShortPtr( const cmData_t* p )
|
|
390
|
+cmDtRC_t cmDataGetShortPtr( const cmData_t* p, short** vp )
|
396
|
391
|
{
|
397
|
|
- assert( p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId );
|
398
|
|
- return (p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId ) ? p->u.sp : NULL;
|
|
392
|
+ if( p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId )
|
|
393
|
+ {
|
|
394
|
+ *vp = (p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId ) ? p->u.sp : NULL;
|
|
395
|
+ return kOkDtRC;
|
|
396
|
+ }
|
|
397
|
+ return _cmDataSetError(kCvtErrDtRC);
|
399
|
398
|
}
|
400
|
399
|
|
401
|
|
-unsigned short* cmDataGetUShortPtr( const cmData_t* p )
|
|
400
|
+cmDtRC_t cmDataGetUShortPtr( const cmData_t* p, unsigned short** vp )
|
402
|
401
|
{
|
403
|
|
- assert( p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId );
|
404
|
|
- return (p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId ) ? p->u.usp : NULL;
|
|
402
|
+ if( p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId )
|
|
403
|
+ {
|
|
404
|
+ *vp = (p->tid == kShortPtrDtId || p->tid == kUShortPtrDtId ) ? p->u.usp : NULL;
|
|
405
|
+ return kOkDtRC;
|
|
406
|
+ }
|
|
407
|
+ return _cmDataSetError(kCvtErrDtRC);
|
405
|
408
|
}
|
406
|
409
|
|
407
|
|
-int* cmDataGetIntPtr( const cmData_t* p )
|
|
410
|
+cmDtRC_t cmDataGetIntPtr( const cmData_t* p, int** vp )
|
408
|
411
|
{
|
409
|
|
- assert( p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId );
|
410
|
|
- return (p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId ) ? p->u.ip : NULL;
|
|
412
|
+ if( p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId )
|
|
413
|
+ {
|
|
414
|
+ *vp = (p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId ) ? p->u.ip : NULL;
|
|
415
|
+ return kOkDtRC;
|
|
416
|
+ }
|
|
417
|
+ return _cmDataSetError(kCvtErrDtRC);
|
411
|
418
|
}
|
412
|
419
|
|
413
|
|
-unsigned int* cmDataGetUIntPtr( const cmData_t* p )
|
|
420
|
+cmDtRC_t cmDataGetUIntPtr( const cmData_t* p, unsigned int** vp )
|
414
|
421
|
{
|
415
|
|
- assert( p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId );
|
416
|
|
- return (p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId ) ? p->u.uip : NULL;
|
|
422
|
+ if( p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId )
|
|
423
|
+ {
|
|
424
|
+ *vp = (p->tid == kIntPtrDtId || p->tid == kUIntPtrDtId ) ? p->u.uip : NULL;
|
|
425
|
+ return kOkDtRC;
|
|
426
|
+ }
|
|
427
|
+ return _cmDataSetError(kCvtErrDtRC);
|
417
|
428
|
}
|
418
|
429
|
|
419
|
|
-long* cmDataGetLongPtr( const cmData_t* p )
|
|
430
|
+cmDtRC_t cmDataGetLongPtr( const cmData_t* p, long** vp )
|
420
|
431
|
{
|
421
|
|
- assert( p->tid == kLongPtrDtId || p->tid == kULongPtrDtId );
|
422
|
|
- return (p->tid == kLongPtrDtId || p->tid == kULongPtrDtId ) ? p->u.lp : NULL;
|
|
432
|
+ if( p->tid == kLongPtrDtId || p->tid == kULongPtrDtId )
|
|
433
|
+ {
|
|
434
|
+ *vp = (p->tid == kLongPtrDtId || p->tid == kULongPtrDtId ) ? p->u.lp : NULL;
|
|
435
|
+ return kOkDtRC;
|
|
436
|
+ }
|
|
437
|
+ return _cmDataSetError(kCvtErrDtRC);
|
423
|
438
|
}
|
424
|
439
|
|
425
|
|
-unsigned long* cmDataGetULongPtr( const cmData_t* p )
|
|
440
|
+cmDtRC_t cmDataGetULongPtr( const cmData_t* p, unsigned long** vp )
|
426
|
441
|
{
|
427
|
|
- assert( p->tid == kLongPtrDtId || p->tid == kULongPtrDtId );
|
428
|
|
- return (p->tid == kLongPtrDtId || p->tid == kULongPtrDtId ) ? p->u.ulp : NULL;
|
|
442
|
+ if( p->tid == kLongPtrDtId || p->tid == kULongPtrDtId )
|
|
443
|
+ {
|
|
444
|
+ *vp = (p->tid == kLongPtrDtId || p->tid == kULongPtrDtId ) ? p->u.ulp : NULL;
|
|
445
|
+ return kOkDtRC;
|
|
446
|
+ }
|
|
447
|
+ return _cmDataSetError(kCvtErrDtRC);
|
429
|
448
|
}
|
430
|
449
|
|
431
|
|
-float* cmDataGetFloatPtr( const cmData_t* p )
|
432
|
|
-{ return p->tid == kFloatPtrDtId ? p->u.fp : NULL; }
|
|
450
|
+cmDtRC_t cmDataGetFloatPtr( const cmData_t* p, float** vp )
|
|
451
|
+{
|
|
452
|
+ if( p->tid == kFloatPtrDtId )
|
|
453
|
+ {
|
|
454
|
+ *vp = p->u.fp;
|
|
455
|
+ return kOkDtRC;
|
|
456
|
+ }
|
|
457
|
+ return _cmDataSetError(kCvtErrDtRC);
|
|
458
|
+}
|
433
|
459
|
|
434
|
|
-double* cmDataGetDoublePtr( const cmData_t* p )
|
435
|
|
-{ return p->tid == kDoublePtrDtId ? p->u.dp : NULL; }
|
|
460
|
+cmDtRC_t cmDataGetDoublePtr( const cmData_t* p, double** vp )
|
|
461
|
+{
|
|
462
|
+ if( p->tid == kDoublePtrDtId )
|
|
463
|
+ {
|
|
464
|
+ *vp = p->u.dp;
|
|
465
|
+ return kOkDtRC;
|
|
466
|
+ }
|
|
467
|
+ return _cmDataSetError(kCvtErrDtRC);
|
|
468
|
+}
|
436
|
469
|
|
437
|
470
|
// Set the value of an existing data object.
|
438
|
471
|
cmData_t* cmDataSetNull( cmData_t* p )
|
|
@@ -1331,13 +1364,17 @@ cmData_t* cmDataPairKey( cmData_t* p )
|
1331
|
1364
|
unsigned cmDataPairKeyId( cmData_t* p )
|
1332
|
1365
|
{
|
1333
|
1366
|
assert( _cmDataPairIsValid(p) );
|
1334
|
|
- return cmDataGetUInt(p->u.child);
|
|
1367
|
+ unsigned id = cmInvalidId;
|
|
1368
|
+ cmDataGetUInt(p->u.child,&id);
|
|
1369
|
+ return id;
|
1335
|
1370
|
}
|
1336
|
1371
|
|
1337
|
1372
|
const cmChar_t* cmDataPairKeyLabel( cmData_t* p )
|
1338
|
1373
|
{
|
1339
|
1374
|
assert( _cmDataPairIsValid(p) );
|
1340
|
|
- return cmDataGetConstStr(p->u.child);
|
|
1375
|
+ const cmChar_t* label = NULL;
|
|
1376
|
+ cmDataGetConstStr(p->u.child,&label);
|
|
1377
|
+ return label;
|
1341
|
1378
|
}
|
1342
|
1379
|
|
1343
|
1380
|
|
|
@@ -1700,13 +1737,17 @@ cmData_t* cmDataRecdKey( cmData_t* p, unsigned index )
|
1700
|
1737
|
unsigned cmDataRecdKeyId( cmData_t* p, unsigned index )
|
1701
|
1738
|
{
|
1702
|
1739
|
cmData_t* kp = cmDataRecdKey(p,index);
|
1703
|
|
- return cmDataGetUInt(kp);
|
|
1740
|
+ unsigned id = cmInvalidId;
|
|
1741
|
+ cmDataGetUInt(kp,&id);
|
|
1742
|
+ return id;
|
1704
|
1743
|
}
|
1705
|
1744
|
|
1706
|
1745
|
const cmChar_t* cmDataRecdKeyLabel( cmData_t* p, unsigned index )
|
1707
|
1746
|
{
|
1708
|
1747
|
cmData_t* kp = cmDataRecdKey(p,index);
|
1709
|
|
- return cmDataGetConstStr(kp);
|
|
1748
|
+ const cmChar_t* label = NULL;
|
|
1749
|
+ cmDataGetConstStr(kp,&label);
|
|
1750
|
+ return label;
|
1710
|
1751
|
}
|
1711
|
1752
|
|
1712
|
1753
|
cmData_t* cmRecdMake( cmData_t* parent, cmData_t* p )
|
|
@@ -1750,7 +1791,7 @@ cmDtRC_t _cmDataRecdParseInputV(cmData_t* parent, unsigned idFl, va_list vl )
|
1750
|
1791
|
label = va_arg(vl,const char*); // text field label identifier
|
1751
|
1792
|
|
1752
|
1793
|
// validate the field identifier
|
1753
|
|
- if( id==kInvalidDtId && label==NULL )
|
|
1794
|
+ if( (idFl && id==kInvalidDtId) || (!idFl && label==NULL) )
|
1754
|
1795
|
break;
|
1755
|
1796
|
|
1756
|
1797
|
// parse the field data
|
|
@@ -1829,7 +1870,7 @@ cmDtRC_t _cmDataRecdParseV(cmData_t* p, bool idFl, cmErr_t* err, va_list vl )
|
1829
|
1870
|
label = va_arg(vl,const char*); // text field label identifier
|
1830
|
1871
|
|
1831
|
1872
|
// validate the field identifier
|
1832
|
|
- if( id==kInvalidDtId && label==NULL )
|
|
1873
|
+ if( (idFl && id==kInvalidDtId) || (!idFl && label==NULL) )
|
1833
|
1874
|
break;
|
1834
|
1875
|
|
1835
|
1876
|
cmDataFmtId_t typeId = va_arg(vl,unsigned);
|
|
@@ -1847,95 +1888,95 @@ cmDtRC_t _cmDataRecdParseV(cmData_t* p, bool idFl, cmErr_t* err, va_list vl )
|
1847
|
1888
|
break;
|
1848
|
1889
|
|
1849
|
1890
|
case kUCharDtId:
|
1850
|
|
- *((unsigned char*)v) = cmDataGetUChar(np);
|
|
1891
|
+ rc = cmDataGetUChar(np,(unsigned char*)v);
|
1851
|
1892
|
break;
|
1852
|
1893
|
|
1853
|
1894
|
case kCharDtId:
|
1854
|
|
- *((char*)v) = cmDataGetChar(np);
|
|
1895
|
+ rc = cmDataGetChar(np,(char*)v);
|
1855
|
1896
|
break;
|
1856
|
1897
|
|
1857
|
1898
|
case kUShortDtId:
|
1858
|
|
- *((unsigned short*)v) = cmDataGetUShort(np);
|
|
1899
|
+ rc = cmDataGetUShort(np,(unsigned short*)v);
|
1859
|
1900
|
break;
|
1860
|
1901
|
|
1861
|
1902
|
case kShortDtId:
|
1862
|
|
- *((short*)v) = cmDataGetShort(np);
|
|
1903
|
+ rc = cmDataGetShort(np,(short*)v);
|
1863
|
1904
|
break;
|
1864
|
1905
|
|
1865
|
1906
|
case kUIntDtId:
|
1866
|
|
- *((unsigned int*)v) = cmDataGetUInt(np);
|
|
1907
|
+ rc = cmDataGetUInt(np,(unsigned int*)v);
|
1867
|
1908
|
break;
|
1868
|
1909
|
|
1869
|
1910
|
case kIntDtId:
|
1870
|
|
- *((int*)v) = cmDataGetInt(np);
|
|
1911
|
+ rc = cmDataGetInt(np,(int*)v);
|
1871
|
1912
|
break;
|
1872
|
1913
|
|
1873
|
1914
|
case kULongDtId:
|
1874
|
|
- *((unsigned long*)v) = cmDataGetULong(np);
|
|
1915
|
+ rc = cmDataGetULong(np,(unsigned long*)v);
|
1875
|
1916
|
break;
|
1876
|
1917
|
|
1877
|
1918
|
case kLongDtId:
|
1878
|
|
- *((long*)v) = cmDataGetLong(np);
|
|
1919
|
+ rc = cmDataGetLong(np,(long*)v);
|
1879
|
1920
|
break;
|
1880
|
1921
|
|
1881
|
1922
|
case kFloatDtId:
|
1882
|
|
- *((float*)v) = cmDataGetFloat(np);
|
|
1923
|
+ rc = cmDataGetFloat(np,(float*)v);
|
1883
|
1924
|
break;
|
1884
|
1925
|
|
1885
|
1926
|
case kDoubleDtId:
|
1886
|
|
- *((double*)v) = cmDataGetDouble(np);
|
|
1927
|
+ rc = cmDataGetDouble(np,(double*)v);
|
1887
|
1928
|
break;
|
1888
|
1929
|
|
1889
|
1930
|
case kStrDtId:
|
1890
|
|
- *((char**)v) = cmDataGetStr(np);
|
|
1931
|
+ rc = cmDataGetStr(np,(char**)v);
|
1891
|
1932
|
break;
|
1892
|
1933
|
|
1893
|
1934
|
case kConstStrDtId:
|
1894
|
|
- *((const char**)v) = cmDataGetConstStr(np);
|
|
1935
|
+ rc = cmDataGetConstStr(np,(const char**)v);
|
1895
|
1936
|
break;
|
1896
|
1937
|
|
1897
|
1938
|
case kUCharPtrDtId:
|
1898
|
|
- *((unsigned char**)v) = cmDataGetUCharPtr(np);
|
|
1939
|
+ rc = cmDataGetUCharPtr(np,(unsigned char**)v);
|
1899
|
1940
|
break;
|
1900
|
1941
|
|
1901
|
1942
|
case kCharPtrDtId:
|
1902
|
|
- *((char**)v) = cmDataGetCharPtr(np);
|
|
1943
|
+ rc = cmDataGetCharPtr(np,(char**)v);
|
1903
|
1944
|
break;
|
1904
|
1945
|
|
1905
|
1946
|
case kUShortPtrDtId:
|
1906
|
|
- *((unsigned short**)v) = cmDataGetUShortPtr(np);
|
|
1947
|
+ rc = cmDataGetUShortPtr(np,(unsigned short**)v);
|
1907
|
1948
|
break;
|
1908
|
1949
|
|
1909
|
1950
|
case kShortPtrDtId:
|
1910
|
|
- *((short**)v) = cmDataGetShortPtr(np);
|
|
1951
|
+ rc = cmDataGetShortPtr(np,(short**)v);
|
1911
|
1952
|
break;
|
1912
|
1953
|
|
1913
|
1954
|
case kUIntPtrDtId:
|
1914
|
|
- *((unsigned int**)v) = cmDataGetUIntPtr(np);
|
|
1955
|
+ rc = cmDataGetUIntPtr(np,(unsigned int**)v);
|
1915
|
1956
|
break;
|
1916
|
1957
|
|
1917
|
1958
|
case kIntPtrDtId:
|
1918
|
|
- *((int**)v) = cmDataGetIntPtr(np);
|
|
1959
|
+ rc = cmDataGetIntPtr(np,(int**)v);
|
1919
|
1960
|
break;
|
1920
|
1961
|
|
1921
|
1962
|
case kULongPtrDtId:
|
1922
|
|
- *((unsigned long**)v) = cmDataGetULongPtr(np);
|
|
1963
|
+ rc = cmDataGetULongPtr(np,(unsigned long**)v);
|
1923
|
1964
|
break;
|
1924
|
1965
|
|
1925
|
1966
|
case kLongPtrDtId:
|
1926
|
|
- *((long**)v) = cmDataGetLongPtr(np);
|
|
1967
|
+ rc = cmDataGetLongPtr(np,(long**)v);
|
1927
|
1968
|
break;
|
1928
|
1969
|
|
1929
|
1970
|
case kFloatPtrDtId:
|
1930
|
|
- *((float**)v) = cmDataGetFloatPtr(np);
|
|
1971
|
+ rc = cmDataGetFloatPtr(np,(float**)v);
|
1931
|
1972
|
break;
|
1932
|
1973
|
|
1933
|
1974
|
case kDoublePtrDtId:
|
1934
|
|
- *((double**)v) = cmDataGetDoublePtr(np);
|
|
1975
|
+ rc = cmDataGetDoublePtr(np,(double**)v);
|
1935
|
1976
|
break;
|
1936
|
1977
|
|
1937
|
1978
|
case kVoidPtrDtId:
|
1938
|
|
- *((void**)v) = cmDataGetDoublePtr(np);
|
|
1979
|
+ rc = cmDataGetVoidPtr(np,(void**)v);
|
1939
|
1980
|
break;
|
1940
|
1981
|
|
1941
|
1982
|
case kListDtId:
|
|
@@ -2031,30 +2072,30 @@ void _cmDataPrint( const cmData_t* p, cmRpt_t* rpt, unsigned indent )
|
2031
|
2072
|
switch(p->tid)
|
2032
|
2073
|
{
|
2033
|
2074
|
case kNullDtId: cmRptPrintf(rpt,"<null>"); break;
|
2034
|
|
- case kUCharDtId: cmRptPrintf(rpt,"%c ",cmDataGetUChar(p)); break;
|
2035
|
|
- case kCharDtId: cmRptPrintf(rpt,"%c ",cmDataGetChar(p)); break;
|
2036
|
|
- case kUShortDtId: cmRptPrintf(rpt,"%i ",cmDataGetUShort(p)); break;
|
2037
|
|
- case kShortDtId: cmRptPrintf(rpt,"%i ",cmDataGetShort(p)); break;
|
2038
|
|
- case kUIntDtId: cmRptPrintf(rpt,"%i ",cmDataGetUInt(p)); break;
|
2039
|
|
- case kIntDtId: cmRptPrintf(rpt,"%i ",cmDataGetInt(p)); break;
|
2040
|
|
- case kULongDtId: cmRptPrintf(rpt,"%i ",cmDataGetULong(p)); break;
|
2041
|
|
- case kLongDtId: cmRptPrintf(rpt,"%i ",cmDataGetLong(p)); break;
|
2042
|
|
- case kFloatDtId: cmRptPrintf(rpt,"%f ",cmDataGetFloat(p)); break;
|
2043
|
|
- case kDoubleDtId: cmRptPrintf(rpt,"%f ",cmDataGetDouble(p)); break;
|
2044
|
|
-
|
2045
|
|
- case kStrDtId: cmRptPrintf(rpt,"%s ",cmDataGetStr(p)); break;
|
2046
|
|
- case kConstStrDtId: cmRptPrintf(rpt,"%s ",cmDataGetConstStr(p)); break;
|
2047
|
|
-
|
2048
|
|
- case kUCharPtrDtId: parr(rpt,"%c ",cmDataGetUCharPtr(p), p->cnt); break;
|
2049
|
|
- case kCharPtrDtId: parr(rpt,"%c ",cmDataGetCharPtr(p), p->cnt); break;
|
2050
|
|
- case kUShortPtrDtId: parr(rpt,"%i ",cmDataGetUShortPtr(p),p->cnt); break;
|
2051
|
|
- case kShortPtrDtId: parr(rpt,"%i ",cmDataGetShortPtr(p), p->cnt); break;
|
2052
|
|
- case kUIntPtrDtId: parr(rpt,"%i ",cmDataGetUIntPtr(p), p->cnt); break;
|
2053
|
|
- case kIntPtrDtId: parr(rpt,"%i ",cmDataGetIntPtr(p), p->cnt); break;
|
2054
|
|
- case kULongPtrDtId: parr(rpt,"%i ",cmDataGetULongPtr(p), p->cnt); break;
|
2055
|
|
- case kLongPtrDtId: parr(rpt,"%i ",cmDataGetLongPtr(p), p->cnt); break;
|
2056
|
|
- case kFloatPtrDtId: parr(rpt,"%f ",cmDataGetFloatPtr(p), p->cnt); break;
|
2057
|
|
- case kDoublePtrDtId: parr(rpt,"%f ",cmDataGetDoublePtr(p),p->cnt); break;
|
|
2075
|
+ case kUCharDtId: cmRptPrintf(rpt,"%c ",cmDataUChar(p)); break;
|
|
2076
|
+ case kCharDtId: cmRptPrintf(rpt,"%c ",cmDataChar(p)); break;
|
|
2077
|
+ case kUShortDtId: cmRptPrintf(rpt,"%i ",cmDataUShort(p)); break;
|
|
2078
|
+ case kShortDtId: cmRptPrintf(rpt,"%i ",cmDataShort(p)); break;
|
|
2079
|
+ case kUIntDtId: cmRptPrintf(rpt,"%i ",cmDataUInt(p)); break;
|
|
2080
|
+ case kIntDtId: cmRptPrintf(rpt,"%i ",cmDataInt(p)); break;
|
|
2081
|
+ case kULongDtId: cmRptPrintf(rpt,"%i ",cmDataULong(p)); break;
|
|
2082
|
+ case kLongDtId: cmRptPrintf(rpt,"%i ",cmDataLong(p)); break;
|
|
2083
|
+ case kFloatDtId: cmRptPrintf(rpt,"%f ",cmDataFloat(p)); break;
|
|
2084
|
+ case kDoubleDtId: cmRptPrintf(rpt,"%f ",cmDataDouble(p)); break;
|
|
2085
|
+
|
|
2086
|
+ case kStrDtId: cmRptPrintf(rpt,"%s ",cmDataStr(p)); break;
|
|
2087
|
+ case kConstStrDtId: cmRptPrintf(rpt,"%s ",cmDataConstStr(p)); break;
|
|
2088
|
+
|
|
2089
|
+ case kUCharPtrDtId: parr(rpt,"%c ",cmDataUCharPtr(p), p->cnt); break;
|
|
2090
|
+ case kCharPtrDtId: parr(rpt,"%c ",cmDataCharPtr(p), p->cnt); break;
|
|
2091
|
+ case kUShortPtrDtId: parr(rpt,"%i ",cmDataUShortPtr(p),p->cnt); break;
|
|
2092
|
+ case kShortPtrDtId: parr(rpt,"%i ",cmDataShortPtr(p), p->cnt); break;
|
|
2093
|
+ case kUIntPtrDtId: parr(rpt,"%i ",cmDataUIntPtr(p), p->cnt); break;
|
|
2094
|
+ case kIntPtrDtId: parr(rpt,"%i ",cmDataIntPtr(p), p->cnt); break;
|
|
2095
|
+ case kULongPtrDtId: parr(rpt,"%i ",cmDataULongPtr(p), p->cnt); break;
|
|
2096
|
+ case kLongPtrDtId: parr(rpt,"%i ",cmDataLongPtr(p), p->cnt); break;
|
|
2097
|
+ case kFloatPtrDtId: parr(rpt,"%f ",cmDataFloatPtr(p), p->cnt); break;
|
|
2098
|
+ case kDoublePtrDtId: parr(rpt,"%f ",cmDataDoublePtr(p),p->cnt); break;
|
2058
|
2099
|
|
2059
|
2100
|
case kVoidPtrDtId: cmRptPrintf(rpt,"<void:%i>",p->cnt); break;
|
2060
|
2101
|
|