[BACK]Return to aitio.h CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitio / inc

Diff for /libaitio/inc/aitio.h between versions 1.11.2.1 and 1.11.2.9

version 1.11.2.1, 2011/08/29 14:57:53 version 1.11.2.9, 2011/08/31 13:23:25
Line 103  struct tagReqXML { Line 103  struct tagReqXML {
         url_Item_t      xml_value;          url_Item_t      xml_value;
 };  };
   
/* RPC variables and managment *//* AIT RPC variables and managment */
   
 typedef enum {  typedef enum {
         empty,                          /* empty -> variable is not set */          empty,                          /* empty -> variable is not set */
        buffer, string, blob, array,  /* buffer -> uint8_t*; string -> int8_t*;         buffer, string, blob,           /* buffer -> uint8_t*; string -> int8_t*; blob -> void*(+socket); */
                                                blob -> void*(+socket); array -> array_t* */        f32, f64,                       /* float -> f32; double -> f64 */
         u8, u16, u32, u64,              /* unsigned integers ... */          u8, u16, u32, u64,              /* unsigned integers ... */
        i8, i16, i32, i64               /* integers ... */        i8, i16, i32, i64,                /* integers ... */
 } ait_type_t;  } ait_type_t;
   
 typedef struct {  typedef struct {
         uint8_t         val_type;          uint8_t         val_type;
         uint32_t        val_len;          uint32_t        val_len;
         union {          union {
                uint8_t         *buffer,                uint64_t        net;
                                *array;
                 uint8_t         *buffer;
                 int8_t          *string;                  int8_t          *string;
                 uint32_t        blob;                  uint32_t        blob;
                   float           f32;
                   double          f64;
                 uint8_t         u8;                  uint8_t         u8;
                 uint16_t        u16;                  uint16_t        u16;
                 uint32_t        u32;                  uint32_t        u32;
Line 132  typedef struct { Line 135  typedef struct {
         } val;          } val;
 } __packed ait_val_t;  } __packed ait_val_t;
   
#define AIT_TYPE(_vl)                   (assert((_vl)), ((ait_type_t) (_vl)->val_type))#define AIT_TYPE(_vl)                   ((ait_type_t) (_vl)->val_type)
#define AIT_LEN(_vl)                    (assert((_vl)), (_vl)->val_len)#define AIT_LEN(_vl)                    (_vl)->val_len
#define AIT_BLOB_CHUNKS(_vl, _n)        (assert((_vl)), (_vl)->val_len / _n + ((_vl)->val_len % _n) ? 1 : 0)#define AIT_BLOB_CHUNKS(_vl, _n)        (assert((_vl)), AIT_LEN((_vl)) / _n + (AIT_LEN((_vl)) % _n) ? 1 : 0)
#define AIT_ISEMPTY(_vl)                (assert((_vl)), (_vl)->val_type == empty)#define AIT_ISEMPTY(_vl)                (assert((_vl)), AIT_TYPE((_vl)) == empty)
   
#define AIT_GET_ARRAY(_vl)              (assert((_vl)), assert((_vl)->val_type == array), \#define AIT_GET_BUF(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == buffer), (_vl)->val.buffer)
                                                ((array_t*) (_vl)->val.array))#define AIT_GET_STR(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == string), (_vl)->val.string)
#define AIT_GET_BUF(_vl)                (assert((_vl)), assert((_vl)->val_type == buffer), (_vl)->val.buffer)#define AIT_GET_BLOB(_vl)               (assert((_vl)), assert(AIT_TYPE((_vl)) == blob), (_vl)->val.blob)
#define AIT_GET_STR(_vl)                (assert((_vl)), assert((_vl)->val_type == string), (_vl)->val.string)#define AIT_GET_U8(_vl)                 (assert((_vl)), assert(AIT_TYPE((_vl)) == u8), (_vl)->val.u8)
#define AIT_GET_BLOB(_vl)               (assert((_vl)), assert((_vl)->val_type == blob), (_vl)->val.blob)#define AIT_GET_U16(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == u16), (_vl)->val.u16)
#define AIT_GET_U8(_vl)                 (assert((_vl)), assert((_vl)->val_type == u8), (_vl)->val.u8)#define AIT_GET_U32(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == u32), (_vl)->val.u32)
#define AIT_GET_U16(_vl)                (assert((_vl)), assert((_vl)->val_type == u16), (_vl)->val.u16)#define AIT_GET_U64(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == u64), (_vl)->val.u64)
#define AIT_GET_U32(_vl)                (assert((_vl)), assert((_vl)->val_type == u32), (_vl)->val.u32)#define AIT_GET_I8(_vl)                 (assert((_vl)), assert(AIT_TYPE((_vl)) == i8), (_vl)->val.i8)
#define AIT_GET_U64(_vl)                (assert((_vl)), assert((_vl)->val_type == u64), (_vl)->val.u64)#define AIT_GET_I16(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == i16), (_vl)->val.i16)
#define AIT_GET_I8(_vl)                 (assert((_vl)), assert((_vl)->val_type == i8), (_vl)->val.i8)#define AIT_GET_I32(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == i32), (_vl)->val.i32)
#define AIT_GET_I16(_vl)                (assert((_vl)), assert((_vl)->val_type == i16), (_vl)->val.i16)#define AIT_GET_I64(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == i64), (_vl)->val.i64)
#define AIT_GET_I32(_vl)                (assert((_vl)), assert((_vl)->val_type == i32), (_vl)->val.i32)#define AIT_GET_F32(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == f32), (_vl)->val.f32)
#define AIT_GET_I64(_vl)                (assert((_vl)), assert((_vl)->val_type == i64), (_vl)->val.i64)#define AIT_GET_F64(_vl)                (assert((_vl)), assert(AIT_TYPE((_vl)) == f64), (_vl)->val.f64)
   
 #define AIT_SET_BUF(_vl, _v, _len)      do { ait_val_t *__val = (_vl); assert(__val); assert((_v)); \  #define AIT_SET_BUF(_vl, _v, _len)      do { ait_val_t *__val = (_vl); assert(__val); assert((_v)); \
                                                 __val->val.buffer = malloc(_len); \                                                  __val->val.buffer = malloc(_len); \
                                                 if (__val->val.buffer) { \                                                  if (__val->val.buffer) { \
                                                        AIT_TYPE(__val) = buffer; AIT_LEN(__val) = _len; \                                                        __val->val_type = buffer; AIT_LEN(__val) = _len; \
                                                         memcpy(__val->val.buffer, (_v), _len); \                                                          memcpy(__val->val.buffer, (_v), _len); \
                                                 } } while (0)                                                  } } while (0)
