69 stringstream s; |
69 stringstream s; |
70 |
70 |
71 s |
71 s |
72 << "These are valid data types to use with" << endl |
72 << "These are valid data types to use with" << endl |
73 << "the --type option:" << endl |
73 << "the --type option:" << endl |
74 << " int8, int16, int32, uint8, uint16, uint32, string," << endl |
74 << " bool," << endl |
75 << " octet_string." << endl; |
75 << " int8, int16, int32, int64," << endl |
|
76 << " uint8, uint16, uint32, uint64," << endl |
|
77 << " float, double" << endl |
|
78 << " string, octet_string, unicode_string." << endl; |
76 return s.str(); |
79 return s.str(); |
77 } |
80 } |
78 |
81 |
79 /****************************************************************************/ |
82 /****************************************************************************/ |
80 |
83 |
158 uint32_t val; |
170 uint32_t val; |
159 str >> val; |
171 str >> val; |
160 *(uint32_t *) target = cpu_to_le32(val); |
172 *(uint32_t *) target = cpu_to_le32(val); |
161 break; |
173 break; |
162 } |
174 } |
|
175 case 0x0008: // float |
|
176 { |
|
177 float val; |
|
178 str >> val; |
|
179 *(uint32_t *) target = |
|
180 cpu_to_le32(*(uint32_t *) (void *) &val); |
|
181 break; |
|
182 } |
163 case 0x0009: // string |
183 case 0x0009: // string |
164 case 0x000a: // octet_string |
184 case 0x000a: // octet_string |
|
185 case 0x000b: // unicode_string |
165 dataSize = str.str().size(); |
186 dataSize = str.str().size(); |
166 if (dataSize >= targetSize) { |
187 if (dataSize >= targetSize) { |
167 stringstream err; |
188 stringstream err; |
168 err << "String too large"; |
189 err << "String too large"; |
169 throw SizeException(err.str()); |
190 throw SizeException(err.str()); |
170 } |
191 } |
171 str >> (char *) target; |
192 str >> (char *) target; |
172 break; |
193 break; |
|
194 case 0x0011: // double |
|
195 { |
|
196 double val; |
|
197 str >> val; |
|
198 *(uint64_t *) target = |
|
199 cpu_to_le64(*(uint64_t *) (void *) &val); |
|
200 break; |
|
201 } |
|
202 break; |
|
203 case 0x0015: // int64 |
|
204 { |
|
205 int64_t val; |
|
206 str >> val; |
|
207 *(int64_t *) target = cpu_to_le64(val); |
|
208 break; |
|
209 } |
|
210 break; |
|
211 case 0x001b: // uint64 |
|
212 { |
|
213 uint64_t val; |
|
214 str >> val; |
|
215 *(uint64_t *) target = cpu_to_le64(val); |
|
216 break; |
|
217 } |
|
218 break; |
|
219 |
|
220 case 0x0010: // int24 |
|
221 case 0x0012: // int40 |
|
222 case 0x0013: // int48 |
|
223 case 0x0014: // int56 |
|
224 case 0x0016: // uint24 |
|
225 case 0x0018: // uint40 |
|
226 case 0x0019: // uint48 |
|
227 case 0x001a: // uint56 |
|
228 { |
|
229 stringstream err; |
|
230 err << "Non-native integer type " << type->name |
|
231 << " is not yet implemented."; |
|
232 throw runtime_error(err.str()); |
|
233 } |
173 |
234 |
174 default: |
235 default: |
175 { |
236 { |
176 stringstream err; |
237 stringstream err; |
177 err << "Unknown data type 0x" << hex << type->code; |
238 err << "Unknown data type 0x" << hex << type->code; |
204 } |
265 } |
205 |
266 |
206 o << setfill('0'); |
267 o << setfill('0'); |
207 |
268 |
208 switch (type->code) { |
269 switch (type->code) { |
209 case 0x0002: // int8 |
270 case 0x0001: // bool |
210 { |
271 { |
211 int val = (int) *(int8_t *) data; |
272 int val = (int) *(int8_t *) data; |
212 o << "0x" << hex << setw(2) << val |
273 o << "0x" << hex << setw(2) << val |
213 << " " << dec << val << endl; |
274 << " " << dec << val << endl; |
214 } |
275 } |
215 break; |
276 break; |
|
277 case 0x0002: // int8 |
|
278 { |
|
279 int val = (int) *(int8_t *) data; |
|
280 o << "0x" << hex << setw(2) << val |
|
281 << " " << dec << val << endl; |
|
282 } |
|
283 break; |
216 case 0x0003: // int16 |
284 case 0x0003: // int16 |
217 { |
285 { |
218 int16_t val = le16_to_cpup(data); |
286 int16_t val = le16_to_cpup(data); |
219 o << "0x" << hex << setw(4) << val |
287 o << "0x" << hex << setw(4) << val |
220 << " " << dec << val << endl; |
288 << " " << dec << val << endl; |
246 uint32_t val = le32_to_cpup(data); |
314 uint32_t val = le32_to_cpup(data); |
247 o << "0x" << hex << setw(8) << val |
315 o << "0x" << hex << setw(8) << val |
248 << " " << dec << val << endl; |
316 << " " << dec << val << endl; |
249 } |
317 } |
250 break; |
318 break; |
|
319 case 0x0008: // float |
|
320 { |
|
321 uint32_t val = le32_to_cpup(data); |
|
322 float fval = *(float *) (void *) &val; |
|
323 o << fval << endl; |
|
324 } |
|
325 break; |
251 case 0x0009: // string |
326 case 0x0009: // string |
252 o << string((const char *) data, dataSize) << endl; |
327 o << string((const char *) data, dataSize) << endl; |
253 break; |
328 break; |
254 case 0x000a: // octet_string |
329 case 0x000a: // octet_string |
255 o << string((const char *) data, dataSize) << endl; |
330 o << string((const char *) data, dataSize) << endl; |
256 break; |
331 break; |
|
332 case 0x000b: // unicode_string |
|
333 // FIXME encoding |
|
334 o << string((const char *) data, dataSize) << endl; |
|
335 break; |
|
336 case 0x0011: // double |
|
337 { |
|
338 uint64_t val = le64_to_cpup(data); |
|
339 double fval = *(double *) (void *) &val; |
|
340 o << fval << endl; |
|
341 } |
|
342 break; |
|
343 case 0x0015: // int64 |
|
344 { |
|
345 int64_t val = le64_to_cpup(data); |
|
346 o << "0x" << hex << setw(16) << val |
|
347 << " " << dec << val << endl; |
|
348 } |
|
349 break; |
|
350 case 0x001b: // uint64 |
|
351 { |
|
352 uint64_t val = le64_to_cpup(data); |
|
353 o << "0x" << hex << setw(16) << val |
|
354 << " " << dec << val << endl; |
|
355 } |
|
356 break; |
|
357 |
257 default: |
358 default: |
258 printRawData(o, (const uint8_t *) data, dataSize); // FIXME |
359 printRawData(o, (const uint8_t *) data, dataSize); // FIXME |
259 break; |
360 break; |
260 } |
361 } |
261 } |
362 } |
278 } |
379 } |
279 |
380 |
280 /****************************************************************************/ |
381 /****************************************************************************/ |
281 |
382 |
282 const DataTypeHandler::DataType DataTypeHandler::dataTypes[] = { |
383 const DataTypeHandler::DataType DataTypeHandler::dataTypes[] = { |
283 {"int8", 0x0002, 1}, |
384 {"bool", 0x0001, 1}, |
284 {"int16", 0x0003, 2}, |
385 {"int8", 0x0002, 1}, |
285 {"int32", 0x0004, 4}, |
386 {"int16", 0x0003, 2}, |
286 {"uint8", 0x0005, 1}, |
387 {"int32", 0x0004, 4}, |
287 {"uint16", 0x0006, 2}, |
388 {"uint8", 0x0005, 1}, |
288 {"uint32", 0x0007, 4}, |
389 {"uint16", 0x0006, 2}, |
289 {"string", 0x0009, 0}, |
390 {"uint32", 0x0007, 4}, |
290 {"octet_string", 0x000a, 0}, |
391 {"float", 0x0008, 4}, |
291 {"raw", 0xffff, 0}, |
392 {"string", 0x0009, 0}, // a. k. a. visible_string |
292 //{"int64", 8}, |
393 {"octet_string", 0x000a, 0}, |
293 //{"uint64", 8}, |
394 {"unicode_string", 0x000b, 0}, |
|
395 // ... not implemented yet |
|
396 {"int24", 0x0010, 3}, |
|
397 {"double", 0x0011, 8}, |
|
398 {"int40", 0x0012, 5}, |
|
399 {"int48", 0x0013, 6}, |
|
400 {"int56", 0x0014, 7}, |
|
401 {"int64", 0x0015, 8}, |
|
402 {"uint24", 0x0016, 3}, |
|
403 // reserved 0x0017 |
|
404 {"uint40", 0x0018, 5}, |
|
405 {"uint48", 0x0019, 6}, |
|
406 {"uint56", 0x001a, 7}, |
|
407 {"uint64", 0x001b, 8}, |
|
408 // reserved 0x001c-0x001f |
|
409 {"raw", 0xffff, 0}, |
294 {} |
410 {} |
295 }; |
411 }; |
296 |
412 |
297 /*****************************************************************************/ |
413 /*****************************************************************************/ |