types.h

/*
 *  libFreiburg - src/LibFreiburg/include/msgque/types.h
 *  
 *  (C) 2004 - Freiburg - Project - Group
 *  ------------------------------------------------------
 *  EMail: freiburg AT compiler-factory DOT de
 *  ------------------------------------------------------
 *  all rights reserved
 */

#ifndef MQ_TYPES_H
#define MQ_TYPES_H

/* ####################################################################### */
/* ###                                                                 ### */
/* ###                      M S G Q U E - A P I                        ### */
/* ###                                                                 ### */
/* ####################################################################### */


#define __STDC_VERSION__ 199901L

/* Somewhere in the middle of the GCC 2.96 development cycle, we implemented
   a mechanism by which the user can annotate likely branch directions and
   expect the blocks to be reordered appropriately.  Define __builtin_expect
   to nothing for earlier compilers.  */

#if __GNUC__ == 2 && __GNUC_MINOR__ < 96
#define __builtin_expect(x, expected_value) (x)
#endif

#define likely(x)       __builtin_expect((x),1)

#define unlikely(x)     __builtin_expect((x),0)

#include <limits.h>
#include <float.h>
#include <stdarg.h>
#include <time.h>

//15 min timeout
#ifndef MQ_TIMEOUT

#define MQ_TIMEOUT      900

#define MQ_TIMEOUT5     (MQ_TIMEOUT/5)

#define MQ_TIMEOUT10    (MQ_TIMEOUT/10  < 1 ? 1 : MQ_TIMEOUT/10)

#define MQ_TIMEOUT45    (MQ_TIMEOUT/45  < 1 ? 1 : MQ_TIMEOUT/45)

#define MQ_TIMEOUT180   (MQ_TIMEOUT/180 < 1 ? 1 : MQ_TIMEOUT/180)
#endif

/*****************************************************************************/
/*                                                                           */
/*                        architecture depending types                       */
/*                                                                           */
/*****************************************************************************/

#if defined(DARWIN_7_0_POWERPC)

// system constant __LITTLE_ENDIAN

#define __LITTLE_ENDIAN  LITTLE_ENDIAN
#define __BIG_ENDIAN     BIG_ENDIAN
#define __PDP_ENDIAN     PDP_ENDIAN
#define __BYTE_ORDER     BYTE_ORDER

#define MQ_ARCH "DARWIN_7_0_POWERPC"
#define MQ_SOCKLEN int
#define MQ_IS_POSIX

#elif defined(LINUX_I386)

#define MQ_ARCH "LINUX_I386"

#define MQ_SOCKLEN socklen_t

#define MQ_IS_POSIX

#elif defined(CYGWIN_NT_5_1_I686)

// using MinGW compiler (e.g. cygwin: gcc -no-cygwin)

#define MQ_ARCH "CYGWIN_NT_5_1_I686"
#define MQ_SOCKLEN int
#define MQ_IS_WIN32

#else

#error environment not supported

#endif

/*****************************************************************************/
/*                                                                           */
/*                          windows conform extern                           */
/*                                                                           */
/*****************************************************************************/

#ifdef MQ_IS_STATIC
#   define MQ_EXTERN
#else
#   ifdef MQ_IS_WIN32
#       ifdef MQ_BUILD_DLL
        // the dll exports
#           define MQ_EXTERN __declspec(dllexport)
#       else
        // the exe imports
#           define MQ_EXTERN __declspec(dllimport)
#       endif
#   else

#       define MQ_EXTERN extern
#   endif
#endif

/*****************************************************************************/
/*                                                                           */
/*                            types/definition                               */
/*                                                                           */
/*****************************************************************************/

#define cppxstr(s) cppstr(s)

#define cppstr(s) #s


#if defined(MQ_IS_POSIX)

#define MQ_FS  "/"
#elif defined(MQ_IS_WIN32)
#define MQ_FS  "\\"
#endif

#define MQ_SOCK         MQ_INT4

#define MQ_INT2_MAX     SHRT_MAX

#define MQ_INT2_MIN     SHRT_MIN

#define MQ_INT4_MAX     INT_MAX

