/* vim: set ts=4 sw=4 tw=99 et:

 *

 * Copyright (C) 2012 David Anderson

 *

 * This file is part of SourcePawn.

 *

 * SourcePawn is free software: you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free

 * Software Foundation, either version 3 of the License, or (at your option)

 * any later version.

 * 

 * SourcePawn is distributed in the hope that it will be useful, but WITHOUT ANY

 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * SourcePawn. If not, see http://www.gnu.org/licenses/.

 */

#ifndef _include_jitcraft_utility_h_

#define _include_jitcraft_utility_h_

#include <assert.h>

#include <stddef.h>

#include "../include/keima_util.h"

#ifdef _MSC_VER

# include <intrin.h>

#endif

#ifdef _MSC_VER

# pragma warning(disable:4355)

#endif

namespace ke {

static const size_t kMallocAlignment = sizeof(void *) * 2;

typedef uint8_t uint8;

typedef int32_t int32;

typedef uint32_t uint32;

typedef uint8 * Address;

static const size_t kKB = 1024;

static const size_t kMB = 1024 * kKB;

static const size_t kGB = 1024 * kMB;

template <typename T>

class AutoVec

{

    T *t_;

  public:

    AutoVec()

      : t_(NULL)

    {

    }

    AutoVec(T *t)

      : t_(t)

    {

    }

    ~AutoVec() {

        delete [] t_;

    }

    operator T *() {

        return t_;

    }

    void operator =(T *t) {

        if (t_)

            delete [] t_;

        t_ = t;

    }

};

// Bob Jenkin's one-at-a-time hash function[1].

//

// [1] http://burtleburtle.net/bob/hash/doobs.html

class CharacterStreamHasher

{

    uint32 hash;

  public:

    CharacterStreamHasher()

      : hash(0)

    { }

    void add(char c) {

        hash += c;

        hash += (hash << 10);

        hash ^= (hash >> 6);

    }

    void add(const char *s, size_t length) {

        for (size_t i = 0; i < length; i++)

            add(s[i]);

    }

    uint32 result() {

        hash += (hash << 3);

        hash ^= (hash >> 11);

        hash += (hash << 15);

        return hash;

    }

};

static inline uint32

HashCharSequence(const char *s, size_t length)

{

    CharacterStreamHasher hasher;

    hasher.add(s, length);

    return hasher.result();

}

static inline size_t

Log2(size_t number)

{

    assert(number != 0);

#ifdef _MSC_VER

    unsigned long rval;

# ifdef _M_IX86

    _BitScanReverse(&rval, number);

# elif _M_X64

    _BitScanReverse64(&rval, number);

# endif

    return rval;

#else

	size_t bit;

	asm("bsr %1, %0\n"

		: "=r" (bit)

		: "rm" (number));

	return bit;

#endif

}

static inline size_t

FindRightmostBit(size_t number)

{

    assert(number != 0);

#ifdef _MSC_VER

    unsigned long rval;

# ifdef _M_IX86

    _BitScanForward(&rval, number);

# elif _M_X64

    _BitScanForward64(&rval, number);

# endif

    return rval;

#else

	size_t bit;

	asm("bsf %1, %0\n"

		: "=r" (bit)

		: "rm" (number));

	return bit;

#endif

}

static inline bool

IsPowerOfTwo(size_t value)

{

    if (value == 0)

        return false;

    return !(value & (value - 1));

}

static inline size_t

Align(size_t count, size_t alignment)

{

    assert(IsPowerOfTwo(alignment));

    return count + (alignment - (count % alignment)) % alignment;

}

static inline bool

IsUint32AddSafe(unsigned a, unsigned b)

{

    if (!a || !b)

        return true;

    size_t log2_a = Log2(a);

    size_t log2_b = Log2(b);

    return (log2_a < sizeof(unsigned) * 8) &&

           (log2_b < sizeof(unsigned) * 8);

}

static inline bool

IsUintPtrAddSafe(size_t a, size_t b)

{

    if (!a || !b)

        return true;

    size_t log2_a = Log2(a);

    size_t log2_b = Log2(b);

    return (log2_a < sizeof(size_t) * 8) &&

           (log2_b < sizeof(size_t) * 8);

}

static inline bool

IsUint32MultiplySafe(unsigned a, unsigned b)

{

    if (a <= 1 || b <= 1)

        return true;

    size_t log2_a = Log2(a);

    size_t log2_b = Log2(b);

    return log2_a + log2_b <= sizeof(unsigned) * 8;

}

static inline bool

IsUintPtrMultiplySafe(size_t a, size_t b)

{

    if (a <= 1 || b <= 1)

        return true;

    size_t log2_a = Log2(a);

    size_t log2_b = Log2(b);

    return log2_a + log2_b <= sizeof(size_t) * 8;

}

#define ARRAY_LENGTH(array) (sizeof(array) / sizeof(array[0]))

#define STATIC_ASSERT(cond) extern int static_assert_f(int a[(cond) ? 1 : -1])

#define IS_ALIGNED(addr, alignment)	(!(uintptr_t(addr) & ((alignment) - 1)))

template <typename T>

static inline bool

IsAligned(T addr, size_t alignment)

{

    assert(IsPowerOfTwo(alignment));

    return !(uintptr_t(addr) & (alignment - 1));

}

static inline Address

AlignedBase(Address addr, size_t alignment)

{

    assert(IsPowerOfTwo(alignment));

    return Address(uintptr_t(addr) & ~(alignment - 1));

}

template <typename T> static inline T

Min(const T &t1, const T &t2)

{

    return t1 < t2 ? t1 : t2;

}

#define OFFSETOF(Class, Member) reinterpret_cast<size_t>(&((Class *)NULL)->Member)

}

#endif // _include_jitcraft_utility_h_