#define AIT_SET_STR(_vl, _v)            do { ait_val_t *__val = (_vl); assert(__val); assert((_v)); \#define AIT_SET_STR(_vl, _v)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                 __val->val.string = (int8_t*) strdup((_v)); \                                                  __val->val.string = (int8_t*) strdup((_v)); \
                                                 if (__val->val.string) { \                                                  if (__val->val.string) { \
                                                        AIT_TYPE(__val) = string; \                                                        __val->val_type = string; \
                                                         AIT_LEN(__val) = strlen((_v)) + 1; \                                                          AIT_LEN(__val) = strlen((_v)) + 1; \
                                                 } } while (0)                                                  } } while (0)
 #define AIT_SET_BLOB(_vl, _n, _len)     do { ait_val_t *__val = (_vl); assert(__val); \  #define AIT_SET_BLOB(_vl, _n, _len)     do { ait_val_t *__val = (_vl); assert(__val); \
                                                AIT_TYPE(__val) = blob; AIT_LEN(__val) = _len; \                                                __val->val_type = blob; AIT_LEN(__val) = _len; \
                                                 __val->val.blob = _n; } while (0)                                                  __val->val.blob = _n; } while (0)
 #define AIT_SET_BLOB2(_vl, _bv)         do { ait_val_t *__val = (_vl); assert(__val); assert((_bv)); \  #define AIT_SET_BLOB2(_vl, _bv)         do { ait_val_t *__val = (_vl); assert(__val); assert((_bv)); \
                                                AIT_TYPE(__val) = blob; AIT_LEN(__val) = (_bv)->blob_len; \                                                __val->val_type = blob; AIT_LEN(__val) = (_bv)->blob_len; \
                                                 __val->val.blob = (_bv)->blob_var; } while (0)                                                  __val->val.blob = (_bv)->blob_var; } while (0)
 #define AIT_SET_ARRAY(_vl, _arr)        do { ait_val_t *__val = (_vl); assert(__val); assert((_arr)); \  
                                                 AIT_TYPE(__val) = array; AIT_LEN(__val) = io_arraySize((_arr)); \  
                                         } while (0)  
   
 #define AIT_SET_U8(_vl, _n)             do { ait_val_t *__val = (_vl); assert(__val); \  #define AIT_SET_U8(_vl, _n)             do { ait_val_t *__val = (_vl); assert(__val); \
                                                AIT_TYPE(__val) = u8; __val->val.u8 = _n; \                                                __val->val_type = u8; __val->val.u8 = _n; \
                                                 AIT_LEN(__val) = sizeof(uint8_t); } while (0)                                                  AIT_LEN(__val) = sizeof(uint8_t); } while (0)
 #define AIT_SET_U16(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \  #define AIT_SET_U16(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                AIT_TYPE(__val) = u16; __val->val.u16 = _n; \                                                __val->val_type = u16; __val->val.u16 = _n; \
                                                 AIT_LEN(__val) = sizeof(uint16_t); } while (0)                                                  AIT_LEN(__val) = sizeof(uint16_t); } while (0)
 #define AIT_SET_U32(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \  #define AIT_SET_U32(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                AIT_TYPE(__val) = u32; __val->val.u32 = _n; \                                                __val->val_type = u32; __val->val.u32 = _n; \
                                                 AIT_LEN(__val) = sizeof(uint32_t); } while (0)                                                  AIT_LEN(__val) = sizeof(uint32_t); } while (0)
 #define AIT_SET_U64(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \  #define AIT_SET_U64(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                AIT_TYPE(__val) = u64; __val->val.u64 = _n; \                                                __val->val_type = u64; __val->val.u64 = _n; \
                                                 AIT_LEN(__val) = sizeof(uint64_t); } while (0)                                                  AIT_LEN(__val) = sizeof(uint64_t); } while (0)
 #define AIT_SET_I8(_vl, _n)             do { ait_val_t *__val = (_vl); assert(__val); \  #define AIT_SET_I8(_vl, _n)             do { ait_val_t *__val = (_vl); assert(__val); \
                                                AIT_TYPE(__val) = i8; __val->val.i8 = _n; \                                                __val->val_type = i8; __val->val.i8 = _n; \
                                                 AIT_LEN(__val) = sizeof(int8_t); } while (0)                                                  AIT_LEN(__val) = sizeof(int8_t); } while (0)
 #define AIT_SET_I16(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \  #define AIT_SET_I16(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                AIT_TYPE(__val) = i16; __val->val.i16 = _n; \                                                __val->val_type = i16; __val->val.i16 = _n; \
                                                 AIT_LEN(__val) = sizeof(int16_t); } while (0)                                                  AIT_LEN(__val) = sizeof(int16_t); } while (0)
 #define AIT_SET_I32(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \  #define AIT_SET_I32(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                AIT_TYPE(__val) = i32; __val->val.i32 = _n; \                                                __val->val_type = i32; __val->val.i32 = _n; \
                                                 AIT_LEN(__val) = sizeof(int32_t); } while (0)                                                  AIT_LEN(__val) = sizeof(int32_t); } while (0)
 #define AIT_SET_I64(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \  #define AIT_SET_I64(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                AIT_TYPE(__val) = i64; __val->val.i64 = _n; \                                                __val->val_type = i64; __val->val.i64 = _n; \
                                                 AIT_LEN(__val) = sizeof(int64_t); } while (0)                                                  AIT_LEN(__val) = sizeof(int64_t); } while (0)
   #define AIT_SET_F32(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                   __val->val_type = f32; __val->val.f32 = _n; \
                                                   AIT_LEN(__val) = sizeof(float); } while (0)
   #define AIT_SET_F64(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                   __val->val_type = f64; __val->val.f64 = _n; \
                                                   AIT_LEN(__val) = sizeof(double); } while (0)
   
                                           /* if attribute zeroCopy is set not execute free() */
 #define AIT_FREE_VAL(_vl)               do { ait_val_t *__val = (_vl); assert(__val); \  #define AIT_FREE_VAL(_vl)               do { ait_val_t *__val = (_vl); assert(__val); \
                                                switch (AIT_TYPE(__val)) { \                                                switch (__val->val_type) { \
                                                         case buffer: \                                                          case buffer: \
                                                                 if (__val->val.buffer) { \                                                                  if (__val->val.buffer) { \
                                                                         free(__val->val.buffer); \                                                                          free(__val->val.buffer); \
Line 212  typedef struct { Line 219  typedef struct {
                                                                         __val->val.string = NULL; \                                                                          __val->val.string = NULL; \
                                                                 } \                                                                  } \
                                                                 break; \                                                                  break; \
                                                        case array: \                                                        default: \
                                                                io_arrayDestroy(&AIT_GET_ARRAY(__val)); \ 
                                                                 break; \                                                                  break; \
                                                 } \                                                  } \
                                                AIT_TYPE(__val) = empty; \                                                __val->val_type = empty; \
                                                 AIT_LEN(__val) = 0; \                                                  AIT_LEN(__val) = 0; \
                                         } while (0)                                          } while (0)
   