#define MQ_INT4_MIN     INT_MIN

#define MQ_INT8_MAX     LLONG_MAX

#define MQ_INT8_MIN     LLONG_MIN

#define MQ_PTR_MAX      (MQ_PTR)0xFFFFFFFF

#define MQ_FLT4_MAX     FLT_MAX

#define MQ_FLT4_MIN     FLT_MIN

#define MQ_FLT8_MAX     DBL_MAX

#define MQ_FLT8_MIN     DBL_MIN

#define MQ_NULL_2          0

#define MQ_NULL_4          0

#define MQ_NULL_8          0LL

#define MQ_NULL_F          0.0F

#define MQ_NULL_D          0.0L

#define MQ_NULL_P          NULL

#define MQ_NULL_C          ""

typedef struct MqReadS *MqReadSP;
typedef struct MqSendS *MqSendSP;
typedef struct MqIoS *MqIoSP;
typedef struct MqTransS *MqTransSP;
typedef struct MqTokenS *MqTokenSP;
typedef struct MqBufferS *MqBufferSP;
typedef struct MqS *MqSP;
typedef struct MqErrorS *MqErrorSP;
typedef struct MqBufferLS *MqBufferLSP;
typedef struct MqStatCtxS *MqStatCtxSP;
typedef struct MqStatS *MqStatSP;
typedef struct ContextS *ContextSP;
typedef union MqOptionU *MqOptionUP;

/*****************************************************************************/
/*                                                                           */
/*                            enum definitions                               */
/*                                                                           */
/*****************************************************************************/

typedef enum {
  MQ_PARENT                     
} MqOpt;

typedef enum {
  MQ_CLIENT,
  MQ_SERVER
} MqE;

typedef enum {
  MQ_SELECT_RECV,               
  MQ_SELECT_SEND                
} MqIoSelectE;

typedef enum {
  MQ_WAIT = (1 << 0),           
  MQ_FOREVER = (1 << 1)         
} MqWaitOnEventE;

typedef enum {
  _MQ_BIN = 'B',                
  _MQ_STR = 'C',                
  _MQ_INT2 = '2',               
  _MQ_INT4 = '4',               
  _MQ_INT8 = '8',               
  _MQ_FLT4 = 'F',               
  _MQ_FLT8 = 'D',               
  _MQ_PTR = 'P',                
  _MQ_LST = 'L',                
  _MQ_RET = 'R',                
  _MQ_STA = 'S'                 
} MqTypeE;

typedef enum {
  MQ_DYNAMIC,                   
  MQ_STATIC                     
} MqAllocE;

typedef enum {
  MQ_OK,                        
  MQ_ERROR,                     
  MQ_WARNING,                   
  MQ_CONTINUE                   
} MqErrorE;

/*****************************************************************************/
/*                                                                           */
/*                            types/LINUX_I386                               */
/*                                                                           */
/*****************************************************************************/

#ifdef LINUX_I386

typedef short int MQ_INT2;
typedef int MQ_INT4;
typedef long long int MQ_INT8;
typedef float MQ_FLT4;
typedef double MQ_FLT8;
typedef long double MQ_FLT12;

typedef MQ_INT4 MQ_SIZE;
typedef unsigned short MQ_UINT2;

typedef void MQ_PTRT;
typedef char MQ_STRT;
typedef unsigned char MQ_BINT;
typedef unsigned char MQ_LSTT;

typedef MQ_PTRT *MQ_PTR;
typedef MQ_STRT *MQ_STR;
typedef MQ_BINT *MQ_BIN;
typedef MQ_LSTT *MQ_LST;

#endif
       /* LINUX_I386 */

/*****************************************************************************/
/*                                                                           */
/*                            types/DARWIN_7_0_POWERPC                       */
/*                                                                           */
/*****************************************************************************/

#ifdef DARWIN_7_0_POWERPC

typedef short int MQ_INT2;
typedef int MQ_INT4;
typedef long long int MQ_INT8;
typedef float MQ_FLT4;
typedef double MQ_FLT8;
typedef double MQ_FLT12;        //Darwin does not support long double
typedef void *MQ_PTR;
typedef char *MQ_STR;
typedef unsigned char *MQ_BIN;
typedef unsigned char *MQ_LST;

