core.h

Go to the documentation of this file.

#ifndef VOLK_CORE_H
#define VOLK_CORE_H
 
#ifndef NOCOLOR
#define LOG_USE_COLOR
#endif
 
#include <ctype.h>
#include <dirent.h>
#include <inttypes.h>
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <uuid/uuid.h>
 
#include "log.h"
#include "xxhash.h"
 
 
// Logging and debugging.
 
#ifdef DEBUG
// GDB breakpoints.
#include <signal.h>
#define BREAKPOINT raise (SIGUSR1)
 
#else
#define BREAKPOINT
 
#endif
 
 
#define LIKELY(x)       __builtin_expect(!!(x), true)
#define UNLIKELY(x)     __builtin_expect(!!(x), false)
 
// TODO Cross-platform ramdisk path.
#define TMPDIR "/tmp"


#define VOLK_VERSION "1.0b10"            
 
#define VOLK_NS "info:volksdata:"       
 
#define KLEN sizeof(VOLK_Key)           
#define DBL_KLEN sizeof(VOLK_DoubleKey) 
#define TRP_KLEN sizeof(VOLK_TripleKey) 
#define QUAD_KLEN sizeof(VOLK_QuadKey)  
 
# define UUIDSTR_SIZE 37

#define NULL_TRP {NULL_KEY, NULL_KEY, NULL_KEY}
 
 
/* * * RETURN CODES * * */


typedef int VOLK_rc;

#define VOLK_OK             0

#define VOLK_NOACTION       88801

#define VOLK_NORESULT       88802

#define VOLK_END            88803

#define VOLK_CONFLICT       88804

#define VOLK_ERROR          -88899

#define VOLK_PARSE_ERR      -88898

#define VOLK_VALUE_ERR      -88897

#define VOLK_TXN_ERR        -88896

#define VOLK_DB_ERR         -88895

#define VOLK_NOT_IMPL_ERR   -88894

#define VOLK_IO_ERR         -88893

#define VOLK_MEM_ERR        -88892

#define VOLK_CONFLICT_ERR   -88891

#define VOLK_ENV_ERR        -88890

const char *
VOLK_strerror (VOLK_rc rc);

 

 
#ifndef VOLK_HASH_SEED
#define VOLK_HASH_SEED 0
#endif

#define VOLK_HASH32(buf, size, seed) XXH32 (buf, size, seed)
#define VOLK_HASH64(buf, size, seed) XXH3_64bits_withSeed (buf, size, seed)
#define VOLK_HASH128(buf, size, seed) XXH3_128bits_withSeed (buf, size, seed)
#if INTPTR_MAX == INT64_MAX
#define VOLK_HASH(...) VOLK_HASH64 (__VA_ARGS__)
#else
#define VOLK_HASH(...) VOLK_HASH32 (__VA_ARGS__)
#endif
 
 
extern char *warning_msg[], *error_msg[];
 
extern char *VOLK_root_path;

extern bool VOLK_env_is_init;

typedef XXH32_hash_t VOLK_Hash32;
typedef XXH64_hash_t VOLK_Hash64;
typedef XXH128_hash_t VOLK_Hash128;
#if INTPTR_MAX == INT64_MAX
typedef VOLK_Hash64 VOLK_Hash;
#else
typedef VOLK_Hash32 VOLK_Hash;
#endif

typedef enum {
    VOLK_BOOL_UNION,                
    VOLK_BOOL_SUBTRACTION,          
    VOLK_BOOL_INTERSECTION,         
    VOLK_BOOL_XOR,                  
} VOLK_bool_op;
 

typedef size_t VOLK_Key;
typedef VOLK_Key VOLK_DoubleKey[2];
typedef VOLK_Key VOLK_TripleKey[3];
typedef VOLK_Key VOLK_QuadKey[4];

typedef char uuid_str_t[UUIDSTR_SIZE];

 


 

#define VOLK_MIN_ERROR      VOLK_ERROR

#define VOLK_MAX_ERROR      -88000

#define VOLK_MIN_WARNING    VOLK_NOACTION

#define VOLK_MAX_WARNING    88899
 
 
/*
 * Only compile debug logging in debug mode. Parsing variables for debug and
 * trace messages takes unnecessary cycles for messages that are not displayed
 * in non-debug mode.
 */
#ifndef DEBUG
#undef log_debug
#define log_debug(...) do {} while(0)
#undef log_trace
#define log_trace(...) do {} while(0)
#endif

#define LOG_RC(rc) do {                                             \
    if ((rc) < 0) log_error (VOLK_strerror (rc));                   \
    else if ((rc) > 0) log_warn (VOLK_strerror (rc));              \
} while (0)

#define CHECK(exp, marker) do {                                     \
    VOLK_rc _rc = (exp);                                            \
    LOG_RC(_rc);                                                    \
    if (UNLIKELY (_rc != VOLK_OK)) {                                \
        log_error (                                                 \
                "*** PREMATURE EXIT due to error: %s",              \
                VOLK_strerror (_rc));                               \
        BREAKPOINT;                                                 \
        goto marker;                                                \
    }                                                               \
} while (0)

#define PCHECK(exp, marker) do {                                    \
    VOLK_rc _rc = (exp);                                            \
    if (UNLIKELY (_rc < VOLK_OK)) {                                 \
        log_error (                                                 \
                "*** PREMATURE EXIT due to error: %s",              \
                VOLK_strerror (_rc));                               \
        LOG_RC(_rc);                                                \
        BREAKPOINT;                                                 \
        goto marker;                                                \
    }                                                               \
} while (0)

