HRCore.h

Go to the documentation of this file.

 
#pragma once
 
// ============================ Begin User Configure =============================
 
#define HRCORE_DEBUG_LEVEL 2
 
#ifndef HRCORE_HIGHPERF
#define HRCORE_HIGHPERF 0
#endif
 
#ifndef HRCORE_UNIT_SIZE
#define HRCORE_UNIT_SIZE 32
#endif
 
#ifndef HRCORE_ENABLE_IO_DELIMETER
#define HRCORE_ENABLE_IO_DELIMETER 1
#endif
 
#ifndef HRCORE_ENABLE_MD
#define HRCORE_ENABLE_MD 1
#endif
 
#ifndef HRCORE_ENABLE_FP
#define HRCORE_ENABLE_FP 1
#endif
 
#ifndef HRCORE_FP_BITS_BASE
#define HRCORE_FP_BITS_BASE 24
#endif
 
#ifndef HRCORE_FP_BITS_PER_DIGIT
#define HRCORE_FP_BITS_PER_DIGIT 8
#endif
 
#ifndef HRCORE_FP_DEFAULT_PRECISION
#define HRCORE_FP_DEFAULT_PRECISION 10
#endif
 
#ifndef HRCORE_ENABLE_STORAGE_VMMU
#define HRCORE_ENABLE_STORAGE_VMMU 1
#endif
 
#ifndef HRCORE_STORAGE_VMMU_MAX_LEN
#define HRCORE_STORAGE_VMMU_MAX_LEN 1024
#endif
 
#ifndef HRCORE_ENABLE_UTILS
#define HRCORE_ENABLE_UTILS 1
 
#ifndef HRCORE_ENABLE_UTILS_IO
#define HRCORE_ENABLE_UTILS_IO 1
#endif
 
#endif
 
 
// ================================ End User Configure =============================
 
#ifndef __MERGE__ // Define this to avoid preprocessor join STL headers into merged file
#include <algorithm>
#include <iostream>
#include <exception>
#include <cstdint>
 
#include <deque> // For expressions
#include <stack>
#include <complex> // For FFT support in the future
 
#endif
 
// Pre-compile checks
#if HRCORE_DEBUG_LEVEL >= 4
#define HRCORE_DBG(x) x
#else
#define HRCORE_DBG(x)
#endif
 
#if HRCORE_DEBUG_LEVEL >= 3
#define HRCORE_DBGI(x) x
#else
#define HRCORE_DBGI(x)
#endif
 
#if HRCORE_DEBUG_LEVEL >= 2
#define HRCORE_DBGW(x) x
#else
#define HRCORE_DBGW(x)
#endif
 
#if HRCORE_DEBUG_LEVEL >= 1
#define HRCORE_DBGE(x) x
#else
#define HRCORE_DBGE(x)
#endif
 
#if HRCORE_ENABLE_FP
 
#if HRCORE_FP_BITS_BASE < 16
#warning HRCORE_FP_BITS_BASE too small! Float may lose precision.
#endif
 
#if HRCORE_FP_BITS_PER_DIGIT < 6
#warning HRCORE_FP_BITS_PER_DIGIT too small! Float may lose precision.
#endif
 
#endif
 
namespace HRCore {
 
#if (HRCORE_UNIT_SIZE == 16)
using ival_t = uint16_t;
using idval_t = uint32_t;
#define HRCORE_UNIT_DIV 4
#elif (HRCORE_UNIT_SIZE == 32)
using ival_t = uint32_t;
using idval_t = uint64_t;
#define HRCORE_UNIT_DIV 5
#elif (HRCORE_UNIT_SIZE == 64)
using ival_t = uint64_t;
using idval_t = __uint128_t; // Only support with GCC
#define HRCORE_UNIT_DIV 6
#else
#error Invalid Unit Size (i.e. macro HRCORE_UNIT_SIZE) provided!
#endif
 
using complex_t = std::complex<float>;
 
namespace Exception {
 
#ifndef __HRCORE_EXCEPTION_HELPER__
#define __HRCORE_EXCEPTION_HELPER__(w)            \
    : public std::exception                       \
    {                                             \
    public:                                       \
        const char* what() const throw() override \
        {                                         \
            return w;                             \
        }                                         \
    }
#endif
 
    class InternalError __HRCORE_EXCEPTION_HELPER__("HRCore internal error"); 
    class LLR __HRCORE_EXCEPTION_HELPER__("Left operator argument is not bigger than right"); 
    class InvalidArgument __HRCORE_EXCEPTION_HELPER__("Invalid argument provided"); 
    class DividedByZero __HRCORE_EXCEPTION_HELPER__("Devided by 0 is not allowed"); 
 
#if HRCORE_ENABLE_FP
                                                                                    // class FPAdjustFailed __HRCORE_EXCEPTION_HELPER__("FixedPoint adjust point failed"); ///< @brief Exception of FixedPoint adjust point failed
    class FPConvertFailed __HRCORE_EXCEPTION_HELPER__("FixedPoint failed to convert"); 
#endif
 
#if HRCORE_ENABLE_UTILS_IO
    class ExpressionConvertFailed __HRCORE_EXCEPTION_HELPER__("Expression Failed to convert! Maybe the expression is invalid?");
    class ExpressionInvalidOperation __HRCORE_EXCEPTION_HELPER__("Invalid operation on seleted data type");
#endif
 
} // namespace Exception
}
 
#include "inc/StorageIF.hpp"
#include "inc/VirtualMMU.hpp"
#include "inc/LinkedList.hpp"
#include "inc/Value.hpp"
#include "inc/Utils.hpp"
 
namespace HRCore {
using BINT = Value::Integer;
 
#if HRCORE_ENABLE_FP
using BFLOAT = Value::Float;
#endif
 
#if HRCORE_ENABLE_UTILS_IO
template <typename T, typename U>
using BEXP = Utils::Expression<T, U>;
#endif
 
} // namespace HRCore