typedef int MQ_SIZE;
typedef unsigned short MQ_UINT2;

typedef void MQ_PTRT;
typedef char MQ_STRT;
typedef unsigned char MQ_BINT;
typedef unsigned char MQ_LSTT;

#endif
       /* DARWIN_7_0_POWERPC */

/*****************************************************************************/
/*                                                                           */
/*                            types/CYGWIN_NT_5_1_I686                       */
/*                                                                           */
/*****************************************************************************/

#ifdef CYGWIN_NT_5_1_I686

typedef short int MQ_INT2;
typedef int MQ_INT4;
typedef long long MQ_INT8;
typedef float MQ_FLT4;
typedef double MQ_FLT8;
typedef long double MQ_FLT12;
typedef void *MQ_PTR;
typedef char *MQ_STR;
typedef unsigned char *MQ_BIN;
typedef unsigned char *MQ_LST;

typedef int MQ_SIZE;
typedef unsigned short MQ_UINT2;

typedef void MQ_PTRT;
typedef char MQ_STRT;
typedef unsigned char MQ_BINT;
typedef unsigned char MQ_LSTT;

#endif
       /* CYGWIN_NT_5_1_I686 */

/* ####################################################################### */
/* ###                                                                 ### */
/* ###                    M S G Q U E - A P I                          ### */
/* ###                                                                 ### */
/* ####################################################################### */

/*****************************************************************************/
/*                                                                           */
/*                            msgque/definition                              */
/*                                                                           */
/*****************************************************************************/

typedef MqErrorE (
  *ContextCreateF
) (
  MqBufferLSP,
  ContextSP *
);

typedef void (
  *ContextDeleteF
) (
  ContextSP *
);

typedef MqErrorE (
  *MqTokenF
) (
  MqSP msgque,
  void *data
);

#define MQ_SAVE_ERROR(msgque) ((msgque)&&(msgque)->error?(msgque)->error:NULL)

#ifndef MQ_PRIVATE

typedef struct MqS {

  ContextSP myCtx;              
  MqBufferSP const temp;        
  MqBufferSP name;              

  const MQ_INT2 debug;          
  const MQ_INT2 stat;           
  const MQ_INT2 silent;         
  const MQ_INT2 binary;         

  MqSendSP const send;          
  MqReadSP const read;          
  MqIoSP const io;              
  MqErrorSP const error;        
  MqStatSP statistic;           

} MqS;
#endif
       /* MQ_PRIVATE */

/*****************************************************************************/
/*                                                                           */
/*                               msgque/init                                 */
/*                                                                           */
/*****************************************************************************/

MQ_EXTERN MqErrorE MqCreate (
  ContextSP context,            
  MqBufferLSP argv,             
  MqSP *out                     
);

MQ_EXTERN void MqDelete (
  MqSP *msgqueP                 
);

/*****************************************************************************/
/*                                                                           */
/*                                set/get                                    */
/*                                                                           */
/*****************************************************************************/

MQ_EXTERN MQ_PTR MqGetOpt (
  MqSP const msgque,
  MqOpt opt
);

inline MQ_EXTERN MqTransSP const MqGetTransPtr (
  MqSP const msgque
);

/*****************************************************************************/
/*                                                                           */
/*                                misc                                       */
/*                                                                           */
/*****************************************************************************/

MQ_EXTERN void MqDataLog (
  MqSP msgque,
  const char *prefix
);

MQ_EXTERN inline MqErrorE MqServiceCreate (
  MqSP const msgque,
  MQ_STR token,
  MqTokenF proc,
  MQ_PTR data
);

MQ_EXTERN inline MqErrorE MqServiceDelete (
  MqSP const msgque,
  MQ_STR token
);

/* ####################################################################### */
/* ###                                                                 ### */
/* ###                     E V E N T - A P I                           ### */
/* ###                                                                 ### */
/* ####################################################################### */


typedef void (
  *MqEventF
) (
  ContextSP
);

typedef void (
  *EventCreateF
) (
  ContextSP
);

