sys.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_impl_sys_h
#define INCL_evo_impl_sys_h

// Compiler detection -- most version integers are calculated as (except where noted): (major * 100) + minor
#if defined(__INTEL_COMPILER)
    // Intel C++ -- version 900 for 9.0, 1700 for 17.0, etc
    #define EVO_COMPILER "Intel"
    #define EVO_INTEL_VER __INTEL_COMPILER
    #define EVO_COMPILER_VER EVO_INTEL_VER
#elif defined(_MSC_VER)
    // MS Visual C++ version as Visual Studio version -- 1503 for Visual Studio 15.3 (2017), 1400 for 14.0 (2015), etc
    #define EVO_COMPILER "MSVC"
    #if _MSC_VER >= 1910
        #define EVO_MSVC_YEAR 2017
        #define EVO_MSVC_TOOLSET 141
        #if _MSC_VER >= 1916
            #define EVO_MSVS_VER 1509
        #elif _MSC_VER >= 1912
            #define EVO_MSVS_VER (1505 + (_MSC_VER - 1912))
        #elif _MSC_VER >= 1911
            #define EVO_MSVS_VER 1503
        #elif _MSC_VER >= 1910
            #define EVO_MSVS_VER 1500
        #endif
    #elif _MSC_VER >= 1900
        #define EVO_MSVC_YEAR 2015
        #define EVO_MSVC_TOOLSET 140
        #define EVO_MSVS_VER 1400
    #elif _MSC_VER >= 1800
        #define EVO_MSVC_YEAR 2013
        #define EVO_MSVC_TOOLSET 120
        #define EVO_MSVS_VER 1200
    #elif _MSC_VER >= 1700
        #define EVO_MSVC_YEAR 2012
        #define EVO_MSVC_TOOLSET 110
        #define EVO_MSVS_VER 1100
    #elif _MSC_VER >= 1600
        #define EVO_MSVC_YEAR 2010
        #define EVO_MSVC_TOOLSET 100
        #define EVO_MSVS_VER 1000
    #elif _MSC_VER >= 1500
        #define EVO_MSVC_YEAR 2008
        #define EVO_MSVC_TOOLSET 90
        #define EVO_MSVS_VER 900
    #elif _MSC_VER >= 1400
        #define EVO_MSVC_YEAR 2005
        #define EVO_MSVC_TOOLSET 80
        #define EVO_MSVS_VER 800
    #elif _MSC_VER >= 1310
        #define EVO_MSVC_YEAR 2003
        #define EVO_MSVC_TOOLSET 71
        #define EVO_MSVS_VER 701
    #elif _MSC_VER >= 1300
        #define EVO_MSVC_YEAR 2002
        #define EVO_MSVC_TOOLSET 70
        #define EVO_MSVS_VER 700
    #else
        #error "This MSVC compiler is too old (before 2002) and not supported by Evo"
    #endif
    #define EVO_COMPILER_VER EVO_MSVS_VER
#elif defined(__clang__)
    #if defined(__APPLE__) || defined(__apple_build_version__)
        #define EVO_COMPILER "Apple clang"
        #define EVO_APPLE_CLANG_VER ((__clang_major__ * 100) + __clang_minor__)
        #define EVO_CLANG_VER    EVO_APPLE_CLANG_VER        // Apple forked clang versions after 3.1, common EVO_CLANG_VER is useful on versions before then
        #define EVO_COMPILER_VER EVO_APPLE_CLANG_VER
        #if EVO_CLANG_VER < 500
            #define EVO_OLDCC
        #endif
    #else
        #define EVO_COMPILER "clang"
        #define EVO_LLVM_CLANG_VER ((__clang_major__ * 100) + __clang_minor__)
        #define EVO_CLANG_VER    EVO_LLVM_CLANG_VER
        #define EVO_COMPILER_VER EVO_LLVM_CLANG_VER
        #if EVO_CLANG_VER < 303
            #define EVO_OLDCC
        #endif
    #endif
    #include <ciso646> // used to identify LLVM libc++
    #if defined(_LIBCPP_VERSION)
        #define EVO_CLANG_LIBCPP _LIBCPP_VERSION
    #else
        #if defined(__GLIBCXX__)
            #define EVO_GLIBCPP __GLIBCXX__
        #endif
    #endif
#elif defined(__GNUC__)
    #define EVO_COMPILER "gcc"
    #define EVO_GCC_VER ((__GNUC__ * 100) + __GNUC_MINOR__)
    #define EVO_COMPILER_VER EVO_GCC_VER
    #if EVO_GCC_VER < 409
        #define EVO_OLDCC
        #if EVO_GCC_VER < 407
            #define EVO_OLDCC2
        #endif
    #endif
    #include <limits.h> // used to identify GNU libc++
    #if defined(__GLIBCXX__)
        #define EVO_GLIBCPP __GLIBCXX__
    #endif        
