[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 and 1.11.2.3

version 1.11, 2011/08/29 12:00:57 version 1.11.2.3, 2011/08/29 23:10:51
Line 54  SUCH DAMAGE. Line 54  SUCH DAMAGE.
 #define VACUUM_LEFT     1  #define VACUUM_LEFT     1
 #define VACUUM_BETWEEN  2  #define VACUUM_BETWEEN  2
   
   /* AIT arrays */
   
 typedef void ** sarr_seg_t;  typedef void ** sarr_seg_t;
 typedef struct _tagSplitArray {  typedef struct _tagSplitArray {
Line 68  typedef struct _tagArray { Line 69  typedef struct _tagArray {
         void    **arr_data;          void    **arr_data;
 } array_t;  } array_t;
   
   /* URL staff ... */
   
 typedef struct _tagURLItem {  typedef struct _tagURLItem {
         int     vallen;          int     vallen;
         char    *value;          char    *value;
Line 99  struct tagReqXML { Line 102  struct tagReqXML {
         url_Item_t      xml_attribute;          url_Item_t      xml_attribute;
         url_Item_t      xml_value;          url_Item_t      xml_value;
 };  };
   
   /* AIT RPC variables and managment */
   
   typedef enum {
           empty,                          /* empty -> variable is not set */
           buffer, string, blob, array,    /* buffer -> uint8_t*; string -> int8_t*; 
                                                   blob -> void*(+socket); array -> array_t* */
           u8, u16, u32, u64,              /* unsigned integers ... */
           i8, i16, i32, i64               /* integers ... */
   } ait_type_t;
   
   typedef struct {
           uint8_t         val_type;
           uint32_t        val_len;
           union {
                   uint8_t         *buffer,
                                   *array;
                   int8_t          *string;
                   uint32_t        blob;
                   uint8_t         u8;
                   uint16_t        u16;
                   uint32_t        u32;
                   uint64_t        u64;
                   int8_t          i8;
                   int16_t         i16;
                   int32_t         i32;
                   int64_t         i64;
           } val;
   } __packed ait_val_t;
   
   #define AIT_TYPE(_vl)                   ((ait_type_t) (_vl)->val_type)
   #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_ISEMPTY(_vl)                (assert((_vl)), (_vl)->val_type == empty)
   
   #define AIT_GET_ARRAY(_vl)              (assert((_vl)), assert((_vl)->val_type == array), \
                                                   ((array_t*) (_vl)->val.array))
   #define AIT_GET_BUF(_vl)                (assert((_vl)), assert((_vl)->val_type == buffer), (_vl)->val.buffer)
   #define AIT_GET_STR(_vl)                (assert((_vl)), assert((_vl)->val_type == string), (_vl)->val.string)
   #define AIT_GET_BLOB(_vl)               (assert((_vl)), assert((_vl)->val_type == blob), (_vl)->val.blob)
   #define AIT_GET_U8(_vl)                 (assert((_vl)), assert((_vl)->val_type == u8), (_vl)->val.u8)
   #define AIT_GET_U16(_vl)                (assert((_vl)), assert((_vl)->val_type == u16), (_vl)->val.u16)
   #define AIT_GET_U32(_vl)                (assert((_vl)), assert((_vl)->val_type == u32), (_vl)->val.u32)
   #define AIT_GET_U64(_vl)                (assert((_vl)), assert((_vl)->val_type == u64), (_vl)->val.u64)
   #define AIT_GET_I8(_vl)                 (assert((_vl)), assert((_vl)->val_type == i8), (_vl)->val.i8)
   #define AIT_GET_I16(_vl)                (assert((_vl)), assert((_vl)->val_type == i16), (_vl)->val.i16)
   #define AIT_GET_I32(_vl)                (assert((_vl)), assert((_vl)->val_type == i32), (_vl)->val.i32)
   #define AIT_GET_I64(_vl)                (assert((_vl)), assert((_vl)->val_type == i64), (_vl)->val.i64)
   
   #define AIT_SET_BUF(_vl, _v, _len)      do { ait_val_t *__val = (_vl); assert(__val); assert((_v)); \
                                                   __val->val.buffer = malloc(_len); \
                                                   if (__val->val.buffer) { \
                                                           __val->val_type = buffer; AIT_LEN(__val) = _len; \
                                                           memcpy(__val->val.buffer, (_v), _len); \
                                                   } } while (0)
   #define AIT_SET_STR(_vl, _v)            do { ait_val_t *__val = (_vl); assert(__val); assert((_v)); \
                                                   __val->val.string = (int8_t*) strdup((_v)); \
                                                   if (__val->val.string) { \
                                                           __val->val_type = string; \
                                                           AIT_LEN(__val) = strlen((_v)) + 1; \
                                                   } } while (0)
   #define AIT_SET_BLOB(_vl, _n, _len)     do { ait_val_t *__val = (_vl); assert(__val); \
                                                   __val->val_type = blob; AIT_LEN(__val) = _len; \
                                                   __val->val.blob = _n; } while (0)
   #define AIT_SET_BLOB2(_vl, _bv)         do { ait_val_t *__val = (_vl); assert(__val); assert((_bv)); \
                                                   __val->val_type = blob; AIT_LEN(__val) = (_bv)->blob_len; \
                                                   __val->val.blob = (_bv)->blob_var; } while (0)
   #define AIT_SET_ARRAY(_vl, _arr)        do { ait_val_t *__val = (_vl); assert(__val); assert((_arr)); \
                                                   __val->val_type = array; AIT_LEN(__val) = io_arraySize((_arr)); \
                                                   __val->val.array = (uint8_t*) (_arr); \
                                           } while (0)
   
   #define AIT_SET_U8(_vl, _n)             do { ait_val_t *__val = (_vl); assert(__val); \
                                                   __val->val_type = u8; __val->val.u8 = _n; \
                                                   AIT_LEN(__val) = sizeof(uint8_t); } while (0)
   #define AIT_SET_U16(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                   __val->val_type = u16; __val->val.u16 = _n; \
                                                   AIT_LEN(__val) = sizeof(uint16_t); } while (0)
   #define AIT_SET_U32(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                   __val->val_type = u32; __val->val.u32 = _n; \
                                                   AIT_LEN(__val) = sizeof(uint32_t); } while (0)
   #define AIT_SET_U64(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                   __val->val_type = u64; __val->val.u64 = _n; \
                                                   AIT_LEN(__val) = sizeof(uint64_t); } while (0)
   #define AIT_SET_I8(_vl, _n)             do { ait_val_t *__val = (_vl); assert(__val); \
                                                   __val->val_type = i8; __val->val.i8 = _n; \
                                                   AIT_LEN(__val) = sizeof(int8_t); } while (0)
   #define AIT_SET_I16(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                   __val->val_type = i16; __val->val.i16 = _n; \
                                                   AIT_LEN(__val) = sizeof(int16_t); } while (0)
   #define AIT_SET_I32(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                   __val->val_type = i32; __val->val.i32 = _n; \
                                                   AIT_LEN(__val) = sizeof(int32_t); } while (0)
   #define AIT_SET_I64(_vl, _n)            do { ait_val_t *__val = (_vl); assert(__val); \
                                                   __val->val_type = i64; __val->val.i64 = _n; \
                                                   AIT_LEN(__val) = sizeof(int64_t); } while (0)
   
   #define AIT_FREE_VAL(_vl)               do { ait_val_t *__val = (_vl); assert(__val); \
                                                   switch (__val->val_type) { \
                                                           case buffer: \
                                                                   if (__val->val.buffer) { \
                                                                           free(__val->val.buffer); \
                                                                           __val->val.buffer = NULL; \
                                                                   } \
                                                                   break; \
                                                           case string: \
                                                                   if (__val->val.string) { \
                                                                           free(__val->val.string); \
                                                                           __val->val.string = NULL; \
                                                                   } \
                                                                   break; \
                                                           default: \
                                                                   break; \
                                                   } \
                                                   __val->val_type = empty; \
                                                   AIT_LEN(__val) = 0; \
                                           } while (0)
   
   
 // io_GetErrno() Get error code of last operation  // io_GetErrno() Get error code of last operation
Removed from v.1.11  
changed lines
  Added in v.1.11.2.3

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