00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00033 #ifndef _LCM_LIB_INLINE_H
00034 #define _LCM_LIB_INLINE_H
00035
00036 #include <stdio.h>
00037 #include <stdint.h>
00038 #include <string.h>
00039 #include <stdlib.h>
00040
00041 #ifdef __cplusplus
00042 extern "C" {
00043 #endif
00044
00045 union float_uint32
00046 {
00047 float f;
00048 uint32_t i;
00049 };
00050
00051 union double_uint64
00052 {
00053 double f;
00054 uint64_t i;
00055 };
00056
00057 typedef struct ___lcm_hash_ptr __lcm_hash_ptr;
00058 struct ___lcm_hash_ptr
00059 {
00060 const __lcm_hash_ptr *parent;
00061 void *v;
00062 };
00063
00067 #define __boolean_hash_recursive __int8_t_hash_recursive
00068 #define __boolean_decode_array_cleanup __int8_t_decode_array_cleanup
00069 #define __boolean_encoded_array_size __int8_t_encoded_array_size
00070 #define __boolean_encode_array __int8_t_encode_array
00071 #define __boolean_decode_array __int8_t_decode_array
00072 #define __boolean_clone_array __int8_t_clone_array
00073 #define boolean_encoded_size int8_t_encoded_size
00074
00078 #define __byte_hash_recursive(p) 0
00079 #define __byte_decode_array_cleanup(p, sz) {}
00080 #define byte_encoded_size(p) ( sizeof(int64_t) + sizeof(uint8_t) )
00081
00082 static inline int __byte_encoded_array_size(const uint8_t *p, int elements)
00083 {
00084 return sizeof(uint8_t) * elements;
00085 }
00086
00087 static inline int __byte_encode_array(void *_buf, int offset, int maxlen, const uint8_t *p, int elements)
00088 {
00089 if (maxlen < elements)
00090 return -1;
00091
00092 uint8_t *buf = (uint8_t*) _buf;
00093 memcpy(&buf[offset], p, elements);
00094
00095 return elements;
00096 }
00097
00098 static inline int __byte_decode_array(const void *_buf, int offset, int maxlen, uint8_t *p, int elements)
00099 {
00100 if (maxlen < elements)
00101 return -1;
00102
00103 uint8_t *buf = (uint8_t*) _buf;
00104 memcpy(p, &buf[offset], elements);
00105
00106 return elements;
00107 }
00108
00109 static inline int __byte_clone_array(const uint8_t *p, uint8_t *q, int elements)
00110 {
00111 memcpy(q, p, elements * sizeof(uint8_t));
00112 return 0;
00113 }
00117 #define __int8_t_hash_recursive(p) 0
00118 #define __int8_t_decode_array_cleanup(p, sz) {}
00119 #define int8_t_encoded_size(p) ( sizeof(int64_t) + sizeof(int8_t) )
00120
00121 static inline int __int8_t_encoded_array_size(const int8_t *p, int elements)
00122 {
00123 return sizeof(int8_t) * elements;
00124 }
00125
00126 static inline int __int8_t_encode_array(void *_buf, int offset, int maxlen, const int8_t *p, int elements)
00127 {
00128 if (maxlen < elements)
00129 return -1;
00130
00131 int8_t *buf = (int8_t*) _buf;
00132 memcpy(&buf[offset], p, elements);
00133
00134 return elements;
00135 }
00136
00137 static inline int __int8_t_decode_array(const void *_buf, int offset, int maxlen, int8_t *p, int elements)
00138 {
00139 if (maxlen < elements)
00140 return -1;
00141
00142 int8_t *buf = (int8_t*) _buf;
00143 memcpy(p, &buf[offset], elements);
00144
00145 return elements;
00146 }
00147
00148 static inline int __int8_t_clone_array(const int8_t *p, int8_t *q, int elements)
00149 {
00150 memcpy(q, p, elements * sizeof(int8_t));
00151 return 0;
00152 }
00153
00157 #define __int16_t_hash_recursive(p) 0
00158 #define __int16_t_decode_array_cleanup(p, sz) {}
00159 #define int16_t_encoded_size(p) ( sizeof(int64_t) + sizeof(int16_t) )
00160
00161 static inline int __int16_t_encoded_array_size(const int16_t *p, int elements)
00162 {
00163 return sizeof(int16_t) * elements;
00164 }
00165
00166 static inline int __int16_t_encode_array(void *_buf, int offset, int maxlen, const int16_t *p, int elements)
00167 {
00168 int total_size = sizeof(int16_t) * elements;
00169 uint8_t *buf = (uint8_t*) _buf;
00170 int pos = offset;
00171 int element;
00172
00173 if (maxlen < total_size)
00174 return -1;
00175
00176 for (element = 0; element < elements; element++) {
00177 int16_t v = p[element];
00178 buf[pos++] = (v>>8) & 0xff;
00179 buf[pos++] = (v & 0xff);
00180 }
00181
00182 return total_size;
00183 }
00184
00185 static inline int __int16_t_decode_array(const void *_buf, int offset, int maxlen, int16_t *p, int elements)
00186 {
00187 int total_size = sizeof(int16_t) * elements;
00188 uint8_t *buf = (uint8_t*) _buf;
00189 int pos = offset;
00190 int element;
00191
00192 if (maxlen < total_size)
00193 return -1;
00194
00195 for (element = 0; element < elements; element++) {
00196 p[element] = (buf[pos]<<8) + buf[pos+1];
00197 pos+=2;
00198 }
00199
00200 return total_size;
00201 }
00202
00203 static inline int __int16_t_clone_array(const int16_t *p, int16_t *q, int elements)
00204 {
00205 memcpy(q, p, elements * sizeof(int16_t));
00206 return 0;
00207 }
00208
00212 #define __int32_t_hash_recursive(p) 0
00213 #define __int32_t_decode_array_cleanup(p, sz) {}
00214 #define int32_t_encoded_size(p) ( sizeof(int64_t) + sizeof(int32_t) )
00215
00216 static inline int __int32_t_encoded_array_size(const int32_t *p, int elements)
00217 {
00218 return sizeof(int32_t) * elements;
00219 }
00220
00221 static inline int __int32_t_encode_array(void *_buf, int offset, int maxlen, const int32_t *p, int elements)
00222 {
00223 int total_size = sizeof(int32_t) * elements;
00224 uint8_t *buf = (uint8_t*) _buf;
00225 int pos = offset;
00226 int element;
00227
00228 if (maxlen < total_size)
00229 return -1;
00230
00231 for (element = 0; element < elements; element++) {
00232 int32_t v = p[element];
00233 buf[pos++] = (v>>24)&0xff;
00234 buf[pos++] = (v>>16)&0xff;
00235 buf[pos++] = (v>>8)&0xff;
00236 buf[pos++] = (v & 0xff);
00237 }
00238
00239 return total_size;
00240 }
00241
00242 static inline int __int32_t_decode_array(const void *_buf, int offset, int maxlen, int32_t *p, int elements)
00243 {
00244 int total_size = sizeof(int32_t) * elements;
00245 uint8_t *buf = (uint8_t*) _buf;
00246 int pos = offset;
00247 int element;
00248
00249 if (maxlen < total_size)
00250 return -1;
00251
00252 for (element = 0; element < elements; element++) {
00253 p[element] = (buf[pos+0]<<24) + (buf[pos+1]<<16) + (buf[pos+2]<<8) + buf[pos+3];
00254 pos+=4;
00255 }
00256
00257 return total_size;
00258 }
00259
00260 static inline int __int32_t_clone_array(const int32_t *p, int32_t *q, int elements)
00261 {
00262 memcpy(q, p, elements * sizeof(int32_t));
00263 return 0;
00264 }
00265
00269 #define __int64_t_hash_recursive(p) 0
00270 #define __int64_t_decode_array_cleanup(p, sz) {}
00271 #define int64_t_encoded_size(p) ( sizeof(int64_t) + sizeof(int64_t) )
00272
00273 static inline int __int64_t_encoded_array_size(const int64_t *p, int elements)
00274 {
00275 return sizeof(int64_t) * elements;
00276 }
00277
00278 static inline int __int64_t_encode_array(void *_buf, int offset, int maxlen, const int64_t *p, int elements)
00279 {
00280 int total_size = sizeof(int64_t) * elements;
00281 uint8_t *buf = (uint8_t*) _buf;
00282 int pos = offset;
00283 int element;
00284
00285 if (maxlen < total_size)
00286 return -1;
00287
00288 for (element = 0; element < elements; element++) {
00289 int64_t v = p[element];
00290 buf[pos++] = (v>>56)&0xff;
00291 buf[pos++] = (v>>48)&0xff;
00292 buf[pos++] = (v>>40)&0xff;
00293 buf[pos++] = (v>>32)&0xff;
00294 buf[pos++] = (v>>24)&0xff;
00295 buf[pos++] = (v>>16)&0xff;
00296 buf[pos++] = (v>>8)&0xff;
00297 buf[pos++] = (v & 0xff);
00298 }
00299
00300 return total_size;
00301 }
00302
00303 static inline int __int64_t_decode_array(const void *_buf, int offset, int maxlen, int64_t *p, int elements)
00304 {
00305 int total_size = sizeof(int64_t) * elements;
00306 uint8_t *buf = (uint8_t*) _buf;
00307 int pos = offset;
00308 int element;
00309
00310 if (maxlen < total_size)
00311 return -1;
00312
00313 for (element = 0; element < elements; element++) {
00314 int64_t a = (buf[pos+0]<<24) + (buf[pos+1]<<16) + (buf[pos+2]<<8) + buf[pos+3];
00315 pos+=4;
00316 int64_t b = (buf[pos+0]<<24) + (buf[pos+1]<<16) + (buf[pos+2]<<8) + buf[pos+3];
00317 pos+=4;
00318 p[element] = (a<<32) + (b&0xffffffff);
00319 }
00320
00321 return total_size;
00322 }
00323
00324 static inline int __int64_t_clone_array(const int64_t *p, int64_t *q, int elements)
00325 {
00326 memcpy(q, p, elements * sizeof(int64_t));
00327 return 0;
00328 }
00329
00333 #define __float_hash_recursive(p) 0
00334 #define __float_decode_array_cleanup(p, sz) {}
00335 #define float_encoded_size(p) ( sizeof(int64_t) + sizeof(float) )
00336
00337 static inline int __float_encoded_array_size(const float *p, int elements)
00338 {
00339 return sizeof(float) * elements;
00340 }
00341
00342 static inline int __float_encode_array(void *_buf, int offset, int maxlen, const float *p, int elements)
00343 {
00344 return __int32_t_encode_array(_buf, offset, maxlen, (int32_t*) p, elements);
00345 }
00346
00347 static inline int __float_decode_array(const void *_buf, int offset, int maxlen, float *p, int elements)
00348 {
00349 return __int32_t_decode_array(_buf, offset, maxlen, (int32_t*) p, elements);
00350 }
00351
00352 static inline int __float_clone_array(const float *p, float *q, int elements)
00353 {
00354 memcpy(q, p, elements * sizeof(float));
00355 return 0;
00356 }
00357
00361 #define __double_hash_recursive(p) 0
00362 #define __double_decode_array_cleanup(p, sz) {}
00363 #define double_encoded_size(p) ( sizeof(int64_t) + sizeof(double) )
00364
00365 static inline int __double_encoded_array_size(const double *p, int elements)
00366 {
00367 return sizeof(double) * elements;
00368 }
00369
00370 static inline int __double_encode_array(void *_buf, int offset, int maxlen, const double *p, int elements)
00371 {
00372 return __int64_t_encode_array(_buf, offset, maxlen, (int64_t*) p, elements);
00373 }
00374
00375 static inline int __double_decode_array(const void *_buf, int offset, int maxlen, double *p, int elements)
00376 {
00377 return __int64_t_decode_array(_buf, offset, maxlen, (int64_t*) p, elements);
00378 }
00379
00380 static inline int __double_clone_array(const double *p, double *q, int elements)
00381 {
00382 memcpy(q, p, elements * sizeof(double));
00383 return 0;
00384 }
00385
00389 #define __string_hash_recursive(p) 0
00390
00391 static inline int __string_decode_array_cleanup(char **s, int elements)
00392 {
00393 int element;
00394 for (element = 0; element < elements; element++)
00395 free(s[element]);
00396 return 0;
00397 }
00398
00399 static inline int __string_encoded_array_size(char * const *s, int elements)
00400 {
00401 int size = 0;
00402 int element;
00403 for (element = 0; element < elements; element++)
00404 size += 4 + strlen(s[element]) + 1;
00405
00406 return size;
00407 }
00408
00409 static inline int __string_encoded_size(char * const *s)
00410 {
00411 return sizeof(int64_t) + __string_encoded_array_size(s, 1);
00412 }
00413
00414 static inline int __string_encode_array(void *_buf, int offset, int maxlen, char * const *p, int elements)
00415 {
00416 int pos = 0, thislen;
00417 int element;
00418
00419 for (element = 0; element < elements; element++) {
00420 int length = strlen(p[element]) + 1;
00421
00422 thislen = __int32_t_encode_array(_buf, offset + pos, maxlen - pos, &length, 1);
00423 if (thislen < 0) return thislen; else pos += thislen;
00424
00425 thislen = __int8_t_encode_array(_buf, offset + pos, maxlen - pos, (int8_t*) p[element], length);
00426 if (thislen < 0) return thislen; else pos += thislen;
00427 }
00428
00429 return pos;
00430 }
00431
00432 static inline int __string_decode_array(const void *_buf, int offset, int maxlen, char **p, int elements)
00433 {
00434 int pos = 0, thislen;
00435 int element;
00436
00437 for (element = 0; element < elements; element++) {
00438 int length;
00439
00440
00441 thislen = __int32_t_decode_array(_buf, offset + pos, maxlen - pos, &length, 1);
00442 if (thislen < 0) return thislen; else pos += thislen;
00443
00444 p[element] = (char*) malloc(length);
00445 thislen = __int8_t_decode_array(_buf, offset + pos, maxlen - pos, (int8_t*) p[element], length);
00446 if (thislen < 0) return thislen; else pos += thislen;
00447 }
00448
00449 return pos;
00450 }
00451
00452 static inline int __string_clone_array(char * const *p, char **q, int elements)
00453 {
00454 int element;
00455 for (element = 0; element < elements; element++) {
00456
00457 size_t len = strlen(p[element]) + 1;
00458 q[element] = (char*) malloc (len);
00459 memcpy (q[element], p[element], len);
00460 }
00461 return 0;
00462 }
00463
00464 static inline void *lcm_malloc(size_t sz)
00465 {
00466 if (sz)
00467 return malloc(sz);
00468 return NULL;
00469 }
00470
00471 #ifdef __cplusplus
00472 }
00473 #endif
00474
00475 #endif
00476