#elif defined(__CODEGEARC__) && __CODEGEARC__ >= 0x0630     // Not supported before C++ Builder XE
    // C++ Builder -- calculated version (100 for 10, 101 for 10.1, etc) for latest recognized version, XE number for older compiler (1 for XE, 2 for XE2, etc)
    #define EVO_COMPILER "C++ Builder"
    #if __CODEGEARC__ >= 0x0710     // 10.0 - 10.2
        #define EVO_CBUILDER_VER (100 + (((__CODEGEARC__ & 0x0FF0) - 0x0710) / 0x0010))
    #else                           // XE 1-8
        #define EVO_CBUILDER_VER (((__CODEGEARC__ & 0x0FF0) - 0x0620) / 0x0010)
    #endif
    #define EVO_COMPILER_VER EVO_CBUILDER_VER
#elif defined(__BORLANDC__)
    #error "This Borland compiler is too old (before C++ Builder XE) and not supported by Evo"
#else

    #define EVO_COMPILER "Unknown"

    #define EVO_COMPILER_VER 0

    #if defined(DOXYGEN)

        #define EVO_GCC_VER 504

        #define EVO_CLANG_VER 301

        #define EVO_LLVM_CLANG_VER 308

        #define EVO_APPLE_CLANG_VER 901

        #define EVO_MSVC_YEAR 2017

        #define EVO_MSVC_TOOLSET 141
    #endif
#endif

// System includes
#if defined(_WIN32)
    #define _WINSOCKAPI_            // exclude winsock from windows.h
    #if !defined(WIN32_LEAN_AND_MEAN)
        #define WIN32_LEAN_AND_MEAN // minimize windows.h include
    #endif
    #if !defined(_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES)
        #define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1
    #endif
    #if !defined(_CRT_NONSTDC_NO_WARNINGS)
        #define _CRT_NONSTDC_NO_WARNINGS 1
    #endif
    #define NOMINMAX                // disable windows min/max macros

    #include <windows.h>
    #include <malloc.h>
#elif defined(__APPLE__) && defined(__MACH__)
    #include <unistd.h>
    #include <sys/time.h>
#elif defined(__linux) || defined(__unix__) || defined(__CYGWIN__)
    #define _FILE_OFFSET_BITS 64
    #if defined(__linux) && defined(__GLIBC__)
        #define __GNU_SOURCE
    #endif

    #include <unistd.h>
    #include <time.h>
    #include <sys/time.h>
    #if defined(__linux)
        #include <malloc.h>
        #include <stdint.h>
    #else
        #include <stdlib.h>
    #endif
#elif !defined(DOXYGEN)
    #error "This system is not supported by Evo"
#endif

#include <stdlib.h>
#include <stdio.h>
#include <limits>
#include <limits.h>
#include <float.h>
#include <math.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
// Evo Config
#include "../evo_config.h"

// C++ Version
#if __cplusplus >= 201103L || (defined(EVO_MSVC_YEAR) && EVO_MSVC_YEAR >= 2017) || defined(DOXYGEN)

    #define EVO_CPP11
#endif
#if __cplusplus >= 201402L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L) || defined(DOXYGEN)

    #define EVO_CPP14

    #if !defined(EVO_MSVC_YEAR) || EVO_MSVC_YEAR > 2015
        #define EVO_CPP14_FULL // MSVC 2015 has issues, use to detect full C++14 support
    #endif
#endif
#if __cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || defined(DOXYGEN)

    #define EVO_CPP17
#endif

#if defined(EVO_CPP11)

    #define EVO_ONCPP11(EXPR) EXPR

    #define EVO_ONCPP11_ELSE(EXPR1, EXPR2) EXPR1
#else
    #define EVO_ONCPP11(EXPR)
    #define EVO_ONCPP11_ELSE(EXPR1, EXPR2) EXPR2
#endif

#if defined(EVO_CPP14)

    #define EVO_ONCPP14(EXPR) EXPR
#else
    #define EVO_ONCPP14(EXPR)
#endif

#if defined(EVO_CPP14_FULL)

    #define EVO_ONCPP14_FULL(EXPR) EXPR
#else
    #define EVO_ONCPP14_FULL(EXPR)
#endif

#if defined(EVO_CPP17)

    #define EVO_ONCPP17(EXPR) EXPR
#else
    #define EVO_ONCPP17(EXPR)
#endif

