#include <stdint.h>
typedef uint64_t    uintx_t;

#define UINTX_ZERO(x)        do{ (x) = 0; } while (0)
#define UINTX_STALL(x)        do{ (x) = UINT64_MAX; } while ( 0 ) 
#define UINTX_STI(x, i)        do{ (x) = ((x) | (i)); } while( 0 )
#define UINTX_CLI(x, i)        ((x) &= ~(i))
#define UINTX_MERGE(x, b)    ((x) |= (b))


#define __TBLFN(x)        (x)
static uintx_t    uintx_tbl[64] = {
    __UINTX_SET_U64(__TBLFN)
};

#define UINTX_CHK(x, i)        ((x) & (i))
#define UINTX_POPCNT(x)        _mm_popcnt_u64(x)
struct kbitmap {
    size_t        uxcnt;
    size_t        size;
    uintx_t        bitbuf[];
};

#define KBITMAP_HDRSIZE(size)    (sizeof(struct kbitmap) + kbitmap_xcount(size))

static inline bool kbitmap_init(struct kbitmap* pkb, size_t num_bits){
    assert( NULL != pkb && num_bits > 0 );
    if( NULL == pkb || 0 >= num_bits ){
        return false;
    }
    size_t uxcount = kbitmap_xcount(num_bits);

    for( size_t i = 0; i < uxcount; ++i ){
        UINTX_ZERO( pkb->bitbuf[i] );
    }
    pkb->uxcnt    = uxcount;
    pkb->size    = num_bits;

    return true;
}

static inline void kbitmap_uninit(struct kbitmap* pkb){
    if( NULL != pkb ){
        pkb->uxcnt    = 0;
        pkb->size    = 0;
    }
}

static inline struct kbitmap kbitmap_create(size_t num_bits){
assert( num_bits > 0 );
struct kbitmap pkb = (struct kbitmap*)malloc(KBITMAP_HDRSIZE(num_bits));
if( NULL == pkb ){
return NULL;
}

if( false == kbitmap_init(pkb, num_bits) ){
    free(pkb);
    return NULL;
}

return pkb;

}

static inline void kbitmap_destory(struct kbitmap* pkb){
assert( NULL != pkb );
if( NULL != pkb ){
kbitmap_uninit(pkb);
free(pkb);
}
}

static inline bool kbitmap_cli(struct kbitmap pkb, size_t bitindex){
assert( NULL != pkb ); /清空某一位/
if( NULL == pkb || 0 >= bitindex ){
return false;
}
size_t _slot = (bitindex / (sizeof(uintx_t) CHAR_BIT));
size_t _index = (bitindex % (sizeof(uintx_t) * CHAR_BIT));

printf("slot = [%u], index = [%u]\n", _slot, _index);
UINTX_CLI( pkb->bitbuf[_slot], uintx_tbl[_index]);

return true;

}

static inline bool kbitmap_sti(struct kbitmap pkb, size_t bitindex){
assert( NULL != pkb ); /设置某一位/
if( NULL == pkb || 0 >= bitindex ){
return false;
}
size_t _slot = (bitindex / (sizeof(uintx_t) CHAR_BIT));
size_t _index = (bitindex % (sizeof(uintx_t) * CHAR_BIT));

printf("slot = [%u], index = [%u]\n", _slot, _index);
UINTX_STI( pkb->bitbuf[_slot], uintx_tbl[_index]);

return true;

}
static inline bool kbitmap_get(struct kbitmap pkb, size_t bitindex){
assert( NULL != pkb );
if( NULL == pkb || 0 >= bitindex ){
return false;
}
size_t _slot = (bitindex / (sizeof(uintx_t) CHAR_BIT));
size_t _index = (bitindex % (sizeof(uintx_t) * CHAR_BIT));

printf("slot = [%u], index = [%u]\n", _slot, _index);
if( UINTX_CHK( pkb->bitbuf[_slot], uintx_tbl[_index]) ){
    return true;
}

return false;

}
flexiable array has no error on linux, but on windows' execution is wrong, no error, no output..... test program :

include <kbitmap.h>

int main(){
printf("hello world!\n");
struct kbitmap* pkb = kbitmap_create(1024);

if( false == kbitmap_sti(pkb, 1023) ){
    printf("error: kbitmap_sti 1023\n");
    kbitmap_destory(pkb);
    abort();
}else {
    printf("ok: kbitmap_sti 1023\n");
}
kbitmap_dump(pkb);


if( false == kbitmap_get( pkb, 1023) ){
    printf("error: kbitmap_get 1023\n");
    kbitmap_destory(pkb);
    abort();
}else {
    printf("ok: kbitmap_get 1023\n");
}

if 0

if( true == kbitmap_get( pkb, 1022) ){
    printf("error: kbitmap_get 1022\n");
    kbitmap_destory(pkb);
    abort();
}else {
    printf("ok: kbitmap_get 1022\n");
}

endif

kbitmap_destory(pkb);
return 0;

}