regify-util.h

/*
 * Copyright regify
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this 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 this 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 UTIL_REGIFY_UTIL_H
#define UTIL_REGIFY_UTIL_H
 
/* for our error codes only */
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include <stdbool.h>
 
/* Only need to export C interface if used by C++ source code */
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
#if defined(regify_util_EXPORTS)
    #if (defined(WINDOWS) || defined(WIN32) || defined(__BORLANDC__))
        #ifdef RU_BUILDING
            #define RUAPI extern __declspec(dllexport)
        #else
            #define RUAPI extern __declspec(dllimport)
        #endif
    #else
        #if defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 303
            #define RUAPI __attribute__ ((visibility ("default")))
        #else
            #define RUAPI
        #endif
    #endif
#else
    #define RUAPI
#endif
#if defined(WINDOWS) || defined(WIN32) || defined(__BORLANDC__)
    #ifdef _MSC_VER
        // running non posix
        #define RUMS
    #endif
 
    #include <windows.h>
 
    #ifndef int32_t
        typedef int int32_t;
    #endif
    #ifndef int64_t
        typedef long long int64_t;
    #endif
    #ifdef _WIN64
        typedef int64_t rusize_s;
    #else
        typedef int rusize_s;
    #endif
 
    RUAPI int32_t ruGetRegistryEntry(HKEY topKey, const char* tree,
                                     const char* leaf, char** value);
 
    RUAPI int32_t ruGetVolumeInfo(const char* mountPoint,
            unsigned long* serialNo, unsigned long* maxCompLen, unsigned long* fsFlags,
            char** volumeName, char** fsName);
 
#else
 
#if defined(__APPLE__) && defined(__MACH__) // Apple OSX and iOS (Darwin)
#include <TargetConditionals.h>
    #if TARGET_OS_IPHONE == 1
        #ifndef ITS_IOS
            #define ITS_IOS 1
        #endif
    #elif TARGET_OS_MAC == 1
        #ifndef ITS_OSX
            #define ITS_OSX 1
        #endif
    #endif
#endif
 
    /* for folderwalk */
    #include <dirent.h>
 
    typedef signed long rusize_s;
 
#endif
 
#ifdef _WIN32
typedef DWORD ru_pid;
#else
#include <sys/types.h>
typedef pid_t ru_pid;
#endif
 
 
typedef const char* perm_chars;
 
typedef const char* trans_chars;
 
typedef char* alloc_chars;
 
typedef const uint16_t* perm_uni;
 
typedef const uint16_t* trans_uni;
 
typedef uint16_t* alloc_uni;
 
typedef const unsigned char* perm_bytes;
 
typedef const unsigned char* trans_bytes;
 
typedef unsigned char* alloc_bytes;
 
typedef const void* perm_ptr;
 
typedef const void* trans_ptr;
 
typedef void* alloc_ptr;
 
typedef void* ptr;
 
#ifdef __EMSCRIPTEN__
typedef long long sec_t;
#else
typedef long sec_t;
#endif
 
typedef int64_t msec_t;
 
typedef int64_t usec_t;
 
typedef intptr_t ru_int;
 
typedef uintptr_t ru_uint;
 
typedef size_t rusize;
 
typedef void* ruType;
 
#define RU_SIZE_AUTO (~0LU)
 
typedef ptr (*ruClearFunc)(ptr o);
 
typedef void (*ruFreeFunc)(ptr o);
 
typedef struct {
    sec_t sec;
    usec_t usec;
} ruTimeVal;
 
 
typedef struct {
    msec_t start;
    msec_t finish;
    msec_t retry;
} ruTryLoop;
 
RUAPI const char* ruVersion(void);
 
RUAPI const char* ruLastError(void);
 
RUAPI perm_chars ruGetOs(void);
 
RUAPI alloc_chars ruGetHostname(void);
 
RUAPI trans_chars ruGetenv(trans_chars variable);
 
RUAPI ru_pid ruProcessId(void);
 
#define RU_NON_BLOCK (-1)
 
#define RU_NO_TIMEOUT 0
 
RUAPI int32_t ruRunProg(const char **argv, sec_t timeout);
 
RUAPI alloc_chars ruGetLanguage(void);
 
RUAPI unsigned long ruSemiRandomNumber(unsigned long max, long offset);
 
RUAPI int ruVersionComp(trans_chars ver1, trans_chars ver2);
 
RUAPI int32_t ruGetTimeVal(ruTimeVal *result);
 
RUAPI usec_t ruTimeUs(void);
 
RUAPI msec_t ruTimeMs(void);
 
RUAPI sec_t ruTimeSec(void);
 
RUAPI bool ruTimeUsEllapsed(usec_t stamp);
 