// STL Compatibility
#if (EVO_STD_STRING || defined(_BASIC_STRING_H) || defined(_STRING_) || defined(_LIBCPP_STRING) || defined(_GLIBCXX_STRING) || (defined(_MSC_VER) && defined(_XSTRING_))) && EVO_STD_STRING != -1
    #include <string> // std::string
    #define EVO_STD_STRING_ENABLED 1
#endif
#if defined(EVO_CPP17) && (EVO_STD_STRING_VIEW || defined(_LIBCPP_STRING_VIEW) || defined(_GLIBCXX_STRING_VIEW) || (defined(_MSC_VER) && defined(_XSTRING_))) && EVO_STD_STRING_VIEW != -1
    #include <string_view> // std::string_view
    #define EVO_STD_STRING_VIEW_ENABLED 1
#endif

// Exception support
#if defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND) || defined(DOXYGEN)
    #define EVO_EXCEPTIONS_ENABLED 1
#endif

#if defined(EVO_CPP11)
    #define EVO_NOEXCEPT noexcept
#else
    #define EVO_NOEXCEPT throw()
#endif

// 64 bit environment
#if defined(__LP64__) || defined(_LP64) || defined(_WIN64) || defined(DOXYGEN)

    #define EVO_64 1

    #define EVO_ARCH_BITS 64
#else
    #define EVO_32 1
    #define EVO_ARCH_BITS 32
#endif

// SSE optimization, use SSE 4.2 if AVX enabled
#if !defined(EVO_NO_CPU) && !defined(EVO_NO_SSE)
    #if !defined(EVO_NO_SSE42) && ( defined(EVO_USE_SSE42) || defined(__SSE4_2__) || defined(__AVX__) )
        #define EVO_IMPL_SSE42
        #define EVO_CPU "SSE 4.2"
    #elif !defined(EVO_NO_SSE2) && ( defined(EVO_USE_SSE2) || defined(__SSE2__) || defined(__AVX__) )
        #define EVO_IMPL_SSE2
        #define EVO_CPU "SSE 2"
    #elif defined(_MSC_VER) // no MSVC macro for SSE 4.2
        #if !defined(EVO_NO_SSE2) && ( defined(EVO_USE_SSE2) || defined(_M_X64) || (defined(_M_IX86) && _M_IX86_FP == 2) || defined(__AVX__) )
            #define EVO_IMPL_SSE2
            #define EVO_CPU "SSE 2"
        #endif
    #endif
#endif

#if !defined(EVO_CHAR_SIGNED)
    #if defined(EVO_MSVC_YEAR) || defined(DOXYGEN)
        #define EVO_CHAR_SIGNED 1
    #elif (((char)-1) < 0)
        #define EVO_CHAR_SIGNED 1
    #else
        #define EVO_CHAR_SIGNED 0
    #endif
#endif


// Whether to use glibc memmem()
#if !defined(EVO_NO_MEMMEM) && defined(__linux) && defined(__GNU_LIBRARY__) && defined(__GLIBC__) && defined(__GLIBC_MINOR__) && __GNU_LIBRARY__ >= 6 && __GLIBC__ >= 2
    // Requires at least glibc 2.12 -- see: https://bugzilla.redhat.com/show_bug.cgi?id=641128
    #if __GLIBC__ > 2 || __GLIBC_MINOR__ >= 12
        #define EVO_GLIBC_MEMMEM
    #endif
#endif

// Whether to use glibc memrchr()
#if !defined(EVO_NO_MEMRCHR) && defined(__linux) && defined(__GNU_LIBRARY__) && defined(__GLIBC__) && defined(__GLIBC_MINOR__) && __GNU_LIBRARY__ >= 6 && __GLIBC__ >= 2
    // Requires at least glibc 2.2
    #if __GLIBC__ > 2 || __GLIBC_MINOR__ >= 2
        #define EVO_GLIBC_MEMRCHR
    #endif
#endif


// Some macros under Windows cause problems
#if defined(_WIN32)
    #if defined(min)
        #undef min
    #endif
    #if defined(max)
        #undef max
    #endif
#endif

// Used to ignore certain warnings
#if defined(_MSC_VER)
    #define EVO_PARAM_UNUSED(NAME)       __pragma(warning(suppress:4100)) NAME
    #define EVO_MSVC_NOWARN_START(CODES) __pragma(warning(push)) __pragma(warning(disable:CODES))
    #define EVO_MSVC_NOWARN_END          __pragma(warning(pop))
#else

    #define EVO_PARAM_UNUSED(NAME)

    #define EVO_MSVC_NOWARN_START(CODES)

    #define EVO_MSVC_NOWARN_END
#endif