struct timeval;

MQ_EXTERN MqErrorE MqEventCheck (
  MqSP const msgque,            
  const MqIoSelectE type,       
  struct timeval *timeout,      
  EventCreateF proc             
);

MQ_EXTERN MqErrorE MqProcessEvent (
  MqSP const msgque,            
  const time_t timeout,         
  const MqWaitOnEventE wait     
);

/* ####################################################################### */
/* ###                                                                 ### */
/* ###                     B U F F E R - A P I                         ### */
/* ###                                                                 ### */
/* ####################################################################### */

/*****************************************************************************/
/*                                                                           */
/*                              buffer_init                                  */
/*                                                                           */
/*****************************************************************************/

typedef union MqBufferU {
  MQ_BINT *B;                   
  MQ_STRT *C;                   
  MQ_INT2 *I2;                  
  MQ_INT4 *I4;                  
  MQ_INT8 *I8;                  
  MQ_FLT4 *F;                   
  MQ_FLT8 *D;                   
  MQ_PTR *P;                    
  MQ_LSTT *L;                   
  MQ_LSTT *R;                   
} MqBufferU;

typedef struct MqBufferS {
  MqErrorSP error;              
  MQ_BIN data;                  
  MQ_SIZE size;                 
  MQ_SIZE cursize;              
  MQ_SIZE numItems;             
  MqBufferU cur;                

  MqAllocE alloc;               
  MqTypeE type;                 
} MqBufferS;

MQ_EXTERN MqBufferSP MqBufferCreate (
  MqErrorSP const error,
  const MQ_SIZE size
);

MQ_EXTERN void MqBufferDelete (
  MqBufferSP *bufP
);

MQ_EXTERN void MqBufferDeleteStatic (
  MqBufferSP buf
);

MQ_EXTERN inline void MqBufferReset (
  MqBufferSP buf
);

/*****************************************************************************/
/*                                                                           */
/*                           buffer_create_type                              */
/*                                                                           */
/*****************************************************************************/

MQ_EXTERN inline MqBufferSP MqBufferCreateC (
  MqErrorSP const error,
  const MQ_STR in
);

MQ_EXTERN inline MqBufferSP MqBufferCreate2 (
  MqErrorSP const error,
  const MQ_INT2 in
);

MQ_EXTERN inline MqBufferSP MqBufferCreate4 (
  MqErrorSP const error,
  const MQ_INT4 in
);

MQ_EXTERN inline MqBufferSP MqBufferCreate8 (
  MqErrorSP const error,
  const MQ_INT8 in
);

MQ_EXTERN inline MqBufferSP MqBufferCreateD (
  MqErrorSP const error,
  const MQ_FLT8 in
);

MQ_EXTERN inline MqBufferSP MqBufferCreateP (
  MqErrorSP const error,
  const MQ_PTR in
);

/*****************************************************************************/
/*                                                                           */
/*                              buffer_atom                                  */
/*                                                                           */
/*****************************************************************************/

#define MqBufferInitFromString(str) \
    { NULL, (MQ_BIN) str, strlen(str), strlen(str), 0, {.C str}, MQ_STATIC, _MQ_STR}

MQ_EXTERN void _MqBufferNewSize (
  const char *header,
  MqBufferSP const buf,
  MQ_SIZE newSize
);

#define MqBufferNewSize(buf, newSize) \
    if (unlikely(buf->alloc == MQ_STATIC) || unlikely(newSize > buf->size)) \
        _MqBufferNewSize(__func__, buf, newSize)

#define MqBufferAddSize(buf, addSize) \
    if (unlikely(buf->alloc == MQ_STATIC) || unlikely((buf->cursize + addSize) > buf->size)) \
        _MqBufferNewSize(__func__, buf, (buf->cursize + addSize))

/*****************************************************************************/
/*                                                                           */
/*                              buffer_append                                */
/*                                                                           */
/*****************************************************************************/

MQ_EXTERN MqBufferSP MqBufferCopy (
  MqBufferSP const dest,
  const MqBufferSP srce
);

MQ_EXTERN inline MqBufferSP MqBufferDup (
  const MqBufferSP srce
);

