#define __BASE_BITFIELD_HH__
#include <inttypes.h>
-//#include "base/misc.hh"
/**
* Generate a 64-bit mask of 'nbits' 1s, right justified.
return msb;
}
-template<class Data, int first, int last=first>
-class BitfieldBase
+namespace BitfieldBackend
{
- protected:
- uint8_t __data[sizeof(Data)];
-
- //These are defined here so it can be specialized for Data, but can be
- //hidden by RO and WO variants.
- inline uint64_t getBits(int _first, int _last)
- {
- //build up the right bits from the byte array "data"
- //panic("Not yet implemented.\n");
- return 0;
- }
-
- inline void setBits(int _first, int _last, uint64_t val)
- {
- //Set the right bits from the byte array "data"
- //panic("Not yet implemented.\n");
- }
-};
-
-template<class Data, int first, int last=first>
-class BitfieldNativeBase
-{
- protected:
- Data __data;
-
- inline uint64_t getBits(int _first, int _last)
- {
- return bits(__data, first, last);
- }
-
- inline void setBits(int _first, int _last, uint64_t val)
- {
- replaceBits(__data, first, last, val);
- }
-};
-
-template <int first>
-class BitfieldBase<uint64_t, first, first> :
- public BitfieldNativeBase<uint64_t, first, first>
-{};
-
-template <int first, int last>
-class BitfieldBase<uint64_t, first, last> :
- public BitfieldNativeBase<uint64_t, first, last>
-{};
-
-template <int first>
-class BitfieldBase<uint32_t, first, first> :
- public BitfieldNativeBase<uint32_t, first, first>
-{};
-
-template <int first, int last>
-class BitfieldBase<uint32_t, first, last> :
- public BitfieldNativeBase<uint32_t, first, last>
-{};
-
-template <int first>
-class BitfieldBase<uint16_t, first, first> :
- public BitfieldNativeBase<uint16_t, first, first>
-{};
-
-template <int first, int last>
-class BitfieldBase<uint16_t, first, last> :
- public BitfieldNativeBase<uint16_t, first, last>
-{};
-
-template <int first>
-class BitfieldBase<uint8_t, first, first> :
- public BitfieldNativeBase<uint8_t, first, first>
-{};
-
-template <int first, int last>
-class BitfieldBase<uint8_t, first, last> :
- public BitfieldNativeBase<uint8_t, first, last>
-{};
-
-template<class Data, int first, int last=first>
-class _BitfieldRO : public BitfieldBase<Data, first, last>
-{
- public:
- operator const Data & ()
- {
- return this->getBits(first, last);
- }
-};
-
-template<class Data, int first, int last=first>
-class _BitfieldWO : public BitfieldBase<Data, first, last>
-{
- public:
- const Data & operator = (const Data & _data)
- {
- this->setBits(first, last, _data);
- return *this;
- }
-};
-
-template<class Data, int first, int last=first>
-class _BitfieldRW : public BitfieldBase<Data, first, last>
-{
- public:
- operator const Data ()
+ template<class Data>
+ class BitfieldBase
{
- return this->getBits(first, last);
- }
-
- const Data operator = (const Data & _data)
- {
- this->setBits(first, last, _data);
- return *this;
- }
-};
-
-template <class Type, class Base>
-class BitUnionOperators : public Base
-{
- public:
- operator const Type ()
+ protected:
+ Data __data;
+
+ inline uint64_t
+ getBits(int first, int last)
+ {
+ return bits(__data, first, last);
+ }
+
+ inline void
+ setBits(int first, int last, uint64_t val)
+ {
+ replaceBits(__data, first, last, val);
+ }
+ };
+
+ template<class Type, class Base>
+ class _BitfieldRO : public Base
{
- return Base::__data;
- }
-
- const Type operator = (const Type & _data)
+ public:
+ operator const Type ()
+ {
+ return *((Base *)this);
+ }
+ };
+
+ template<class Type, class Base>
+ class _BitfieldWO : public Base
{
- Base::__data = _data;
- }
-
- bool operator < (const Base & base)
+ public:
+ const Type operator = (const Type & _data)
+ {
+ *((Base *)this) = _data;
+ return _data;
+ }
+ };
+
+ template<class Data, int first, int last=first>
+ class _Bitfield : public BitfieldBase<Data>
{
- return Base::__data < base.__data;
- }
-
- bool operator == (const Base & base)
+ public:
+ operator const Data ()
+ {
+ return this->getBits(first, last);
+ }
+
+ const Data
+ operator = (const Data & _data)
+ {
+ this->setBits(first, last, _data);
+ return _data;
+ }
+ };
+
+ template <class Type, class Base>
+ class BitUnionOperators : public Base
{
- return Base::__data == base.__data;
- }
-};
+ public:
+ operator const Type ()
+ {
+ return Base::__data;
+ }
+
+ const Type
+ operator = (const Type & _data)
+ {
+ Base::__data = _data;
+ }
+
+ bool
+ operator < (const Base & base)
+ {
+ return Base::__data < base.__data;
+ }
+
+ bool
+ operator == (const Base & base)
+ {
+ return Base::__data == base.__data;
+ }
+ };
+}
#define __BitUnion(type, name) \
- class __##name { \
+ namespace BitfieldUnderlyingClasses \
+ { \
+ class name; \
+ } \
+ class BitfieldUnderlyingClasses::name { \
public: \
typedef type __DataType; \
union { \
#define EndBitUnion(name) \
}; \
}; \
- typedef BitUnionOperators<__##name::__DataType, __##name> name;
+ typedef BitfieldBackend::BitUnionOperators< \
+ BitfieldUnderlyingClasses::name::__DataType, \
+ BitfieldUnderlyingClasses::name> name;
#define __SubBitUnion(type, name) \
union { \
#define EndSubBitUnion(name) } name;
-//Regular read/write bitfields
-#define BitfieldRW(first, last) _BitfieldRW<__DataType, first, last>
-#define SubBitUnionRW(name, first, last) \
- __SubBitUnion(BitfieldRW(first, last), name)
-#define Bitfield(first, last) BitfieldRW(first, last)
-#define SubBitUnion(name, first, last) SubBitUnionRW(name, first, last)
+//This is so we can send in parameters with commas
+#define wrap(guts) guts
//Read only bitfields
-#define BitfieldRO(first, last) _BitfieldRO<__DataType, first, last>
-#define SubBitUnionRO(name, first, last) \
- __SubBitUnion(BitfieldRO(first, last), name)
+#define __BitfieldRO(base) \
+ BitfieldBackend::_BitfieldRO<__DataType, base>
+#define __SubBitUnionRO(name, base) \
+ __SubBitUnion(wrap(_BitfieldRO<__DataType, base>), name)
//Write only bitfields
-#define BitfieldWO(first, last) _BitfieldWO<__DataType, first, last>
+#define __BitfieldWO(base) \
+ BitfieldBackend::_BitfieldWO<__DataType, base>
+#define __SubBitUnionWO(name, base) \
+ __SubBitUnion(wrap(_BitfieldWO<__DataType, base>), name)
+
+//Regular bitfields
+#define Bitfield(first, last) \
+ BitfieldBackend::_Bitfield<__DataType, first, last>
+#define SubBitUnion(name, first, last) \
+ __SubBitUnion(Bitfield(first, last), name)
+#define BitfieldRO(first, last) __BitfieldRO(Bitfield(first, last))
+#define SubBitUnionRO(name, first, last) \
+ __SubBitUnionRO(Bitfield(first, last), name)
+#define BitfieldWO(first, last) __BitfieldWO(Bitfield(first, last))
#define SubBitUnionWO(name, first, last) \
- __SubBitUnion(BitfieldWO(first, last), name)
+ __SubBitUnionWO(Bitfield(first, last), name)
#define BitUnion(type, name) __BitUnion(type, name)