#if defined(__GNUC__)
    #define EVO_ATTRIB_UNUSED __attribute__((unused))
#else

    #define EVO_ATTRIB_UNUSED
#endif


#if defined(EVO_CPP11)
    #define EVO_THREAD_LOCAL thread_local
#elif defined(EVO_MSVC_YEAR)
    #define EVO_THREAD_LOCAL __declspec(thread)
#else
    #define EVO_THREAD_LOCAL __thread
#endif


// Floating point functions
// Windows -- has overloads for all floating point types
#if defined _WIN32
    #define evo_pow pow
    #define evo_modf modf
    #define evo_fabs fabs

// Unix/Linux -- has separate functions for float and long-double
#else
    // Determine whether long double math functions are supported
    #if defined(__CYGWIN__)
        // This indicates a possible precision loss on long-double due to missing math functions
        #define EVO_LDBL_NOMATH
    #endif

    // evo_pow()
    inline float evo_pow(float x, float y)
        { return powf(x, y); }
    inline double evo_pow(double x, double y)
        { return pow(x, y); }
    #if defined EVO_LDBL_NOMATH
        // Use pow() -- possible precision loss
        inline long double evo_pow(long double x, long double y)
            { return pow((double)x, (double)y); }
    #else
        inline long double evo_pow(long double x, long double y)
            { return powl(x, y); }
    #endif

    // evo_modf()
    inline float evo_modf(float x, float* iptr)
        { return modff(x, iptr); }
    inline double evo_modf(double x, double* iptr)
        { return modf(x, iptr); }
    #if defined EVO_LDBL_NOMATH
        // Use modf() -- possible precision loss
        inline long double evo_modf(long double x, long double* iptr)
            { return modf((double)x, (double*)iptr); }
    #else
        inline long double evo_modf(long double x, long double* iptr)
            { return modfl(x, iptr); }
    #endif

    // evo_fabs()
    inline float evo_fabs(float x)
        { return fabsf(x); }
    inline double evo_fabs(double x)
        { return fabs(x); }
    #if defined EVO_LDBL_NOMATH
        inline long double evo_fabs(long double x)
            { return (x<0.0 ? -x : x); }
    #else
        inline long double evo_fabs(long double x)
            { return fabsl(x); }
    #endif

#endif



// Primitive aliases
typedef unsigned char          uchar;   
typedef unsigned short         ushort;  
typedef unsigned long long int ulongl;  
typedef long long int          longl;   
typedef long double            ldouble; 
#if defined(__unix__) || defined(__APPLE__) || defined(DOXYGEN)
    typedef unsigned int  uint;         
    typedef unsigned long ulong;        
#endif

#if defined(_WIN32)
    typedef unsigned int uint;
    typedef unsigned long ulong;
    typedef __int8  int8;
    typedef __int16 int16;
    typedef __int32 int32;
    typedef __int64 int64;
    typedef unsigned __int8  uint8;
    typedef unsigned __int16 uint16;
    typedef unsigned __int32 uint32;
    typedef unsigned __int64 uint64;
#else
    typedef int8_t   int8;      
    typedef int16_t  int16;     
    typedef int32_t  int32;     
    typedef int64_t  int64;     
    typedef uint8_t  uint8;     
    typedef uint16_t uint16;    
    typedef uint32_t uint32;    
    typedef uint64_t uint64;    
#endif

typedef uint16 wchar16;     
typedef uint32 wchar32;     


#define EVO_CNULL ((const char*)0)

#define EVO_VNULL ((void*)0)


