xstddef.h

[詳解]

/*
 * License: MIT license
 * Copyright (c) <2015> <MaskedW [maskedw00@gmail.com]>
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of self software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use, copy,
 * modify, merge, publish, distribute, sublicense, and/or sell copies
 * of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and self permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef picox_core_detail_xstddef_h_
#define picox_core_detail_xstddef_h_


#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */


#define X_COUNT_OF(a)      (sizeof(a) / sizeof(*(a)))


#define X_COUNT_OF_ROW(x) (sizeof(x) / sizeof(x[0]))


#define X_COUNT_OF_COL(x) (sizeof(x[0]) / sizeof(x[0][0]))


#define X_COUNT_OF_2D(x)   (X_COUNT_OF_ROW(x) * X_COUNT_OF_COL(x))


#define X_SIZEOF_MEM(s, m) (sizeof(((s*)0)->m))


#define X_OFFSET_OF(s, m)   ((uintptr_t)&(((s *)0)->m))


#define X_ALIGN_OF(type)   X_OFFSET_OF(struct { char c; type member; }, member)


#if (X_HAS_TYPEOF != 0) && (X_HAS_STATEMENT_EXPRESSIONS != 0)
    #define X_CONTAINER_OF(ptr, type, member)                     \
            ({                                                    \
                const X_TYPEOF(((type*)0)->member)* mptr = (ptr); \
                (type*)((char*)mptr - X_OFFSET_OF(type,member) ); \
            })
#else
    #define X_CONTAINER_OF(ptr, type, member)                     \
            ((type*) ((char*)(ptr) - X_OFFSET_OF(type, member)))
#endif


#define X_STATIC_ASSERT_CAT_(a, b)          a ## b


#define X_STATIC_ASSERT(cond)  \
    enum { X_STATIC_ASSERT_CAT_(X_STATIC_ASSERTION_FAILED, __LINE__) = \
          sizeof( struct { int assertion_failed[(cond) ? 1: -1];})}


#define X_SIZEOF_CHAR       (1)
#define X_SIZEOF_SHORT      (2)

#if UINT_MAX == 0xFF
    #define X_SIZEOF_INT    (1)
#elif UINT_MAX == 0xFFFF
    #define X_SIZEOF_INT    (2)
#elif UINT_MAX == 0xFFFFFFFF
    #define X_SIZEOF_INT    (4)
#elif UINT_MAX == 0xFFFFFFFFFFFFFFFF
    #define X_SIZEOF_INT    (8)
#else
    #error unspported platform
#endif

#if ULONG_MAX == 0xFFFFFFFF
    #define X_SIZEOF_LONG   (4)
#elif ULONG_MAX == 0xFFFFFFFFFFFFFFFF
    #define X_SIZEOF_LONG   (8)
#else
    #error unspported platform
#endif

#if UINTPTR_MAX == 0xFFFF
    #define X_SIZEOF_INTPTR    (2)
#elif UINTPTR_MAX == 0xFFFFFFFF
    #define X_SIZEOF_INTPTR    (4)
#elif UINTPTR_MAX == 0xFFFFFFFFFFFFFFFF
    #define X_SIZEOF_INTPTR    (8)
#else
    #error unspported platform
#endif

#if SIZE_MAX == 0xFFFF
    #define X_SIZEOF_SIZE    (2)
#elif SIZE_MAX == 0xFFFFFFFF
    #define X_SIZEOF_SIZE    (4)
#elif SIZE_MAX == 0xFFFFFFFFFFFFFFFF
    #define X_SIZEOF_SIZE    (8)
#else
    #error unspported platform
#endif


#define X_MSBOF_CHAR     (X_BIT(CHAR_BIT))
#define X_MSBOF_SHORT    (USHORT_MAX  & (~(USHORT_MAX  >> 1)))
#define X_MSBOF_INT      (UINT_MAX    & (~(UINT_MAX    >> 1)))
#define X_MSBOF_LONG     (ULONG_MAX   & (~(ULONG_MAX   >> 1)))
#define X_MSBOF_INTPTR   (UINTPTR_MAX & (~(UINTPTR_MAX >> 1)))
#define X_MSBOF_SIZE     (SIZE_MAX    & (~(SIZE_MAX    >> 1)))
#define X_MSBOF_INT8     (1U << 7)
#define X_MSBOF_INT16    (1U << 15)
#define X_MSBOF_INT32    (X_UINT32_C(1) << 31)


#if X_SIZEOF_INT < 4
    #define X_INT32_C(c)    c ## L
    #define X_UINT32_C(c)   c ## UL
#else
    #define X_INT32_C(c)    c
    #define X_UINT32_C(c)   c
#endif