Line 228  inline const char *io_GetError(); Line 234  inline const char *io_GetError();
   
   
 /*  /*
    * io_vals2buffer() Marshaling data from array with variables to buffer
    * @buf = Buffer
    * @buflen = Size of buffer
    * @vars = Variable array
    * return: -1 error, 0 nothing done or >0 size of marshaled data
    */
   int io_vals2buffer(unsigned char *buf, int buflen, array_t *vars);
   /*
    * io_buffer2vals() De-marshaling data from buffer to array with variables
    * @buf = Buffer
    * @buflen = Size of buffer
    * @vnum = Number of variables into buffer
    * @zcpy = Zero-copy for variables, if !=0 don't use io_arrayFree() for free variables and 
                   *DON'T MODIFY OR DESTROY BUFFER*. =0 call io_arrayFree() before io_arrayDestroy()
    * return: =NULL error, !=NULL allocated variable array, after use must free with io_arrayDestroy()
    */
   array_t *io_buffer2vals(unsigned char *buf, int buflen, int vnum, int zcpy);
   
   /*
  * ioPromptRead() Read data from input h[0] with prompt to output h[1]   * ioPromptRead() Read data from input h[0] with prompt to output h[1]
  * @h = file handles h[0] = input, h[1] = output, if NULL use stdin, stdout   * @h = file handles h[0] = input, h[1] = output, if NULL use stdin, stdout
  * @csPrompt = Prompt before input, may be NULL   * @csPrompt = Prompt before input, may be NULL
Line 378  inline int io_arrayLen(array_t * __restrict arr); Line 403  inline int io_arrayLen(array_t * __restrict arr);
  */   */
 int io_arrayConcat(array_t * __restrict dest, array_t * __restrict src);  int io_arrayConcat(array_t * __restrict dest, array_t * __restrict src);
 /*  /*
    * io_arrayCopy() Copy source array to destination array
    * @dest = Destination array, after use free with io_arrayDestroy()
    * @src = Source array
    * return: -1 error; >0 count of destination array
    */
   int io_arrayCopy(array_t ** __restrict dest, array_t * __restrict src);
   /*
  * io_arrayGrow() - Grow/Shrink dynamic array, Use with care when it shrink!!!   * io_arrayGrow() - Grow/Shrink dynamic array, Use with care when it shrink!!!
  * @arr = Array   * @arr = Array
  * @newNumItems = Number of Items   * @newNumItems = Number of Items
    * @freeShrink = Free elements before shrink array
  * return: -1 error, 0 ok   * return: -1 error, 0 ok
  */   */