// Namespace: evo
namespace evo {


#if defined(_WIN32)

namespace impl {
    // High preceision sleep in 100 nsec units
    inline bool nano100sleep(ulongl nsec100) {
        bool result;
        HANDLE timer = ::CreateWaitableTimer(NULL, TRUE, NULL);
        if (timer == NULL) {
            result = false;
        } else {
            LARGE_INTEGER tm;
            if (nsec100 > (ulongl)std::numeric_limits<LONGLONG>::max())
                tm.QuadPart = std::numeric_limits<LONGLONG>::min();
            else
                tm.QuadPart = -(LONGLONG)nsec100;
            result = (::SetWaitableTimer(timer, &tm, 0, NULL, NULL, FALSE) != 0 && ::WaitForSingleObject(timer, INFINITE) != WAIT_FAILED);
            ::CloseHandle(timer);
        }
        return result;
    }
}
#endif

inline bool sleepms(ulong msec) {
    assert( msec > 0 );
#if defined(_WIN32)
    ::Sleep(msec);
#else
    const ulong MSEC_PER_SEC = 1000;
    const long NSEC_PER_MSEC = 1000000;
    timespec tm;
    tm.tv_sec  = (msec / MSEC_PER_SEC);
    tm.tv_nsec = (long)(msec - (MSEC_PER_SEC * tm.tv_sec)) * NSEC_PER_MSEC;
    while (nanosleep(&tm, &tm) == -1)
        if (errno != EINTR)
            return false;
#endif
    return true;
}

inline bool sleepus(ulongl usec) {
    assert( usec > 0 );
#if defined(_WIN32)
    const ulongl NSEC100_PER_USEC = 10;
    return impl::nano100sleep(usec * NSEC100_PER_USEC);
#else
    const ulongl USEC_PER_SECOND = 1000000;
    const long NSEC_PER_USEC = 1000;
    timespec tm;
    tm.tv_sec  = (usec / USEC_PER_SECOND);
    tm.tv_nsec = (long)(usec - (USEC_PER_SECOND * tm.tv_sec)) * NSEC_PER_USEC;
    while (nanosleep(&tm, &tm) == -1)
        if (errno != EINTR)
            return false;
    return true;
#endif
}

inline bool sleepns(ulongl nsec) {
    assert( nsec > 0 );
#if defined(_WIN32)
    const ulongl NSEC_PER_NSEC100 = 100;
    return impl::nano100sleep(nsec < NSEC_PER_NSEC100 ? 1 : nsec / NSEC_PER_NSEC100);
#else
    const ulongl NSEC_PER_SECOND = 1000000000ULL;
    timespec tm;
    tm.tv_sec  = (nsec / NSEC_PER_SECOND);
    tm.tv_nsec = (long)(nsec - (NSEC_PER_SECOND * tm.tv_sec));
    while (nanosleep(&tm, &tm) == -1)
        if (errno != EINTR)
            return false;
    return true;
#endif
}


typedef EVO_SIZE_TYPE SizeT;

typedef EVO_STR_SIZE_TYPE StrSizeT;


enum Flush { fFLUSH=0 };


enum Newline {  // The order here is important and must align with functions below
    nLF=0,          
    nCR,            
    nCRLF,          
    nLFCR           
};

#if defined(_WIN32)
    // Windows
    static const Newline NL_SYS = nCRLF;
#else
    // Linux/Unix
    static const Newline NL_SYS = nLF;
#endif

struct NewlineDefault {
    operator Newline() const
        { return NL_SYS; }
};

static const NewlineDefault& NL = NewlineDefault();

inline const char* getnewline(Newline newline=NL) {
    const char* NEWLINES[] = { "\n", "\r", "\r\n", "\n\r" };
    return NEWLINES[(int)newline];
}

inline uint getnewlinesize(Newline newline=NL) {
    const uint SIZES[] = { 1, 1, 2, 2 };
    return SIZES[(int)newline];
}

class NewlineValue {
public:
    NewlineValue() : null_(true), nl_(NL_SYS) {
    }

    NewlineValue(Newline nl) : null_(false), nl_(nl) {
    }

    NewlineValue(const NewlineDefault&) : null_(true), nl_(NL_SYS) {
    }

    NewlineValue(const NewlineValue& src) : null_(src.null_), nl_(src.nl_) {
    }

    bool null() {
        return null_;
    }

    NewlineValue& operator=(Newline nl) {
        null_ = false;
        nl_   = nl;
        return *this;
    }

    NewlineValue& operator=(NewlineDefault) {
        null_ = true;
        nl_   = NL_SYS;
        return *this;
    }

    NewlineValue& operator=(const NewlineValue& src) {
        null_ = src.null_;
        nl_   = src.nl_;
        return *this;
    }

    operator Newline() const
        { return nl_; }

    const char* getnewline() const {
        return evo::getnewline(nl_);
    }

    const char* getnewline(uint& size, const char* default_newline, uint default_size) const {
        if (null_) {
            size = default_size;
            return default_newline;
        }
        size = evo::getnewlinesize(nl_);
        return evo::getnewline(nl_);
    }

    uint getnewlinesize() const {
        return evo::getnewlinesize(nl_);
    }

private:
    bool null_;
    Newline nl_;
};


template<class T>
class WorkBuffer {
public:
    WorkBuffer() : buf_(NULL), size_(0)
        { }

    ~WorkBuffer()
        { free(); }

    T* get(ulong size) {
        if (buf_ == NULL) {
            buf_  = (T*)::malloc(size * sizeof(T));
            size_ = size;
        } else if (size > size_) {
            buf_  = (T*)::realloc(buf_, size * sizeof(T));
            size_ = size;
        }
        return buf_;
    }

private:
    // Disable copying
    WorkBuffer(const WorkBuffer&);
    WorkBuffer& operator=(const WorkBuffer&);