MQ_EXTERN MQ_SIZE MqBufferAppendH (
  MqBufferSP const buf,
  const char character
);

MQ_EXTERN MQ_SIZE MqBufferAppendB (
  MqBufferSP const buf,
  const MQ_BIN binary,
  MQ_SIZE size
);

MQ_EXTERN MQ_SIZE MqBufferAppendC (
  MqBufferSP const buf,
  const MQ_STR string
);

MQ_EXTERN inline MQ_SIZE MqBufferAppendU (
  MqBufferSP const buf,
  const MqBufferSP buffer
);

MQ_EXTERN MQ_SIZE MqBufferAppendVL (
  MqBufferSP const buf,
  const char *format,
  const va_list var_list
);

MQ_EXTERN MQ_SIZE MqBufferAppendV (
  MqBufferSP const buf,
  const char *fmt,
  ...
);

/*****************************************************************************/
/*                                                                           */
/*                              buffer_make                                  */
/*                                                                           */
/*****************************************************************************/

MQ_EXTERN MQ_STR MqBufferGetC (
  MqBufferSP const buf
);

/*****************************************************************************/
/*                                                                           */
/*                              buffer_get                                   */
/*                                                                           */
/*****************************************************************************/

MQ_EXTERN inline MQ_SIZE MqBufferGetLen (
  MqBufferSP const buf
);

MQ_EXTERN char *const MqBufferGetTypeName (
  const MqBufferSP buf
);

MQ_EXTERN void MqBufferLog (
  MqBufferSP const buf,
  const char *prefix
);

/*****************************************************************************/
/*                                                                           */
/*                              buffer_set                                   */
/*                                                                           */
/*****************************************************************************/

MQ_EXTERN MqBufferSP _MqBufferSet (
  MqBufferSP const buf,         
  MQ_PTR const in,              
  const MQ_SIZE size,           
  const MqTypeE type            
);

MQ_EXTERN MqBufferSP MqBufferSetC (
  MqBufferSP const buf,
  const MQ_STR string
);

#define MqBufferSet2(buf,int2) _MqBufferSet(buf,(MQ_PTR const)&int2,sizeof(MQ_INT2),_MQ_INT2)

#define MqBufferSet4(buf,int4) _MqBufferSet(buf,(MQ_PTR const)&int4,sizeof(MQ_INT4),_MQ_INT4)

#define MqBufferSet8(buf,int8) _MqBufferSet(buf,(MQ_PTR const)&int8,sizeof(MQ_INT8),_MQ_INT8)

#define MqBufferSetP(buf,pointer) _MqBufferSet(buf,(MQ_PTR const)&pointer,sizeof(MQ_PTR),_MQ_PTR)

#define MqBufferSetF(buf,flt4) _MqBufferSet(buf,(MQ_PTR const)&flt4,sizeof(MQ_FLT4),_MQ_FLT4)

#define MqBufferSetD(buf,flt8) _MqBufferSet(buf,(MQ_PTR const)&flt8,sizeof(MQ_FLT8),_MQ_FLT8)

MQ_EXTERN MqBufferSP MqBufferSetV (
  MqBufferSP const buf,
  const char *format,
  ...
);

/*****************************************************************************/
/*                                                                           */
/*                              buffer_push                                  */
/*                                                                           */
/*****************************************************************************/

MQ_EXTERN MQ_SIZE MqBufferPush (
  MqBufferSP buf,
  const char *str
);

MQ_EXTERN MQ_SIZE MqBufferPop (
  MqBufferSP buf,
  const char *star
);

/* ####################################################################### */
/* ###                                                                 ### */
/* ###                     E R R O R - A P I                           ### */
/* ###                                                                 ### */
/* ####################################################################### */



MQ_EXTERN void MqPanicVL (
  MqErrorSP const error,
  const char *prefix,
  const MQ_INT4 errnum,
  const char *fmt,
  va_list ap
) __attribute__ ((noreturn));

MQ_EXTERN void MqPanicV (
  MqErrorSP const error,
  const char *prefix,
  const MQ_INT4 errnum,
  const char *fmt,
  ...
) __attribute__ ((noreturn));

