util.h

// Copyright (c) 2014 Yasser Asmi
// Released under the MIT License (http://opensource.org/licenses/MIT)

#ifndef _UTIL_H
#define _UTIL_H

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <memory.h>
#include <errno.h>

#include <string>

#ifndef NDEBUG
    #define _DEBUG

    #define dbglog(fmt, ...) \
        do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)

    #define dbgerr(fmt, ...) \
        do { fprintf(stderr, "Error: %s(%d): " fmt, __FILE__, __LINE__, ## __VA_ARGS__); } while (0)

    #define dbgtrc(fmt, ...) \
        do { if (jvar::enable_dbgtrc) fprintf(stderr, "%s(%d): " fmt, __func__, __LINE__, ## __VA_ARGS__); } while (0)

    #define dbgfnc() \
        do { fprintf(stderr, "%s in %s(%d)\n", __PRETTY_FUNCTION__, __FILE__, __LINE__); } while (0)

namespace jvar
{
    void dbghex(const char* label, const void* ptr, int len);
}

#else
    #undef _DEBUG

    #define dbglog(fmt, ...)

    #define dbgerr(fmt, ...) \
        do { fprintf(stderr, "Error: " fmt, ## __VA_ARGS__); } while (0)

    #define dbgtrc(fmt, ...)

    #define dbgfnc()

    #define dbghex(label, ptr, len)

//namespace jvar
//{
//    void dbghex(const char* label, const void* ptr, int len)
//    {
//    }
//}

#endif

#define isFlagSet(value, flag)         ( ((value) & (flag)) != 0 )
#define isFlagClear(value, flag)       ( ((value) & (flag)) == 0 )
#define setFlag(value, flag)           { (value) |= (flag); }
#define clearFlag(value, flag)         { (value) &= ~(flag); }

#define countof(x)  ((sizeof(x)/sizeof(0[x])) / ((size_t)(!(sizeof(x) % sizeof(0[x])))))


namespace jvar
{

typedef unsigned char uchar;
typedef short int shortint;
typedef unsigned short int ushortint;
typedef unsigned int uint;
typedef long int longint;
typedef unsigned long int ulongint;

extern bool enable_dbgtrc;

class Buffer
{
public:
    Buffer() :
        mMemory(NULL),
        mSize(0)
    {
    }

    ~Buffer()
    {
        free();
    }

    inline void* ptr()
    {
        return mMemory;
    }

    inline const void* cptr()
    {
        return mMemory;
    }

    inline size_t size() const
    {
        return mSize;
    }

    void alloc(size_t size);

    void reAlloc(size_t size);

    void free();

    void copyFrom(Buffer& src);

    void moveFrom(Buffer& src);

    bool readFile(const char* filename, bool nullterm);

private:
    void* mMemory;
    size_t mSize;
};


class InterfaceImpl
{
public:
    virtual ~InterfaceImpl()
    {
    }
    virtual InterfaceImpl* newImpl() = 0;
};

ulongint getTickCount();


} // jvar

#endif // _UTIL_H