    T*    buf_;
    ulong size_;

    void free() {
        if (buf_ != NULL)
            ::free(buf_);
    }
};


template<class T,class TSize=SizeT>
struct ListBase {
    typedef ListBase<T,TSize> ListBaseType;       

    T*    data_;            
    TSize size_;            

    ListBase() {
        data_ = NULL;
        size_ = 0;
    }

    ListBase(const ListBaseType& src) {
        data_ = src.data_;
        size_ = src.size_;
    }

    ListBase(const char* str) {
        if (str == NULL) {
            data_ = NULL;
            size_ = 0;
        } else {
            data_ = (char*)str;
            size_ = (TSize)strlen(str);
        }
    }

    ListBase(const char* str, TSize size) {
        if (size > 0) {
            data_ = (char*)str;
            size_ = size;
        } else {
            data_ = (char*)(str == NULL ? NULL : "");
            size_ = 0;
        }
    }
};

// If enabled, implicitly convert "const std::string&" and "const std::string*" to StringBase (ListBase<char>)
#if EVO_STD_STRING_ENABLED
template<class TSize>
struct ListBase<char,TSize> {
    typedef ListBase<char,TSize> ListBaseType;

    char* data_;
    TSize size_;

    ListBase() {
        data_ = NULL;
        size_ = 0;
    }

    ListBase(const ListBaseType& src) {
        data_ = src.data_;
        size_ = src.size_;
    }

    ListBase(const char* str) {
        if (str == NULL) {
            data_ = NULL;
            size_ = 0;
        } else {
            data_ = (char*)str;
            size_ = (TSize)strlen(str);
        }
    }

    ListBase(const char* str, TSize size) {
        if (size > 0) {
            data_ = (char*)str;
            size_ = size;
        } else {
            data_ = (char*)(str == NULL ? NULL : "");
            size_ = 0;
        }
    }

    ListBase(const std::basic_string<char>& str) {
        size_ = (TSize)str.length();
        data_ = (char*)(size_ > 0 ? str.data() : "");
    }

    ListBase(const std::basic_string<char>* str) {
        if (str == NULL) {
            data_ = NULL;
            size_ = 0;
        } else {
            data_ = (char*)str->data();
            size_ = (TSize)str->length();
        }
    }

#if EVO_STD_STRING_VIEW_ENABLED
    ListBase(const std::basic_string_view<char>& str) {
        size_ = (TSize)str.length();
        data_ = (char*)(size_ > 0 ? str.data() : "");
    }

    ListBase(const std::basic_string_view<char>* str) {
        if (str == NULL) {
            data_ = NULL;
            size_ = 0;
        } else {
            data_ = (char*)str->data();
            size_ = (TSize)str->length();
        }
    }
#endif
};
#endif


struct Null { };

enum ValNull {
    vNULL=0         
};

enum ValEmpty {
    vEMPTY=0        
};

enum ValAlgReverse {
    vREVERSE=0      
};


enum Error {
    // Non-errors first
    ENone = 0,          
    EEnd,               
    EMoreOutput,        
    ENonBlock,          
    // General errors
    EUnknown,           
    ENotImpl,           
    EInvalOp,           
    EInval,             
    EFail,              
    ELoss,              
    ERetry,             
    EBufSize,           
    // More specific errors
    EOutOfBounds,       
    EClosed,            
    ETimeout,           
    ESignal,            
    EPtr,               
    ESpace,             
    EAccess,            
    EExist,             
    ENotFound,          
    ENotDir,            
    ESize,              
    ELimit,             
    ELength,            
    // I/O Errors
    ERead,              
    EWrite,             
    EInput              
    // EInput expected to be last in errormsg()
};

inline const char* errormsg(Error error) {
    const char* msgs[] = {
        // Non-errors first
        "No error (ENone)",
        "End of resource (EEnd)",
        "More pending output to flush (EMoreOutput)",
        "Operation would block (non-blocking I/O) (ENonBlock)",
        // General errors
        "Unknown error (EUnknown)",
        "Function not supported/implemented (ENotImpl)",
        "Invalid or unsupported operation (EInvalOp)",
        "Invalid argument or data (EInval)",
        "Operation failed (EFail)",
        "Aborted to prevent data loss (ELoss)",
        "Temporary failure, try again (ERetry)",
        "Buffer too small (EBufSize)",
        // More specific errors
        "Data out of bounds (EOutOfBounds)",
        "Resource is closed (EClosed)",
        "Operation timed out (ETimeout)",
        "Interrupted by signal (ESignal)",
        "Invalid pointer (EPtr)",
        "Not enough space/memory available (ESpace)",
        "Permission denied (EAccess)",
        "Resource already exists or in use (EExist)",
        "Resource not found (ENotFound)",
        "Path component is not a directory (ENotDir)",
        "Size or resource limit exceeded (ESize)",
        "System resource limit reached (ELimit)",
        "String too long (ELength)",
        // I/O Errors
        "General read error (ERead)",
        "General write error (EWrite)",
        "Truncated or incomplete input (EInput)"
    };
    if (error < 0 || error > EInput)
        return "Bad error code";
    return msgs[(int)error];
}

template<class TOut>
inline TOut& errormsg_out(TOut& out, Error err) {
    out << errormsg(err) << ListBase<char>(" (errno:", 8) << errno << ')';
    return out;
}


class Exception {
public:
    typedef ListBase<char,StrSizeT> StringBase; 