#define MqPanicC(error,prefix,errnum,string) MqPanicV(error,prefix,errnum,"%s",string);

#define MqPanicSYS(error) MqPanicV(error,__func__,-1,"%s","internal ERROR, please contact your local support");

inline MQ_EXTERN void MqErrorReset (
  MqErrorSP const error
);

/*****************************************************************************/
/*                                                                           */
/*                            error_init_text                                */
/*                                                                           */
/*****************************************************************************/

MQ_EXTERN MqErrorE MqErrorSGenVL (
  MqErrorSP const error,
  const char *prefix,
  const MqErrorE status,
  const MQ_INT4 errnum,
  const char *fmt,
  va_list ap
);

MQ_EXTERN MqErrorE MqErrorSGenV (
  MqErrorSP const error,
  const char *prefix,
  const MqErrorE status,
  const MQ_INT4 errnum,
  const char *fmt,
  ...
);

#define MqErrorC(error,prefix,errnum,str)           MqErrorSGenV(error,prefix,MQ_ERROR  ,errnum,"%s", str);

#define MqWarningC(error,prefix,str)                MqErrorSGenV(error,prefix,MQ_WARNING,-1,"%s", str);

#define MqErrorV(error,prefix,errnum,fmt,args...)   MqErrorSGenV(error,prefix,MQ_ERROR,errnum,fmt, args);

#define MqWarningV(error,prefix,fmt,args...)        MqErrorSGenV(error,prefix,MQ_WARNING,-1,fmt,args);

/*****************************************************************************/
/*                                                                           */
/*                              error_append                                 */
/*                                                                           */
/*****************************************************************************/

MQ_EXTERN MqErrorE MqErrorSAppendV (
  MqErrorSP const error,
  const char *fmt,
  ...
);

#define MqErrorSAppendC(error,str)        MqErrorSAppendV(error,"%s",str);

#define MQ_ERROR_PROC_FMT "found in procedure \"%s\" at file " cppxstr(__FILE__)

/*****************************************************************************/
/*                                                                           */
/*                              error_append                                 */
/*                                                                           */
/*****************************************************************************/

MQ_EXTERN MqErrorE MqErrorSSend (
  MqErrorSP const error,
  const char *prefix
);

/*****************************************************************************/
/*                                                                           */
/*                              error_set/get                                */
/*                                                                           */
/*****************************************************************************/

inline MQ_EXTERN MqErrorE MqErrorGetStatus (
  MqErrorSP const error
);

inline MQ_EXTERN MQ_STR MqErrorGetString (
  MqErrorSP const error
);

inline MQ_EXTERN MQ_INT2 MqErrorGetNum (
  MqErrorSP const error
);

MQ_EXTERN MqBufferSP const MqErrorGetText (
  MqErrorSP const error
);

MQ_EXTERN inline MqSP MqErrorGetMsgque (
  MqErrorSP const error
);

/*****************************************************************************/
/*                                                                           */
/*                              error_is/check                               */
/*                                                                           */
/*****************************************************************************/

#define MqErrorCheck(PROC) if (unlikely((PROC) == MQ_ERROR)) goto error
#define MqErrorCheck1(PROC) if (unlikely((PROC) == MQ_ERROR)) goto error1
#define MqErrorCheck2(PROC,JUMP) if (unlikely((PROC) == MQ_ERROR)) goto JUMP
#define MqOkCheck(PROC)    if (likely((PROC) == MQ_OK)) goto ok

#define MqErrorCheckNULL(PROC) if (unlikely((PROC) == NULL)) goto error
#define MqErrorCheckNULL1(PROC) if (unlikely((PROC) == NULL)) goto error1

/*****************************************************************************/
/*                                                                           */
/*                              error_misc                                   */
/*                                                                           */
/*****************************************************************************/

MQ_EXTERN void MqErrorLog (
  MqErrorSP const error,
  const char *prefix
);

MQ_EXTERN MqErrorE MqErrorCopy (
  MqErrorSP out,
  MqErrorSP const in
);

#endif /* MQ_TYPES_H */

---