#define NLCHECK(exp, marker) do {                                   \
    if (UNLIKELY ((exp) == NULL)) {                                 \
        log_error ("*** PREMATURE EXIT due to NULL result.");       \
        BREAKPOINT;                                                 \
        goto marker;                                                \
    }                                                               \
} while (0);

#define RCCK(exp) do {                                              \
    VOLK_rc _rc = (exp);                                            \
    if (UNLIKELY (_rc != VOLK_OK)) {                                \
        log_error (                                                 \
                "*** PREMATURE EXIT due to non-zero exit: %s (%d)", \
                VOLK_strerror (_rc), _rc);                          \
        BREAKPOINT;                                                 \
        return _rc;                                                 \
    }                                                               \
} while (0)

#define PRCCK(exp) do {                                             \
    VOLK_rc _rc = (exp);                                            \
    if (UNLIKELY (_rc < VOLK_OK)) {                                 \
        log_error (                                                 \
                "*** PREMATURE EXIT due to error: %s (%d)",         \
                VOLK_strerror (_rc), _rc);                          \
        BREAKPOINT;                                                 \
        return _rc;                                                 \
    }                                                               \
} while (0)

#define NLRCCK(exp, _rc) do {                                       \
    if (UNLIKELY ((exp) == NULL)) {                                 \
        log_error ("*** PREMATURE EXIT due to NULL result.");       \
        BREAKPOINT;                                                 \
        return _rc;                                                 \
    }                                                               \
} while (0)

#define RCNL(exp) do {                                              \
    VOLK_rc _rc = (exp);                                            \
    if (UNLIKELY (_rc != VOLK_OK)) {                                \
        log_error (                                                 \
                "*** PREMATURE EXIT due to non-zero exit: %s (%d)", \
                VOLK_strerror (_rc), _rc);                          \
        return NULL;                                                \
    }                                                               \
} while (0);

#define PRCNL(exp) do {                                             \
    VOLK_rc _rc = (exp);                                            \
    if (UNLIKELY (_rc < VOLK_OK)) {                                 \
        log_error (                                                 \
                "*** PREMATURE EXIT due to error: %s (%d)",         \
                VOLK_strerror (_rc), _rc);                          \
        return NULL;                                                \
    }                                                               \
} while (0)

#define NLNL(exp) do {                                              \
    if (UNLIKELY ((exp) == NULL)) {                                 \
        log_error ("*** PREMATURE EXIT due to NULL result.");       \
        return NULL;                                                \
    }                                                               \
} while (0)

#define MALLOC_GUARD(var, rc) do {                                  \
    (var) = malloc (sizeof *(var));                                 \
    if (UNLIKELY (var == NULL)) return (rc);                        \
} while (0)

#define CALLOC_GUARD(var, rc) do {                                  \
    (var) = calloc (1, sizeof *(var));                              \
    if (UNLIKELY (var == NULL)) return (rc);                        \
} while (0)
 
/*
#define MALLOC_GUARD_ME(var) MALLOC_GUARD((var), VOLK_MEM_ERR)      \
#define CALLOC_GUARD_ME(var) CALLOC_GUARD((var), VOLK_MEM_ERR)      \
#define MALLOC_GUARD_NL(var) MALLOC_GUARD((var), NULL)              \
#define CALLOC_GUARD_NL(var) CALLOC_GUARD((var), NULL)              \
*/
 



char *strndup (const char *src, size_t max);
 

char *strdup (const char *src);
 

VOLK_rc
mkdir_p (const char *path, mode_t mode);
 

VOLK_rc
rm_r (const char *path);
 

inline int utf8_encode (const uint32_t utf, unsigned char *out)
{
  if (utf <= 0x7F) {
    // Plain ASCII
    out[0] = (char) utf;
    out[1] = 0;
    return 1;
  }
  else if (utf <= 0x07FF) {
    // 2-byte unicode
    out[0] = (char) (((utf >> 6) & 0x1F) | 0xC0);
    out[1] = (char) (((utf >> 0) & 0x3F) | 0x80);
    out[2] = 0;
    return 2;
  }
  else if (utf <= 0xFFFF) {
    // 3-byte unicode
    out[0] = (char) (((utf >> 12) & 0x0F) | 0xE0);
    out[1] = (char) (((utf >>  6) & 0x3F) | 0x80);
    out[2] = (char) (((utf >>  0) & 0x3F) | 0x80);
    out[3] = 0;
    return 3;
  }
  else if (utf <= 0x10FFFF) {
    // 4-byte unicode
    out[0] = (char) (((utf >> 18) & 0x07) | 0xF0);
    out[1] = (char) (((utf >> 12) & 0x3F) | 0x80);
    out[2] = (char) (((utf >>  6) & 0x3F) | 0x80);
    out[3] = (char) (((utf >>  0) & 0x3F) | 0x80);
    out[4] = 0;
    return 4;
  }
  else {
    // error - use replacement character
    out[0] = (char) 0xEF;
    out[1] = (char) 0xBF;
    out[2] = (char) 0xBD;
    out[3] = 0;
    return 0;
  }
}

 
#endif  /* VOLK_CORE_H */