    Exception(const char* file, ulong line, const StringBase& msg, Error error=EUnknown) : file_(file), line_(line), msg_(NULL), error_(error), errormsg_func_(evo::errormsg)
        { init("Exception", msg.data_, msg.size_); }

    Exception(const Exception& e) : file_(e.file_), line_(e.line_), msg_(NULL), error_(e.error_), errormsg_func_(e.errormsg_func_)
        { init(e.msg_, strlen(e.msg_)); }

    ~Exception()
        { if (msg_ != NULL) free(msg_); }

    const char* file() const
        { return file_; }

    ulong line() const
        { return line_; }

    const char* msg() const
        { return (msg_ == NULL) ? "Unexpected Exception" : msg_; }

    Error error() const
        { return error_; }

    template<class TOut>
    TOut& errormsg_out(TOut& out) {
        out << errormsg_func_(error_) << ListBase<char>(" (errno:", 8) << errno << ')';
        return out;
    }

protected:
    typedef const char* (*ErrorMsgFunc)(Error);     

    Exception(const char* file, ulong line, const char* type, const StringBase& msg, Error error, ErrorMsgFunc errmsg_func) : file_(file), line_(line), msg_(NULL), error_(error), errormsg_func_(errmsg_func)
        { init(type, msg.data_, msg.size_); }

private:
    const char*  file_;             
    ulong        line_;             
    char*        msg_;              
    Error        error_;            
    ErrorMsgFunc errormsg_func_;    

    void init(const char* type, const char* msg, size_t len) {
        size_t type_len  = strlen(type);
        size_t total_len = type_len + 2 + len;
        if (total_len > 0) {
            msg_ = (char*)malloc(total_len+1);
            memcpy(msg_, type, type_len);
            memcpy(msg_+type_len, ": ", 2);
            memcpy(msg_+type_len+2, msg, len);
            msg_[total_len] = '\0';
        }
    }