int io_arrayGrow(array_t * __restrict arr, int newNumItems);int io_arrayGrow(array_t * __restrict arr, int newNumItems, int freeShrink);
 /*  /*
  * io_arrayVacuum() - Vacuum dynamic array, empty elements will be deleted   * io_arrayVacuum() - Vacuum dynamic array, empty elements will be deleted
  * @arr = Array   * @arr = Array
Line 393  int io_arrayGrow(array_t * __restrict arr, int newNumI Line 426  int io_arrayGrow(array_t * __restrict arr, int newNumI
 int io_arrayVacuum(array_t * __restrict arr, int fromWhere);  int io_arrayVacuum(array_t * __restrict arr, int fromWhere);
   
 #define io_arraySize(_arr)              (assert((_arr)), (_arr)->arr_num)  #define io_arraySize(_arr)              (assert((_arr)), (_arr)->arr_num)
   #define io_arrayZero(_arr)              (assert((_arr)), memset((_arr)->arr_data, 0, \
                                                   io_arraySize((_arr)) * sizeof(void*)))
   
 #define io_arrayGet(_arr, _d)           (assert((_arr) && (_arr)->arr_num > _d), *((_arr)->arr_data + _d))  #define io_arrayGet(_arr, _d)           (assert((_arr) && (_arr)->arr_num > _d), *((_arr)->arr_data + _d))
 #define io_array(_arr, _d, _type)       (assert((_arr) && (_arr)->arr_num > _d), \  #define io_array(_arr, _d, _type)       (assert((_arr) && (_arr)->arr_num > _d), \
Line 484  int io_sarrGrow(sarr_t * __restrict arr, int newNumIte Line 519  int io_sarrGrow(sarr_t * __restrict arr, int newNumIte
  */   */
 inline int io_sarrVacuum(sarr_t * __restrict arr);  inline int io_sarrVacuum(sarr_t * __restrict arr);
 #define io_sarrSize(_arr)               (assert((_arr)), (_arr)->sarr_num)  #define io_sarrSize(_arr)               (assert((_arr)), (_arr)->sarr_num)
   #define io_sarrSeg(_arr)                (assert((_arr)), (_arr)->sarr_seg)
   /*
    * io_sarrCopy() Copy source split array to destination split array
    * @dest = Destination split array, after use free with io_sarrDestroy()
    * @src = Source split array
    * return: -1 error; >0 count of destination split array
    */
   int io_sarrCopy(sarr_t ** __restrict dest, sarr_t * __restrict src);
 /*  /*
  * io_sarrGet() - Get element from dynamic split-order array   * io_sarrGet() - Get element from dynamic split-order array
  * @arr = Array   * @arr = Array
Removed from v.1.11.2.1  
changed lines
  Added in v.1.11.2.9

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>