#if X_SIZEOF_LONG < 8
    #define X_INT64_C(c)    c ## LL
    #define X_UINT64_C(c)   c ## ULL
#else
    #define X_INT64_C(c)    c ## L
    #define X_UINT64_C(c)   c ## UL
#endif

typedef uint32_t XSize;


typedef int32_t XSSize;


typedef int32_t XOffset;


typedef uint32_t XTag;


#define X_MAKE_TAG(a,b,c,d) \
    ( ((uint32_t)(a) << 24) \
    | ((uint32_t)(b) << 16) \
    | ((uint32_t)(c) <<  8) \
    | ((uint32_t)(d) <<  0) )


typedef uint32_t XMode;


typedef uint32_t XBits;


typedef int (*XCompareFunc)(const void* a, const void* b);


typedef void* (*XMallocFunc)(size_t size);


typedef void (*XFreeFunc)(void* ptr);


typedef void (*XDeleter)(void* ptr);


static inline void x_null_deleter(void* ptr)
{
    (void)(ptr);
}


typedef union XMaxAlign
{
    char c; int i; long l; long long ll; void* p;
    float f; double d; long double ld; void(*fp)(void);
} XMaxAlign;


#define X_DEF_MAX_ALIGNED(name, size) \
    XMaxAlign name[((size) + sizeof(XMaxAlign) - 1) / sizeof(XMaxAlign)]


typedef enum
{
    X_SEEK_SET = SEEK_SET,
    X_SEEK_CUR = SEEK_CUR,
    X_SEEK_END = SEEK_END
} XSeekMode;


typedef enum
{
    X_ERR_NONE = 0,             
    X_ERR_IO = 1,               
    X_ERR_INVALID = 2,          
    X_ERR_TIMED_OUT = 3,        
    X_ERR_BUSY = 4,             
    X_ERR_AGAIN = 5,            
    X_ERR_CANCELED = 6,         
    X_ERR_NO_MEMORY = 7,        
    X_ERR_EXIST = 8,            
    X_ERR_NOT_READY = 9,        
    X_ERR_ACCESS = 10,          
    X_ERR_NO_ENTRY = 11,        
    X_ERR_NOT_SUPPORTED = 12,   
    X_ERR_DISCONNECTED = 13,    
    X_ERR_INPROGRESS = 14,      
    X_ERR_PROTOCOL = 15,        
    X_ERR_MANY = 16,            
    X_ERR_RANGE = 17,           
    X_ERR_BROKEN = 18,          
    X_ERR_NAME_TOO_LONG = 19,   
    X_ERR_INVALID_NAME = 20,    
    X_ERR_IS_DIRECTORY = 21,    
    X_ERR_NOT_DIRECTORY = 22,   
    X_ERR_NOT_EMPTY = 23,       
    X_ERR_NO_SPACE = 24,        
    X_ERR_INTERNAL = 25,        
    X_ERR_OTHER = 26,           
    X_ERR_UNKNOWN = 27,         
} XError;


typedef enum
{
    X_OPEN_FLAG_READ = (1 << 0),        
    X_OPEN_FLAG_WRITE = (1 << 1),       
    X_OPEN_FLAG_READ_WRITE = X_OPEN_FLAG_READ | X_OPEN_FLAG_WRITE, 
    X_OPEN_FLAG_APPEND = (1 << 2),      
    X_OPEN_FLAG_TRUNCATE = (1 << 3),    
} XOpenFlag;


typedef enum
{
    X_OPEN_MODE_READ = X_OPEN_FLAG_READ,

    X_OPEN_MODE_WRITE = X_OPEN_FLAG_WRITE | X_OPEN_FLAG_TRUNCATE,

    X_OPEN_MODE_APPEND = X_OPEN_FLAG_WRITE | X_OPEN_FLAG_APPEND,

    X_OPEN_MODE_READ_PLUS = X_OPEN_FLAG_READ_WRITE,


    X_OPEN_MODE_WRITE_PLUS = X_OPEN_FLAG_READ_WRITE | X_OPEN_FLAG_TRUNCATE,


    X_OPEN_MODE_APPEND_PLUS = X_OPEN_FLAG_READ_WRITE | X_OPEN_FLAG_APPEND,
    X_OPEN_MODE_UNKNOWN = 0xFF,
} XOpenMode;


#define X_PATH_MAX (X_CONF_FILE_PATH_MAX)


#define X_NAME_MAX (X_CONF_FILE_NAME_MAX)


#define X_LINE_MAX (X_CONF_LINE_MAX)


#define X_XFS_TYPE  (X_CONF_XFS_TYPE)


#ifdef __cplusplus
}
#endif /* __cplusplus */


#endif /* picox_core_detail_xstddef_h_ */