    void init(const char* msg, size_t len) {
        if (len > 0) {
            msg_ = (char*)malloc(len+1);
            memcpy(msg_, msg, len);
            msg_[len] = '\0';
        }
    }
};


#define EVO_CREATE_EXCEPTION_IMPL_2(NAME, BASE, ERRMSG_FUNC) \
    public: \
        using BASE::StringBase; \
        NAME(const char* file, ulong line, const StringBase& msg, Error error=EUnknown) : BASE(file, line, #NAME, msg, error, ERRMSG_FUNC) { } \
        NAME(const NAME& e) : BASE(e) { } \
    protected: \
        NAME(const char* file, ulong line, const char* type, const StringBase& msg, Error error, ErrorMsgFunc errormsg_func) : BASE(file, line, type, msg, error, errormsg_func) { }

#define EVO_CREATE_EXCEPTION_IMPL(NAME, BASE) EVO_CREATE_EXCEPTION_IMPL_2(NAME, BASE, evo::errormsg)

#define EVO_CREATE_EXCEPTION(NAME, BASE) \
    class NAME : public BASE \
        { EVO_CREATE_EXCEPTION_IMPL(NAME, BASE) }

// I/O

class ExceptionStream : public Exception
    { EVO_CREATE_EXCEPTION_IMPL(ExceptionStream, Exception) };

class ExceptionStreamOpen : public ExceptionStream
    { EVO_CREATE_EXCEPTION_IMPL(ExceptionStreamOpen, ExceptionStream) };

class ExceptionStreamIn : public ExceptionStream
    { EVO_CREATE_EXCEPTION_IMPL(ExceptionStreamIn, ExceptionStream) };

class ExceptionStreamOut : public ExceptionStream
    { EVO_CREATE_EXCEPTION_IMPL(ExceptionStreamOut, ExceptionStream) };


class ExceptionFileOpen : public ExceptionStreamOpen
    { EVO_CREATE_EXCEPTION_IMPL(ExceptionFileOpen, ExceptionStreamOpen) };

class ExceptionFileIn : public ExceptionStreamIn
    { EVO_CREATE_EXCEPTION_IMPL(ExceptionFileIn, ExceptionStreamIn) };

class ExceptionFileOut : public ExceptionStreamOut
    { EVO_CREATE_EXCEPTION_IMPL(ExceptionFileOut, ExceptionStreamOut) };


#if defined(EVO_EXCEPTIONS_ENABLED)

    #define EVO_THROW(TYPE, MSG) throw TYPE(__FILE__, __LINE__, MSG)

    #define EVO_THROW_ERR(TYPE, MSG, ERROR) throw TYPE(__FILE__, __LINE__, MSG, ERROR)

    #define EVO_THROW_ERR_CHECK(TYPE, MSG, ERROR, COND) { if (COND) throw TYPE(__FILE__, __LINE__, MSG, ERROR); }
#else
    // Exceptions disabled, use abort()
    #define EVO_THROW(TYPE, MSG) abort()
    #define EVO_THROW_ERR(TYPE, MSG, ERROR) abort()
    #define EVO_THROW_ERR_CHECK(TYPE, MSG, ERROR, COND) { if (COND) abort(); }
#endif


#if !defined(_WIN32)
    // Linux/Unix
    struct SysLinux {
        static void set_timeval_ms(struct timeval& tm, ulong ms) {
            const ulong MSEC_PER_SEC  = 1000;
            const ulong USEC_PER_MSEC = 1000;
            tm.tv_sec  = ms / MSEC_PER_SEC;
            tm.tv_usec = (ms - (tm.tv_sec * MSEC_PER_SEC)) * USEC_PER_MSEC;
        }

        static void set_timespec_tv(struct timespec& tm, struct timeval& tv) {
            const long NSEC_PER_USEC = 1000;
            tm.tv_sec = tv.tv_sec;
            tm.tv_nsec = tv.tv_usec * NSEC_PER_USEC;
        }

        static void set_timespec_ms(struct timespec& tm, ulong ms) {
            const ulong MSEC_PER_SEC  = 1000;
            const ulong NSEC_PER_MSEC = 1000000;
            tm.tv_sec  = ms / MSEC_PER_SEC;
            tm.tv_nsec = (ms - (tm.tv_sec * MSEC_PER_SEC)) * NSEC_PER_MSEC;
        }

        static void add_timespec_ms(struct timespec& tm, ulong ms) {
            const ulong MSEC_PER_SEC  = 1000;
            const ulong NSEC_PER_MSEC = 1000000;
            const long NSEC_PER_SEC   = 1000000000;
            {
                const time_t add_sec = (time_t)(ms / MSEC_PER_SEC);
                tm.tv_sec += add_sec;
                tm.tv_nsec += ((ms - (add_sec * MSEC_PER_SEC)) * NSEC_PER_MSEC);
            }
            const long add_sec = (tm.tv_nsec / NSEC_PER_SEC);
            tm.tv_sec += add_sec;
            tm.tv_nsec -= (add_sec * NSEC_PER_SEC);
        }

        static void set_timespec_now(struct timespec& tm) {
        #if defined(_POSIX_TIMERS) && defined(CLOCK_REALTIME) && !defined(EVO_USE_GETTIMEOFDAY)
            #if defined(CLOCK_MONOTONIC_RAW)
                ::clock_gettime(CLOCK_MONOTONIC_RAW, &tm);
            #elif defined(CLOCK_MONOTONIC)
                ::clock_gettime(CLOCK_MONOTONIC, &tm);
            #else
                ::clock_gettime(CLOCK_REALTIME, &tm);
            #endif
        #else
            struct timeval tv;
            ::gettimeofday(&tv, NULL);
            SysLinux::set_timespec_tv(tm, tv);
        #endif
        }

        static int compare_timespec(const struct timespec& a, const struct timespec& b) {
            if (a.tv_sec < b.tv_sec)
                return -1;
            else if (a.tv_sec > b.tv_sec)
                return 1;
            else if (a.tv_nsec < b.tv_nsec)
                return -1;
            else if (a.tv_nsec > b.tv_nsec)
                return 1;
            return 0;
        }
    };
#endif


template<class T>
inline void swap(T& a, T& b) {
    char tmp[sizeof(T)];
    memcpy(tmp, &a,  sizeof(T));
    memcpy(&a,  &b,  sizeof(T));
    memcpy(&b,  tmp, sizeof(T));
}

}
#endif