RUAPI bool ruTimeMsEllapsed(msec_t stamp);
 
RUAPI bool ruTimeEllapsed(sec_t stamp);
 
RUAPI void ruSleepUs(usec_t microseconds);
 
RUAPI void ruSleepMs(msec_t milliseconds);
 
#define ruSleep(secs) ruSleepMs(((msec_t)(secs))*1000)
 
RUAPI void ruTryLoopInit(ruTryLoop* cycle, msec_t retryMs, msec_t timeoutMs);
 
RUAPI bool ruTryLoopDone(ruTryLoop* cycle);
 
RUAPI sec_t ruTimeParse(trans_chars dateformat, trans_chars datestr);
 
RUAPI sec_t ruUtcParse(trans_chars dateformat, trans_chars datestr);
 
RUAPI int ruTimeFormat(trans_chars format, rusize len, alloc_chars timeStr, sec_t timesecs);
 
RUAPI int ruUtcFormat(trans_chars format, rusize len, alloc_chars timeStr, sec_t timesecs);
 
RUAPI sec_t ruTimeLocalToUtc(sec_t stamp);
 
RUAPI sec_t ruTimeUtcToLocal(sec_t stamp);
 
RUAPI ptr ruCharPtrDup(char* in);
 
 
#define ruMacStart do
#define ruMacEnd while(0)
RUAPI ptr ruClear(ptr o);
 
#define ruFree(p) ruMacStart { if(p) { free((void*)p); p = NULL; } } ruMacEnd
 
#define ruReplace(p, n) ruMacStart { if(p) { free((void*)p); } p = n; } ruMacEnd
 
#define ruRetWithCode(ptr, code, res) ruMacStart { \
    if (ptr) { *ptr = code; } return res; \
    } ruMacEnd
 
typedef void* ruCleaner;
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#include <regify-util/errors.h>
#include <regify-util/logging.h>
#include <regify-util/types.h>
#include <regify-util/list.h>
#include <regify-util/thread.h>
#include <regify-util/string.h>
#include <regify-util/map.h>
#include <regify-util/cleaner.h>
#include <regify-util/ini.h>
#include <regify-util/io.h>
#include <regify-util/json.h>
#include <regify-util/kvstore.h>
#include <regify-util/regex.h>
#include <regify-util/html.h>
#if !defined(__ANDROID__) && defined(__linux__) || defined(ITS_OSX) || defined(_WIN32)
#include <regify-util/fam.h>
#endif
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
#if !defined(__ANDROID__)
#define RU_IP4 0x1
#define RU_IP6 0x2
#define RU_IP (RU_IP4 | RU_IP6)
 
RUAPI ruList ruIpAddrs(int32_t ipfilter);
#endif
 
RUAPI int32_t ruGetOptMap(ruMap* parms, trans_chars opts, int argc, char** argv);
 
#ifdef _WIN32
RUAPI int32_t ruGetOptMapW(ruMap* parms, trans_chars opts, DWORD wargc, LPWSTR* wargv);
#endif
 
RUAPI alloc_ptr ruMallocSize(rusize count, rusize ofsize);
 
#define ruMalloc0(count, ctype) (ctype*) ruMallocSize((rusize)(count), sizeof(ctype));
 
RUAPI alloc_ptr ruReallocSize(alloc_ptr buf, rusize count, rusize ofsize);
 
#define ruRealloc(buf, count, ctype) (ctype*) ruReallocSize(buf, count, sizeof(ctype))
 
RUAPI alloc_ptr ruMemDup(trans_ptr buf, rusize size);
 
/*
 * Some convenience Macros
 */
 
// the ptr < (void*)0xffff is feeble attempt at address validation
#define ruMakeTypeGetter(ctype, magic) \
ctype* ctype ## Get(void* ptr, int32_t* code) { \
    ctype* ret = (ctype*) ptr; \
    if (!ptr) { \
        ruRetWithCode(code, RUE_PARAMETER_NOT_SET, NULL); \
    } \
    if (ptr < (void*)0xffff || magic != ret->type) { \
        ruRetWithCode(code, RUE_INVALID_PARAMETER, NULL); \
    } \
    ruRetWithCode(code, RUE_OK, ret); \
}
 
#define ruZeroedStruct(type, var) type var; \
    memset(&(var), 0, sizeof(type))
 
#define ruMakeTypeGetHeader(ctype) \
ctype* ctype ## Get(void* ptr, int32_t* code)
 
#ifdef __cplusplus
}   /* extern "C" */
#endif /* __cplusplus */
 
#include <regify-util/logging.h>
 
#endif //UTIL_REGIFY_UTIL_H