The Road to Clang-Format part 1
Whitespace: The Darkening
Change-Id: I9c0c355ddf22f9b27763c97e3e85079c135ae7a7
Signed-off-by: Zane Shelley <zshelle@us.ibm.com>
diff --git a/src/chip_data/hei_chip_data.hpp b/src/chip_data/hei_chip_data.hpp
index 0e8bbc2..685ed12 100644
--- a/src/chip_data/hei_chip_data.hpp
+++ b/src/chip_data/hei_chip_data.hpp
@@ -5,4 +5,4 @@
namespace libhei
{
-} //end namespace libhei
+} // end namespace libhei
diff --git a/src/chip_data/hei_chip_data_stream.hpp b/src/chip_data/hei_chip_data_stream.hpp
index 6d4d303..25b8635 100755
--- a/src/chip_data/hei_chip_data_stream.hpp
+++ b/src/chip_data/hei_chip_data_stream.hpp
@@ -4,7 +4,8 @@
@file hei_chip_data_stream.hpp
@brief Description: The ChipDataStream class
-ChipDataStream makes it possible to read a buffer of binary data using the stream operators, ">>".
+ChipDataStream makes it possible to read a buffer of binary data using the
+stream operators, ">>".
Instantiate ChipDataStream class with a pointer to a data buffer
and its size in bytes as below:
@@ -26,154 +27,155 @@
{
/**
-* ChipDataStream
-* ChipDataStream offers convenient stream operator access to binary data.
-**/
+ * ChipDataStream
+ * ChipDataStream offers convenient stream operator access to binary data.
+ **/
class ChipDataStream
{
private:
- /** iv_buffer points to the first address of the Chip Data File
- buffer. **/
- const void * const iv_buffer;
- /** iv_bufferSize is the size of the data buffer. It is
- initialized when the ChipDataStream class is instantiated. **/
- const size_t iv_bufferSize;
- /** iv_asyncOffset keeps an offset into the buffer. This
- offset is incremented appropriately as data is read. **/
- size_t iv_asyncOffset;
+ /** iv_buffer points to the first address of the Chip Data File
+ buffer. **/
+ const void * const iv_buffer;
+ /** iv_bufferSize is the size of the data buffer. It is
+ initialized when the ChipDataStream class is instantiated. **/
+ const size_t iv_bufferSize;
+ /** iv_asyncOffset keeps an offset into the buffer. This
+ offset is incremented appropriately as data is read. **/
+ size_t iv_asyncOffset;
public:
- /* Constructors */
+ /* Constructors */
- /**
- When instantiating the ChipDataStream object a pointer to a
- data buffer containing all the data and its size is passed
- into the class.
- **/
- ChipDataStream(void * i_buffer, size_t i_bufferSize) :
- iv_asyncOffset(0), iv_buffer(i_buffer), iv_bufferSize(i_bufferSize) {}
+ /**
+ When instantiating the ChipDataStream object a pointer to a
+ data buffer containing all the data and its size is passed
+ into the class.
+ **/
+ ChipDataStream(void * i_buffer, size_t i_bufferSize) :
+ iv_asyncOffset(0), iv_buffer(i_buffer), iv_bufferSize(i_bufferSize)
+ {}
- /** Eliminate copy and assignment operator constructors **/
- ChipDataStream ( const ChipDataStream & ) = delete;
- ChipDataStream & operator=( const ChipDataStream & ) = delete;
+ /** Eliminate copy and assignment operator constructors **/
+ ChipDataStream(const ChipDataStream &) = delete;
+ ChipDataStream & operator=(const ChipDataStream &) = delete;
- /** Destructor **/
+ /** Destructor **/
- ~ChipDataStream() = default;
+ ~ChipDataStream() = default;
- /** Functions **/
+ /** Functions **/
- /**
- *@brief Default case for "operator>>" template.
- *@param D: A type
- *@param o_right: A pointer to where the data is stored
- *@return *this: A pointer to "this" object
- **/
- template <class D>
- ChipDataStream & operator>>( D & o_right )
- {
- read( &o_right, sizeof(D) );
- return *this;
- }
+ /**
+ *@brief Default case for "operator>>" template.
+ *@param D: A type
+ *@param o_right: A pointer to where the data is stored
+ *@return *this: A pointer to "this" object
+ **/
+ template <class D>
+ ChipDataStream & operator>>(D & o_right)
+ {
+ read(&o_right, sizeof(D));
+ return *this;
+ }
private:
- /**
- *@brief Read does the copy from the buffer
- *@param o_buf a pointer to the location to copy to
- *@param i_size the size (in bytes) to copy
- *@return None\n\n
- **/
- void read( void * o_buf, size_t i_size )
- {
- /* Ensure memory is not accessed outside i_buffer */
- HEI_ASSERT((iv_asyncOffset + i_size) <= iv_bufferSize);
- /* Copy appropriate bytes from i_buffer to o_buff */
- memcpy(o_buf,(char *)iv_buffer+iv_asyncOffset,i_size);
- /* Increment asynchronous offset to next piece of data */
- iv_asyncOffset = iv_asyncOffset + i_size;
- }
+ /**
+ *@brief Read does the copy from the buffer
+ *@param o_buf a pointer to the location to copy to
+ *@param i_size the size (in bytes) to copy
+ *@return None\n\n
+ **/
+ void read(void * o_buf, size_t i_size)
+ {
+ /* Ensure memory is not accessed outside i_buffer */
+ HEI_ASSERT((iv_asyncOffset + i_size) <= iv_bufferSize);
+ /* Copy appropriate bytes from i_buffer to o_buff */
+ memcpy(o_buf, (char *)iv_buffer + iv_asyncOffset, i_size);
+ /* Increment asynchronous offset to next piece of data */
+ iv_asyncOffset = iv_asyncOffset + i_size;
+ }
};
/*
-* Note: The specializations below ensure the big-endian Chip Data File
-* format is converted into the host format.
-*/
+ * Note: The specializations below ensure the big-endian Chip Data File
+ * format is converted into the host format.
+ */
/**
-* @brief This template extracts a uint16_t data type from the data buffer
-* @param o_right: A pointer to where the data is stored
-* @return *this: A pointer to "this" object
-**/
+ * @brief This template extracts a uint16_t data type from the data buffer
+ * @param o_right: A pointer to where the data is stored
+ * @return *this: A pointer to "this" object
+ **/
template <> inline
- ChipDataStream & ChipDataStream::operator>>( uint16_t & o_right )
- {
- read( &o_right, sizeof(o_right));
- be16toh( o_right );
- return *this;
- }
+ChipDataStream & ChipDataStream::operator>>(uint16_t & o_right)
+{
+ read(&o_right, sizeof(o_right));
+ be16toh(o_right);
+ return *this;
+}
/**@brief This template extracts an int16_t type from the data buffer
-* @param o_right: A pointer to where the data is stored
-* @return *this: A pointer to "this" object
-**/
+ * @param o_right: A pointer to where the data is stored
+ * @return *this: A pointer to "this" object
+ **/
template <> inline
- ChipDataStream & ChipDataStream::operator>>( int16_t & o_right )
- {
- read( &o_right, sizeof(o_right) );
- be16toh( o_right );
- return *this;
- }
+ChipDataStream & ChipDataStream::operator>>(int16_t & o_right)
+{
+ read(&o_right, sizeof(o_right));
+ be16toh(o_right);
+ return *this;
+}
/**@brief This template extracts a uint32_t type from the data buffer
-* @param o_right: A pointer to where the data is stored
-* @return *this: A pointer to "this" object
-**/
+ * @param o_right: A pointer to where the data is stored
+ * @return *this: A pointer to "this" object
+ **/
template <> inline
- ChipDataStream & ChipDataStream::operator>>( uint32_t & o_right )
- {
- read( &o_right, sizeof(o_right) );
- be32toh( o_right );
- return *this;
- }
+ChipDataStream & ChipDataStream::operator>>(uint32_t & o_right)
+{
+ read(&o_right, sizeof(o_right));
+ be32toh(o_right);
+ return *this;
+}
/**@brief This template extracts an int32_t type from the data buffer
-* @param o_right: A pointer to where the data is stored
-* @return *this: A pointer to "this" object
-**/
+ * @param o_right: A pointer to where the data is stored
+ * @return *this: A pointer to "this" object
+ **/
template <> inline
- ChipDataStream & ChipDataStream::operator>>( int32_t & o_right )
- {
- read( &o_right, sizeof(o_right) );
- be32toh( o_right );
- return *this;
- }
+ChipDataStream & ChipDataStream::operator>>(int32_t & o_right)
+{
+ read(&o_right, sizeof(o_right));
+ be32toh(o_right);
+ return *this;
+}
/**@brief This template extracts a uint64_t type from the data buffer
-* @param o_right: A pointer to where the data is stored
-* @return *this: A pointer to "this" object
-**/
+ * @param o_right: A pointer to where the data is stored
+ * @return *this: A pointer to "this" object
+ **/
template <> inline
- ChipDataStream & ChipDataStream::operator>>( uint64_t & o_right )
- {
- read( &o_right, sizeof(o_right) );
- be64toh( o_right );
- return *this;
- }
+ChipDataStream & ChipDataStream::operator>>(uint64_t & o_right)
+{
+ read(&o_right, sizeof(o_right));
+ be64toh(o_right);
+ return *this;
+}
/**@brief This template extracts an int64_t type from the data buffer
-* @param o_right: A pointer to where the data is stored
-* @return *this: A pointer to "this" object
-**/
+ * @param o_right: A pointer to where the data is stored
+ * @return *this: A pointer to "this" object
+ **/
template <> inline
- ChipDataStream & ChipDataStream::operator>>( int64_t & o_right )
- {
- read( &o_right, sizeof(o_right) );
- be64toh( o_right );
- return *this;
- }
+ChipDataStream & ChipDataStream::operator>>(int64_t & o_right)
+{
+ read(&o_right, sizeof(o_right));
+ be64toh(o_right);
+ return *this;
+}
-} /** namespace libhei **/
+} // namespace libhei
diff --git a/src/hei_chip.hpp b/src/hei_chip.hpp
index 38a4ba2..216a4cc 100644
--- a/src/hei_chip.hpp
+++ b/src/hei_chip.hpp
@@ -17,16 +17,16 @@
~Chip() = default;
- Chip( const Chip & ) = default;
+ Chip(const Chip &) = default;
- Chip & operator=( const Chip & ) = default;
+ Chip & operator=(const Chip &) = default;
/**
* @brief Constructor.
* @param i_chip See description for iv_chip.
* @param i_type See description for iv_type.
*/
- Chip( void * i_chip, ChipType_t i_type ) :
+ Chip(void * i_chip, ChipType_t i_type) :
iv_chip(i_chip), iv_type(i_type)
{}
@@ -38,17 +38,16 @@
public: // Operators
- bool operator==( const Chip & r ) const
+ bool operator==(const Chip & r) const
{
return (iv_chip == r.iv_chip) &&
(iv_type == r.iv_type);
}
- bool operator<( const Chip & r ) const
+ bool operator<(const Chip & r) const
{
- return ( iv_chip < r.iv_chip ) ||
- ( (iv_chip == r.iv_chip) &&
- (iv_type < r.iv_type) );
+ return (iv_chip < r.iv_chip) ||
+ ((iv_chip == r.iv_chip) && (iv_type < r.iv_type));
}
private:
@@ -72,4 +71,3 @@
}; // end class Chip
} // end namespace libhei
-
diff --git a/src/hei_includes.hpp b/src/hei_includes.hpp
index 82b38b3..0b33436 100644
--- a/src/hei_includes.hpp
+++ b/src/hei_includes.hpp
@@ -16,11 +16,11 @@
// macros:
//
// Tracing (inputs same as printf() from <cstdio>):
-// HEI_INF( ... ) // Generic informational trace
-// HEI_ERR( ... ) // Error path trace
+// HEI_INF(...) // Generic informational trace
+// HEI_ERR(...) // Error path trace
//
// Assertion (at a minimum should work like assert() from <cassert>):
-// HEI_ASSERT( expression )
+// HEI_ASSERT(expression)
//
#include <hei_user_defines.hpp>
@@ -28,4 +28,3 @@
#include <hei_chip.hpp>
#include <hei_return_code.hpp>
#include <hei_types.hpp>
-
diff --git a/src/hei_isolation_data.hpp b/src/hei_isolation_data.hpp
index ee1432d..f0c89c8 100644
--- a/src/hei_isolation_data.hpp
+++ b/src/hei_isolation_data.hpp
@@ -23,10 +23,10 @@
~IsolationData() = default;
/** @brief Copy constructor. */
- IsolationData( const IsolationData & ) = default;
+ IsolationData(const IsolationData &) = default;
/** @brief Assignment operator. */
- IsolationData & operator=( const IsolationData & ) = default;
+ IsolationData & operator=(const IsolationData &) = default;
private: // Instance variables
@@ -41,9 +41,9 @@
* @brief Adds a signature to the signature list.
* @param i_signature The target signature.
*/
- void addSignature( const Signature & i_signature )
+ void addSignature(const Signature & i_signature)
{
- iv_sigLists.push_back( i_signature );
+ iv_sigLists.push_back(i_signature);
}
/** @brief Allows access to the signature list. */
@@ -61,4 +61,3 @@
}; // end class IsolationData
} // end namespace libhei
-
diff --git a/src/hei_main.hpp b/src/hei_main.hpp
index 21aebd2..5cc10bd 100644
--- a/src/hei_main.hpp
+++ b/src/hei_main.hpp
@@ -63,11 +63,11 @@
*
* @return RC_SUCCESS or RC_CHIP_DATA_INVALID or RC_CHIP_DATA_INITIALIZED
*/
-inline ReturnCode initialize( void * i_buffer, size_t i_bufferSize,
- bool i_forceInit = false )
+inline ReturnCode initialize(void * i_buffer, size_t i_bufferSize,
+ bool i_forceInit = false)
{
- return Isolator::getSingleton().initialize( i_buffer, i_bufferSize,
- i_forceInit );
+ return Isolator::getSingleton().initialize(i_buffer, i_bufferSize,
+ i_forceInit);
}
/**
@@ -97,11 +97,10 @@
*
* @return RC_SUCCESS or RC_CHIP_DATA_MISSING
*/
-inline ReturnCode isolate( const std::vector<Chip> & i_chipList,
- IsolationData & o_isoData )
+inline ReturnCode isolate(const std::vector<Chip> & i_chipList,
+ IsolationData & o_isoData)
{
- return Isolator::getSingleton().isolate( i_chipList, o_isoData );
+ return Isolator::getSingleton().isolate(i_chipList, o_isoData);
}
} // end namespace libhei
-
diff --git a/src/hei_return_code.hpp b/src/hei_return_code.hpp
index 5d0526e..c9ebc8a 100644
--- a/src/hei_return_code.hpp
+++ b/src/hei_return_code.hpp
@@ -13,33 +13,33 @@
* @brief Constructor.
* @param i_rc The error code value.
*/
- explicit constexpr ReturnCode( uint32_t i_rc = 0 ) :
- iv_rc( i_rc )
+ explicit constexpr ReturnCode(uint32_t i_rc = 0) :
+ iv_rc(i_rc)
{}
/** @brief Default copy constructor. */
- ReturnCode( const ReturnCode & ) = default;
+ ReturnCode(const ReturnCode &) = default;
/** @brief Default assignment operator. */
- ReturnCode& operator=( const ReturnCode & ) = default;
+ ReturnCode& operator=(const ReturnCode &) = default;
/** @brief Default destructor. */
~ReturnCode() = default;
- /** @brief Integral type conversion function. */
+ /** @brief Integral type conversion function. */
operator uint32_t() const { return iv_rc; }
/** @brief Integral type conversion function. */
operator uint64_t() const { return iv_rc; }
/** @brief Equals operator. */
- bool operator==( const ReturnCode & rhs ) const
+ bool operator==(const ReturnCode & rhs) const
{
return rhs.iv_rc == iv_rc;
}
/** @brief Not equals operator. */
- bool operator!=( const ReturnCode & rhs ) const
+ bool operator!=(const ReturnCode & rhs) const
{
return rhs.iv_rc != iv_rc;
}
@@ -76,4 +76,3 @@
static constexpr ReturnCode RC_REG_ACCESS_FAILURE = ReturnCode(0x00000004);
} // end namespace libhei
-
diff --git a/src/hei_types.hpp b/src/hei_types.hpp
index 9accfcb..698d811 100644
--- a/src/hei_types.hpp
+++ b/src/hei_types.hpp
@@ -172,4 +172,3 @@
};
} // end namespace libhei
-
diff --git a/src/hei_user_interface.hpp b/src/hei_user_interface.hpp
index fbfe92c..81b1473 100644
--- a/src/hei_user_interface.hpp
+++ b/src/hei_user_interface.hpp
@@ -44,8 +44,8 @@
* failure the user application is responsible for reporting why the
* register access failed.
*/
-ReturnCode registerRead( void * i_chip, void * o_buffer, size_t & io_bufSize,
- uint64_t i_regType, uint64_t i_address );
+ReturnCode registerRead(void * i_chip, void * o_buffer, size_t & io_bufSize,
+ uint64_t i_regType, uint64_t i_address);
#ifndef __HEI_READ_ONLY
@@ -80,10 +80,9 @@
* failure the user application is responsible for reporting why the
* register access failed.
*/
-ReturnCode registerWrite( void * i_chip, void * i_buffer, size_t & io_bufSize,
- uint64_t i_regType, uint64_t i_address );
+ReturnCode registerWrite(void * i_chip, void * i_buffer, size_t & io_bufSize,
+ uint64_t i_regType, uint64_t i_address);
#endif
} // end namespace libhei
-
diff --git a/src/isolator/hei_isolation_node.cpp b/src/isolator/hei_isolation_node.cpp
index a0bbf37..b30a678 100644
--- a/src/isolator/hei_isolation_node.cpp
+++ b/src/isolator/hei_isolation_node.cpp
@@ -5,8 +5,8 @@
//------------------------------------------------------------------------------
-bool IsolationNode::analyze( const Chip & i_chip, AttentionType_t i_attnType,
- IsolationData & io_isoData ) const
+bool IsolationNode::analyze(const Chip & i_chip, AttentionType_t i_attnType,
+ IsolationData & io_isoData) const
{
bool o_activeAttn = false; // Initially, assume no active attentions.
@@ -14,34 +14,34 @@
pushIsolationStack();
// A rule for i_attnType must exist.
- auto rule_itr = iv_rules.find( i_attnType );
- HEI_ASSERT( iv_rules.end() != rule_itr );
+ auto rule_itr = iv_rules.find(i_attnType);
+ HEI_ASSERT(iv_rules.end() != rule_itr);
// Get the returned BitString for this rule.
- const BitString * bs = rule_itr->second->getBitString( i_chip );
+ const BitString * bs = rule_itr->second->getBitString(i_chip);
// Ensure this BitString is not longer than the maximum bit field.
- HEI_ASSERT( bs->getBitLen() <= sizeof(RegisterBit_t) * 8 );
+ HEI_ASSERT(bs->getBitLen() <= sizeof(RegisterBit_t) * 8);
// Find all active bits for this rule.
- for ( RegisterBit_t bit = 0; bit < bs->getBitLen(); bit++ )
+ for (RegisterBit_t bit = 0; bit < bs->getBitLen(); bit++)
{
// Continue to the next bit if not active.
- if ( !bs->isBitSet(bit) ) continue;
+ if (!bs->isBitSet(bit)) continue;
// At least one active bit was found.
o_activeAttn = true;
// Determine if this attention originated from another register or if it
// is a leaf in the isolation tree.
- auto child_itr = iv_children.find( bit );
- if ( iv_children.end() != child_itr )
+ auto child_itr = iv_children.find(bit);
+ if (iv_children.end() != child_itr)
{
// This bit was driven from an attention from another register.
// Continue down the isolation tree to look for more attentions.
- bool attnFound = child_itr->second->analyze( i_chip, i_attnType,
- io_isoData );
- if ( !attnFound )
+ bool attnFound = child_itr->second->analyze(i_chip, i_attnType,
+ io_isoData);
+ if (!attnFound)
{
// Something went wrong. There should have been an active
// attention. It's possible there is a bug in the Chip Data
@@ -53,18 +53,18 @@
// io_isoData. If there are no other active attentions, the user
// application could use this signature to help determine, and
// circumvent, the isolation problem.
- io_isoData.addSignature( Signature { i_chip, iv_hwReg.getId(),
- iv_hwReg.getInstance(),
- bit, i_attnType } );
+ io_isoData.addSignature(Signature { i_chip, iv_hwReg.getId(),
+ iv_hwReg.getInstance(),
+ bit, i_attnType });
}
}
else
{
// We have reached a leaf in the isolation tree. Add this bit's
// signature to io_isoData.
- io_isoData.addSignature( Signature { i_chip, iv_hwReg.getId(),
- iv_hwReg.getInstance(),
- bit, i_attnType } );
+ io_isoData.addSignature(Signature { i_chip, iv_hwReg.getId(),
+ iv_hwReg.getInstance(),
+ bit, i_attnType });
}
}
@@ -76,14 +76,13 @@
//------------------------------------------------------------------------------
-void IsolationNode::addRule( AttentionType_t i_attnType,
- const Register * i_rule )
+void IsolationNode::addRule(AttentionType_t i_attnType, const Register * i_rule)
{
// A rule for this attention type should not already exist.
- HEI_ASSERT( iv_rules.end() == iv_rules.find(i_attnType) );
+ HEI_ASSERT(iv_rules.end() == iv_rules.find(i_attnType));
// The rule should not be null.
- HEI_ASSERT( nullptr != i_rule );
+ HEI_ASSERT(nullptr != i_rule);
// Add the new rule.
iv_rules[i_attnType] = i_rule;
@@ -91,13 +90,13 @@
//------------------------------------------------------------------------------
-void IsolationNode::addChild( uint8_t i_bit, const IsolationNode * i_child )
+void IsolationNode::addChild(uint8_t i_bit, const IsolationNode * i_child)
{
// An entry for this bit should not already exist.
- HEI_ASSERT( iv_children.end() == iv_children.find(i_bit) );
+ HEI_ASSERT(iv_children.end() == iv_children.find(i_bit));
// The child register should not be null.
- HEI_ASSERT( nullptr != i_child );
+ HEI_ASSERT(nullptr != i_child);
// Add the new rule.
iv_children[i_bit] = i_child;
@@ -112,15 +111,14 @@
void IsolationNode::pushIsolationStack() const
{
// Ensure this node does not already exist in cv_isolationStack.
- auto itr = std::find( cv_isolationStack.begin(),
- cv_isolationStack.end(), this );
- HEI_ASSERT( cv_isolationStack.end() == itr );
+ auto itr = std::find(cv_isolationStack.begin(),
+ cv_isolationStack.end(), this);
+ HEI_ASSERT(cv_isolationStack.end() == itr);
// Push to node to the stack.
- cv_isolationStack.push_back( this );
+ cv_isolationStack.push_back(this);
}
//------------------------------------------------------------------------------
} // end namespace libhei
-
diff --git a/src/isolator/hei_isolation_node.hpp b/src/isolator/hei_isolation_node.hpp
index eaf18e5..3fc8a37 100644
--- a/src/isolator/hei_isolation_node.hpp
+++ b/src/isolator/hei_isolation_node.hpp
@@ -42,8 +42,8 @@
* @param i_hwReg A reference to the HardwareRegister targeted for
* isolation.
*/
- explicit IsolationNode( const HardwareRegister & i_hwReg ) :
- iv_hwReg( i_hwReg )
+ explicit IsolationNode(const HardwareRegister & i_hwReg) :
+ iv_hwReg(i_hwReg)
{}
/** @brief Destructor. */
@@ -60,7 +60,7 @@
*
* Needed by Flyweight class, but should not be allowed in general.
*/
- IsolationNode( const IsolationNode & ) = default;
+ IsolationNode(const IsolationNode &) = default;
/**
* @brief Explicitly disables assignment operator.
@@ -69,7 +69,7 @@
* of the constant instance variables, but helps communicate it is not
* allowed.
*/
- IsolationNode & operator=( const IsolationNode & ) = delete;
+ IsolationNode & operator=(const IsolationNode &) = delete;
private: // Instance variables
@@ -111,8 +111,8 @@
* @return True, if any active attentions found on this register.
* False, otherwise.
*/
- bool analyze( const Chip & i_chip, AttentionType_t i_attnType,
- IsolationData & io_isoData ) const;
+ bool analyze(const Chip & i_chip, AttentionType_t i_attnType,
+ IsolationData & io_isoData) const;
// TODO: The next two functions are only intended to be used during
// initialization of the isolator. Consider, making them private and
@@ -129,7 +129,7 @@
* @param The target attention type.
* @param The rule for this attention type.
*/
- void addRule( AttentionType_t i_attnType, const Register * i_rule );
+ void addRule(AttentionType_t i_attnType, const Register * i_rule);
/**
* @brief Adds a child register to analyze for the given bit in this
@@ -141,22 +141,22 @@
* @param The target bit on this register.
* @param The child register to analyze for the given bit.
*/
- void addChild( RegisterBit_t i_bit, const IsolationNode * i_child );
+ void addChild(RegisterBit_t i_bit, const IsolationNode * i_child);
public: // Operators
/** @brief Equals operator. */
- bool operator==( const IsolationNode & i_r ) const
+ bool operator==(const IsolationNode & i_r) const
{
// iv_hwReg should be unique per IsolationNode.
- return ( iv_hwReg == i_r.iv_hwReg );
+ return (iv_hwReg == i_r.iv_hwReg);
}
/** @brief Less than operator. */
- bool operator<( const IsolationNode & i_r ) const
+ bool operator<(const IsolationNode & i_r) const
{
// iv_hwReg should be unique per IsolationNode.
- return ( iv_hwReg < i_r.iv_hwReg );
+ return (iv_hwReg < i_r.iv_hwReg);
}
private: // Isolation stack and supporting functions.
@@ -187,4 +187,3 @@
};
} // end namespace libhei
-
diff --git a/src/isolator/hei_isolator.cpp b/src/isolator/hei_isolator.cpp
index e977054..45ca647 100644
--- a/src/isolator/hei_isolator.cpp
+++ b/src/isolator/hei_isolator.cpp
@@ -11,29 +11,29 @@
namespace libhei
{
-ReturnCode Isolator::initialize( void * i_buffer, size_t i_bufferSize,
- bool i_forceInit )
+ReturnCode Isolator::initialize(void * i_buffer, size_t i_bufferSize,
+ bool i_forceInit)
{
ReturnCode rc;
// BEGIN temporary code
- HEI_INF( "Isolator::initialize(%p,%lu,%d)", i_buffer, i_bufferSize,
- i_forceInit );
+ HEI_INF("Isolator::initialize(%p,%lu,%d)", i_buffer, i_bufferSize,
+ i_forceInit);
Flyweight<ScomRegister> & sfw = Flyweight<ScomRegister>::getSingleton();
Flyweight<IdScomRegister> & ifw = Flyweight<IdScomRegister>::getSingleton();
- sfw.get( ScomRegister { CHIP_TYPE_INVALID, REG_ID_INVALID,
- REG_INST_DEFAULT, REG_ACCESS_RW, 0x01234567 } );
- sfw.get( ScomRegister { CHIP_TYPE_INVALID, REG_ID_INVALID,
- REG_INST_DEFAULT, REG_ACCESS_RW, 0x00112233 } );
+ sfw.get(ScomRegister { CHIP_TYPE_INVALID, REG_ID_INVALID,
+ REG_INST_DEFAULT, REG_ACCESS_RW, 0x01234567 });
+ sfw.get(ScomRegister { CHIP_TYPE_INVALID, REG_ID_INVALID,
+ REG_INST_DEFAULT, REG_ACCESS_RW, 0x00112233 });
- ifw.get( IdScomRegister { CHIP_TYPE_INVALID, REG_ID_INVALID,
- REG_INST_DEFAULT, REG_ACCESS_RW,
- 0x0123456789abcdef } );
- ifw.get( IdScomRegister { CHIP_TYPE_INVALID, REG_ID_INVALID,
- REG_INST_DEFAULT, REG_ACCESS_RW,
- 0x0011223344556677 } );
+ ifw.get(IdScomRegister { CHIP_TYPE_INVALID, REG_ID_INVALID,
+ REG_INST_DEFAULT, REG_ACCESS_RW,
+ 0x0123456789abcdef });
+ ifw.get(IdScomRegister { CHIP_TYPE_INVALID, REG_ID_INVALID,
+ REG_INST_DEFAULT, REG_ACCESS_RW,
+ 0x0011223344556677 });
// END temporary code
return rc;
@@ -54,8 +54,8 @@
Flyweight<IdScomRegister>::getSingleton().clear();
}
-ReturnCode Isolator::isolate( const std::vector<Chip> & i_chipList,
- IsolationData & o_isoData ) const
+ReturnCode Isolator::isolate(const std::vector<Chip> & i_chipList,
+ IsolationData & o_isoData) const
{
ReturnCode rc;
@@ -66,11 +66,10 @@
HardwareRegister::flushAll();
// Analyze active error on each chip.
- for ( auto const & chip : i_chipList )
+ for (auto const & chip : i_chipList)
{
// BEGIN temporary code
- HEI_INF( "Isolator::isolate(%p,%u)", chip.getChip(),
- chip.getType() );
+ HEI_INF("Isolator::isolate(%p,%u)", chip.getChip(), chip.getType());
// END temporary code
}
diff --git a/src/isolator/hei_isolator.hpp b/src/isolator/hei_isolator.hpp
index 1cc29b7..3c4a589 100644
--- a/src/isolator/hei_isolator.hpp
+++ b/src/isolator/hei_isolator.hpp
@@ -41,10 +41,10 @@
}
/** @brief Copy constructor. */
- Isolator( const Isolator & ) = delete;
+ Isolator(const Isolator &) = delete;
/** @brief Assignment operator. */
- Isolator & operator=( const Isolator & ) = delete;
+ Isolator & operator=(const Isolator &) = delete;
public:
@@ -56,8 +56,8 @@
}
/** @brief See API wrapper description in hei_main.hpp. */
- ReturnCode initialize( void * i_buffer, size_t i_bufferSize,
- bool i_forceInit = false );
+ ReturnCode initialize(void * i_buffer, size_t i_bufferSize,
+ bool i_forceInit = false);
/**
* @brief See API wrapper description in hei_main.hpp.
@@ -68,8 +68,8 @@
void uninitialize();
/** @brief See API wrapper description in hei_main.hpp. */
- ReturnCode isolate( const std::vector<Chip> & i_chipList,
- IsolationData & o_isoData ) const;
+ ReturnCode isolate(const std::vector<Chip> & i_chipList,
+ IsolationData & o_isoData) const;
private:
diff --git a/src/isolator/hei_signature.hpp b/src/isolator/hei_signature.hpp
index 018673a..4be04b3 100644
--- a/src/isolator/hei_signature.hpp
+++ b/src/isolator/hei_signature.hpp
@@ -25,21 +25,21 @@
* @param i_bit The target bit within this register.
* @param i_attnType The attention type reported by this bit.
*/
- Signature( const Chip & i_chip, RegisterId_t i_id,
- RegisterInstance_t i_instance, RegisterBit_t i_bit,
- AttentionType_t i_attnType ) :
- iv_chip( i_chip ), iv_id( i_id ), iv_instance( i_instance ),
- iv_bit( i_bit ), iv_attnType( i_attnType )
+ Signature(const Chip & i_chip, RegisterId_t i_id,
+ RegisterInstance_t i_instance, RegisterBit_t i_bit,
+ AttentionType_t i_attnType) :
+ iv_chip(i_chip), iv_id(i_id), iv_instance(i_instance),
+ iv_bit(i_bit), iv_attnType(i_attnType)
{}
/** @brief Destructor. */
~Signature() = default;
/** @brief Copy constructor. */
- Signature( const Signature & ) = default;
+ Signature(const Signature &) = default;
/** @brief Assignment operator. */
- Signature & operator=( const Signature & ) = default;
+ Signature & operator=(const Signature &) = default;
private: // Instance variables.
@@ -68,4 +68,3 @@
};
} // end namespace libhei
-
diff --git a/src/register/hei_hardware_register.cpp b/src/register/hei_hardware_register.cpp
index 3334662..52dc28c 100755
--- a/src/register/hei_hardware_register.cpp
+++ b/src/register/hei_hardware_register.cpp
@@ -13,7 +13,7 @@
//------------------------------------------------------------------------------
#if 0
-void HardwareRegister::setBitString( const BitString *bs )
+void HardwareRegister::setBitString(const BitString *bs)
{
BitString & l_string = accessBitString();
l_string.setString(*bs);
@@ -22,10 +22,10 @@
//------------------------------------------------------------------------------
-const BitString * HardwareRegister::getBitString( const Chip & i_chip ) const
+const BitString * HardwareRegister::getBitString(const Chip & i_chip) const
{
// Verify this register belongs on i_chip.
- verifyAccessorChip( i_chip );
+ verifyAccessorChip(i_chip);
// Calling read() will ensure that an entry exists in the cache and the
// entry has at been synched with hardware at least once. Note that we
@@ -33,21 +33,21 @@
// will be created in the cache, if it does not exist, when the cache is
// accessed below.
- if ( ( REG_ACCESS_NONE != getAccessLevel() ) &&
- ( REG_ACCESS_WO != getAccessLevel() ) )
+ if ((REG_ACCESS_NONE != getAccessLevel()) &&
+ (REG_ACCESS_WO != getAccessLevel()))
{
- read( i_chip );
+ read(i_chip);
}
- return &( accessCache(i_chip) );
+ return &(accessCache(i_chip));
}
//------------------------------------------------------------------------------
-BitString & HardwareRegister::accessBitString( const Chip & i_chip )
+BitString & HardwareRegister::accessBitString(const Chip & i_chip)
{
// Verify this register belongs on i_chip.
- verifyAccessorChip( i_chip );
+ verifyAccessorChip(i_chip);
// Calling read() will ensure that an entry exists in the cache and the
// entry has at been synched with hardware at least once. Note that we
@@ -55,52 +55,52 @@
// will be created in the cache, if it does not exist, when the cache is
// accessed below.
- if ( ( REG_ACCESS_NONE != getAccessLevel() ) &&
- ( REG_ACCESS_WO != getAccessLevel() ) )
+ if ((REG_ACCESS_NONE != getAccessLevel()) &&
+ (REG_ACCESS_WO != getAccessLevel()))
{
- read( i_chip );
+ read(i_chip);
}
- return accessCache( i_chip );
+ return accessCache(i_chip);
}
//------------------------------------------------------------------------------
-ReturnCode HardwareRegister::read( const Chip & i_chip, bool i_force ) const
+ReturnCode HardwareRegister::read(const Chip & i_chip, bool i_force) const
{
ReturnCode rc;
// Verify this register belongs on i_chip.
- verifyAccessorChip( i_chip );
+ verifyAccessorChip(i_chip);
// Read from hardware only if the read is forced or the entry for this
// instance does not exist in the cache.
- if ( i_force || !queryCache(i_chip) )
+ if (i_force || !queryCache(i_chip))
{
// This register must be readable.
- HEI_ASSERT( ( REG_ACCESS_NONE != getAccessLevel() ) &&
- ( REG_ACCESS_WO != getAccessLevel() ) );
+ HEI_ASSERT((REG_ACCESS_NONE != getAccessLevel()) &&
+ (REG_ACCESS_WO != getAccessLevel()));
// Get the buffer from the register cache.
- BitString & bs = accessCache( i_chip );
+ BitString & bs = accessCache(i_chip);
// Get the byte size of the buffer.
- size_t sz_buffer = BitString::getMinBytes( bs.getBitLen() );
+ size_t sz_buffer = BitString::getMinBytes(bs.getBitLen());
// Read this register from hardware.
- rc = registerRead( i_chip.getChip(), bs.getBufAddr(),
- sz_buffer, getRegisterType(), getAddress() );
- if ( RC_SUCCESS != rc )
+ rc = registerRead(i_chip.getChip(), bs.getBufAddr(), sz_buffer,
+ getRegisterType(), getAddress());
+ if (RC_SUCCESS != rc)
{
// The read failed and we can't trust what was put in the register
// cache. So remove this instance's entry from the cache.
- flush( i_chip );
+ flush(i_chip);
}
else
{
// Sanity check. The returned size of the data written to the buffer
// should match the register size.
- HEI_ASSERT( getSize() == sz_buffer );
+ HEI_ASSERT(getSize() == sz_buffer);
}
}
@@ -111,35 +111,35 @@
#ifndef __HEI_READ_ONLY
-ReturnCode HardwareRegister::write( const Chip & i_chip ) const
+ReturnCode HardwareRegister::write(const Chip & i_chip) const
{
ReturnCode rc;
// Verify this register belongs on i_chip.
- verifyAccessorChip( i_chip );
+ verifyAccessorChip(i_chip);
// This register must be writable.
- HEI_ASSERT( ( REG_ACCESS_NONE != getAccessLevel() ) &&
- ( REG_ACCESS_RO != getAccessLevel() ) );
+ HEI_ASSERT((REG_ACCESS_NONE != getAccessLevel()) &&
+ (REG_ACCESS_RO != getAccessLevel()));
// An entry for this register must exist in the cache.
- HEI_ASSERT( queryCache(i_chip) );
+ HEI_ASSERT(queryCache(i_chip));
// Get the buffer from the register cache.
- BitString & bs = accessCache( i_chip );
+ BitString & bs = accessCache(i_chip);
// Get the byte size of the buffer.
- size_t sz_buffer = BitString::getMinBytes( bs.getBitLen() );
+ size_t sz_buffer = BitString::getMinBytes(bs.getBitLen());
// Write to this register to hardware.
- rc = registerWrite( i_chip.getChip(), bs.getBufAddr(),
- sz_buffer, getRegisterType(), getAddress() );
+ rc = registerWrite(i_chip.getChip(), bs.getBufAddr(),
+ sz_buffer, getRegisterType(), getAddress());
- if ( RC_SUCCESS == rc )
+ if (RC_SUCCESS == rc)
{
// Sanity check. The returned size of the data written to the buffer
// should match the register size.
- HEI_ASSERT( getSize() == sz_buffer );
+ HEI_ASSERT(getSize() == sz_buffer);
}
return rc;
@@ -153,18 +153,18 @@
//------------------------------------------------------------------------------
-bool HardwareRegister::Cache::query( const Chip & i_chip,
- const HardwareRegister * i_hwReg ) const
+bool HardwareRegister::Cache::query(const Chip & i_chip,
+ const HardwareRegister * i_hwReg) const
{
// Does i_chip exist in the cache?
- auto chipPairItr = iv_cache.find( i_chip );
- if ( iv_cache.end() != chipPairItr )
+ auto chipPairItr = iv_cache.find(i_chip);
+ if (iv_cache.end() != chipPairItr)
{
auto & hwRegMap = chipPairItr->second; // for ease of use
// Does i_hwReg exist in the cache?
- auto hwRegPairItr = hwRegMap.find( i_hwReg );
- if ( hwRegMap.end() != hwRegPairItr )
+ auto hwRegPairItr = hwRegMap.find(i_hwReg);
+ if (hwRegMap.end() != hwRegPairItr)
{
return true;
}
@@ -175,11 +175,11 @@
//------------------------------------------------------------------------------
-BitString & HardwareRegister::Cache::access( const Chip & i_chip,
- const HardwareRegister * i_hwReg )
+BitString & HardwareRegister::Cache::access(const Chip & i_chip,
+ const HardwareRegister * i_hwReg)
{
// If the entry does not exist, create a new entry.
- if ( !query(i_chip, i_hwReg) )
+ if (!query(i_chip, i_hwReg))
{
BitString * bs = new BitStringBuffer { i_hwReg->getSize() * 8 };
iv_cache[i_chip][i_hwReg] = bs;
@@ -194,9 +194,9 @@
void HardwareRegister::Cache::flush()
{
// Delete all of the BitStrings.
- for ( auto & chipPair : iv_cache )
+ for (auto & chipPair : iv_cache)
{
- for ( auto & hwRegPair : chipPair.second )
+ for (auto & hwRegPair : chipPair.second)
{
delete hwRegPair.second;
}
@@ -211,18 +211,18 @@
//------------------------------------------------------------------------------
-void HardwareRegister::Cache::flush( const Chip & i_chip,
- const HardwareRegister * i_hwReg )
+void HardwareRegister::Cache::flush(const Chip & i_chip,
+ const HardwareRegister * i_hwReg)
{
// Does i_chip exist in the cache?
- auto chipPairItr = iv_cache.find( i_chip );
- if ( iv_cache.end() != chipPairItr )
+ auto chipPairItr = iv_cache.find(i_chip);
+ if (iv_cache.end() != chipPairItr)
{
auto & hwRegMap = chipPairItr->second; // for ease of use
// Does i_hwReg exist in the cache?
- auto hwRegPairItr = hwRegMap.find( i_hwReg );
- if ( hwRegMap.end() != hwRegPairItr )
+ auto hwRegPairItr = hwRegMap.find(i_hwReg);
+ if (hwRegMap.end() != hwRegPairItr)
{
delete hwRegPairItr->second; // delete the BitString
hwRegMap.erase(i_hwReg); // remove the entry for this register
@@ -230,7 +230,7 @@
// If i_hwReg was the only entry for i_chip, we can remove i_chip from
// the cache.
- if ( hwRegMap.empty() )
+ if (hwRegMap.empty())
{
iv_cache.erase(i_chip);
}
@@ -240,4 +240,3 @@
//------------------------------------------------------------------------------
} // end namespace libhei
-
diff --git a/src/register/hei_hardware_register.hpp b/src/register/hei_hardware_register.hpp
index ead7b16..ab1c66e 100755
--- a/src/register/hei_hardware_register.hpp
+++ b/src/register/hei_hardware_register.hpp
@@ -50,11 +50,11 @@
* @param i_instance Instance of this register
* @param i_accessLevel Hardware access level for this register.
*/
- HardwareRegister( ChipType_t i_chipType, RegisterId_t i_id,
- RegisterInstance_t i_instance,
- RegisterAccessLevel_t i_accessLevel ) :
- Register(), iv_chipType( i_chipType ), iv_id( i_id ),
- iv_instance( i_instance ), iv_accessLevel( i_accessLevel )
+ HardwareRegister(ChipType_t i_chipType, RegisterId_t i_id,
+ RegisterInstance_t i_instance,
+ RegisterAccessLevel_t i_accessLevel) :
+ Register(), iv_chipType(i_chipType), iv_id(i_id),
+ iv_instance(i_instance), iv_accessLevel(i_accessLevel)
{}
private: // Instance variables
@@ -102,31 +102,31 @@
public: // Operators
/** @brief Equals operator. */
- bool operator==( const HardwareRegister & i_r ) const
+ bool operator==(const HardwareRegister & i_r) const
{
// Comparing register type, chip type, and address should be sufficient.
- return ( getRegisterType() == i_r.getRegisterType() ) &&
- ( getChipType() == i_r.getChipType() ) &&
- ( getAddress() == i_r.getAddress() );
+ return (getRegisterType() == i_r.getRegisterType()) &&
+ (getChipType() == i_r.getChipType() ) &&
+ (getAddress() == i_r.getAddress() );
}
/** @brief Less than operator. */
- bool operator<( const HardwareRegister & i_r ) const
+ bool operator<(const HardwareRegister & i_r) const
{
// Comparing register type, chip type, and address should be sufficient.
- if ( getRegisterType() < i_r.getRegisterType() )
+ if (getRegisterType() < i_r.getRegisterType())
{
return true;
}
- else if ( getRegisterType() == i_r.getRegisterType() )
+ else if (getRegisterType() == i_r.getRegisterType())
{
- if ( getChipType() < i_r.getChipType() )
+ if (getChipType() < i_r.getChipType())
{
return true;
}
- else if ( getChipType() == i_r.getChipType() )
+ else if (getChipType() == i_r.getChipType())
{
- return ( getAddress() < i_r.getAddress() );
+ return (getAddress() < i_r.getAddress());
}
}
@@ -136,7 +136,7 @@
public:
/** Function overloaded from parent Register class. */
- const BitString * getBitString( const Chip & i_chip ) const;
+ const BitString * getBitString(const Chip & i_chip) const;
#if 0
/**
@@ -157,9 +157,9 @@
* read from hardware and update the cache.
* @return See the return code from the registerRead() user interface API.
*/
- ReturnCode read( const Chip & i_chip, bool i_force = false ) const;
+ ReturnCode read(const Chip & i_chip, bool i_force = false) const;
- #ifndef __HEI_READ_ONLY
+#ifndef __HEI_READ_ONLY
/**
* @brief Writes the value stored in the register cache to hardware via the
@@ -167,9 +167,9 @@
* @param i_chip The target chip in which this register belongs.
* @return See the return code from the registerWrite() user interface API.
*/
- ReturnCode write( const Chip & i_chip ) const;
+ ReturnCode write(const Chip & i_chip) const;
- #endif // __HEI_READ_ONLY
+#endif // __HEI_READ_ONLY
protected:
@@ -182,14 +182,14 @@
* @param i_chip The target chip in which this register belongs.
* @return A reference to the BitString.
*/
- BitString & accessBitString( const Chip & i_chip );
+ BitString & accessBitString(const Chip & i_chip);
private: // Hardware accessor management functions.
/** @brief Asserts this register belongs on the target accessor chip. */
- void verifyAccessorChip( const Chip & i_chip ) const
+ void verifyAccessorChip(const Chip & i_chip) const
{
- HEI_ASSERT( getChipType() == i_chip.getType() );
+ HEI_ASSERT(getChipType() == i_chip.getType());
}
private: // Register cache class variable
@@ -212,10 +212,10 @@
~Cache() = default;
/** @brief Copy constructor. */
- Cache( const Cache & ) = delete;
+ Cache(const Cache &) = delete;
/** @brief Assignment operator. */
- Cache & operator=( const Cache & ) = delete;
+ Cache & operator=(const Cache &) = delete;
/**
* @brief Queries if a specific entry exists in the cache.
@@ -223,8 +223,8 @@
* @param i_hwReg The target register.
* @return True if the entry exists, false otherwise.
*/
- bool query( const Chip & i_chip,
- const HardwareRegister * i_hwReg ) const;
+ bool query(const Chip & i_chip,
+ const HardwareRegister * i_hwReg) const;
/**
* @brief Returns the data buffer for the given chip and register.
@@ -234,8 +234,8 @@
* @note If an entry does not exist in the cache, an entry will be
* created and the BitString will be initialized to 0.
*/
- BitString & access( const Chip & i_chip,
- const HardwareRegister * i_hwReg );
+ BitString & access(const Chip & i_chip,
+ const HardwareRegister * i_hwReg);
/** @brief Flushes entire contents from cache. */
void flush();
@@ -245,7 +245,7 @@
* @param i_chip The target chip.
* @param i_hwReg The target register.
*/
- void flush( const Chip & i_chip, const HardwareRegister * i_hwReg );
+ void flush(const Chip & i_chip, const HardwareRegister * i_hwReg);
private:
@@ -279,9 +279,9 @@
* @brief Flushes this register from the cache.
* @param i_chip The target chip in which this register belongs.
*/
- void flush( const Chip & i_chip ) const
+ void flush(const Chip & i_chip) const
{
- cv_cache.flush( i_chip, this );
+ cv_cache.flush(i_chip, this);
}
private: // Register cache management functions.
@@ -290,20 +290,19 @@
* @param i_chip The target chip in which this register belongs.
* @return True if an entry for this register exist in this cache.
*/
- bool queryCache( const Chip & i_chip ) const
+ bool queryCache(const Chip & i_chip) const
{
- return cv_cache.query( i_chip, this );
+ return cv_cache.query(i_chip, this);
}
/**
* @param i_chip The target chip in which this register belongs.
* @return A reference to this register's BitString in cache.
*/
- BitString & accessCache( const Chip & i_chip ) const
+ BitString & accessCache(const Chip & i_chip) const
{
- return cv_cache.access( i_chip, this );
+ return cv_cache.access(i_chip, this);
}
};
} // end namespace libhei
-
diff --git a/src/register/hei_register.hpp b/src/register/hei_register.hpp
index 2a5c6ef..4514c28 100755
--- a/src/register/hei_register.hpp
+++ b/src/register/hei_register.hpp
@@ -17,7 +17,7 @@
Register * fir = new HardwareRegister(REG_ADDRESS, REG_WIDTH,
CHIP_TYPE, ACCESS_RO);
-Register * mask = new ConstantRegister( 0xffffffff00000000 );
+Register * mask = new ConstantRegister(0xffffffff00000000);
Register * fir_mask = new AndRegister(fir, mask);
const BitString * bs = fir_mask->getBitString(chip);
@@ -37,10 +37,10 @@
* @param i_chip Indicates which chip to access for this register.
* @return A BitString containing the value of this register.
*/
- virtual const BitString * getBitString( const Chip & i_chip ) const = 0;
+ virtual const BitString * getBitString(const Chip & i_chip) const = 0;
};
// Pure virtual destructor must be defined.
inline Register::~Register() {}
-}//end namespace libhei
+} // end namespace libhei
diff --git a/src/register/hei_scom_register.hpp b/src/register/hei_scom_register.hpp
index 04fd124..c90d5be 100644
--- a/src/register/hei_scom_register.hpp
+++ b/src/register/hei_scom_register.hpp
@@ -25,11 +25,11 @@
* @param i_accessLevel Hardware access level for this register.
* @param i_address A 4-byte address for this SCOM register.
*/
- ScomRegister( ChipType_t i_chipType, RegisterId_t i_id,
- RegisterInstance_t i_instance,
- RegisterAccessLevel_t i_accessLevel, uint32_t i_address ) :
- HardwareRegister( i_chipType, i_id, i_instance, i_accessLevel ),
- iv_address( i_address )
+ ScomRegister(ChipType_t i_chipType, RegisterId_t i_id,
+ RegisterInstance_t i_instance,
+ RegisterAccessLevel_t i_accessLevel, uint32_t i_address) :
+ HardwareRegister(i_chipType, i_id, i_instance, i_accessLevel),
+ iv_address(i_address)
{}
/** @brief Destructor. */
@@ -46,7 +46,7 @@
*
* Needed by Flyweight class, but should not be allowed in general.
*/
- ScomRegister( const ScomRegister & ) = default;
+ ScomRegister(const ScomRegister &) = default;
/**
* @brief Explicitly disables assignment operator.
@@ -55,7 +55,7 @@
* of the constant instance variables, but helps communicate it is not
* allowed.
*/
- ScomRegister & operator=( const ScomRegister & ) = delete;
+ ScomRegister & operator=(const ScomRegister &) = delete;
public: // Accessor functions
@@ -65,7 +65,7 @@
/** Function overloaded from parent HardwareRegister class. */
RegisterAddress_t getAddress() const
{
- return static_cast<RegisterAddress_t>( iv_address );
+ return static_cast<RegisterAddress_t>(iv_address);
}
/** Function overloaded from parent HardwareRegister class. */
@@ -104,11 +104,11 @@
* @param i_accessLevel Hardware access level for this register.
* @param i_address An 8-byte address for this Indirect SCOM register.
*/
- IdScomRegister( ChipType_t i_chipType, RegisterId_t i_id,
- RegisterInstance_t i_instance,
- RegisterAccessLevel_t i_accessLevel, uint64_t i_address ) :
- HardwareRegister( i_chipType, i_id, i_instance, i_accessLevel ),
- iv_address( i_address )
+ IdScomRegister(ChipType_t i_chipType, RegisterId_t i_id,
+ RegisterInstance_t i_instance,
+ RegisterAccessLevel_t i_accessLevel, uint64_t i_address) :
+ HardwareRegister(i_chipType, i_id, i_instance, i_accessLevel),
+ iv_address(i_address)
{}
/** @brief Destructor. */
@@ -125,7 +125,7 @@
*
* Needed by Flyweight class, but should not be allowed in general.
*/
- IdScomRegister( const IdScomRegister & ) = default;
+ IdScomRegister(const IdScomRegister &) = default;
/**
* @brief Explicitly disables assignment operator.
@@ -134,7 +134,7 @@
* of the constant instance variables, but helps communicate it is not
* allowed.
*/
- IdScomRegister & operator=( const IdScomRegister & ) = delete;
+ IdScomRegister & operator=(const IdScomRegister &) = delete;
public: // Accessor functions
@@ -144,7 +144,7 @@
/** Function overloaded from parent HardwareRegister class. */
RegisterAddress_t getAddress() const
{
- return static_cast<RegisterAddress_t>( iv_address );
+ return static_cast<RegisterAddress_t>(iv_address);
}
/** Function overloaded from parent HardwareRegister class. */
@@ -158,4 +158,3 @@
}; // end class IdScomRegister
} // end namespace libhei
-
diff --git a/src/util/hei_bit_string.cpp b/src/util/hei_bit_string.cpp
index 55da5cd..25443a6 100755
--- a/src/util/hei_bit_string.cpp
+++ b/src/util/hei_bit_string.cpp
@@ -22,23 +22,23 @@
//------------------------------------------------------------------------------
-uint64_t BitString::getFieldRight( uint64_t i_pos, uint64_t i_len ) const
+uint64_t BitString::getFieldRight(uint64_t i_pos, uint64_t i_len) const
{
- HEI_ASSERT( nullptr != getBufAddr() ); // must to have a valid address
- HEI_ASSERT( 0 < i_len ); // must have at least one bit
- HEI_ASSERT( i_len <= UINT64_BIT_LEN ); // i_len length must be valid
- HEI_ASSERT( i_pos + i_len <= getBitLen() ); // field must be within range
+ HEI_ASSERT(nullptr != getBufAddr()); // must to have a valid address
+ HEI_ASSERT(0 < i_len); // must have at least one bit
+ HEI_ASSERT(i_len <= UINT64_BIT_LEN); // i_len length must be valid
+ HEI_ASSERT(i_pos + i_len <= getBitLen()); // field must be within range
// Get the relative address of this byte and the relative starting position
// within the byte.
uint64_t relPos = 0;
- uint8_t * relAddr = getRelativePosition( relPos, i_pos );
+ uint8_t * relAddr = getRelativePosition(relPos, i_pos);
// Get the length of the target bit field within this byte and the length of
// the bit field for any remaining bits.
uint64_t bf_len = i_len;
uint64_t remain_len = 0;
- if ( UINT8_BIT_LEN < relPos + i_len )
+ if (UINT8_BIT_LEN < relPos + i_len)
{
// The target bit field crosses a byte boundary. So truncate the bit
// length for this byte and update the remaining length.
@@ -52,12 +52,12 @@
bf >>= UINT8_BIT_LEN - bf_len; // Right justify the value.
// Check for any remaining bits after this target byte.
- if ( 0 != remain_len )
+ if (0 != remain_len)
{
// Recursively call this function on the remaining bits and push them
// into the right side of the return value.
uint64_t val = static_cast<uint64_t>(bf) << remain_len;
- return val | getFieldRight( i_pos + bf_len, remain_len );
+ return val | getFieldRight(i_pos + bf_len, remain_len);
}
// Nothing more to do. Simply return this bit field.
@@ -66,23 +66,23 @@
//------------------------------------------------------------------------------
-void BitString::setFieldLeft( uint64_t i_pos, uint64_t i_len, uint64_t i_val )
+void BitString::setFieldLeft(uint64_t i_pos, uint64_t i_len, uint64_t i_val)
{
- HEI_ASSERT( nullptr != getBufAddr() ); // must to have a valid address
- HEI_ASSERT( 0 < i_len ); // must have at least one bit
- HEI_ASSERT( i_len <= UINT64_BIT_LEN ); // i_len length must be valid
- HEI_ASSERT( i_pos + i_len <= getBitLen() ); // field must be within range
+ HEI_ASSERT(nullptr != getBufAddr()); // must to have a valid address
+ HEI_ASSERT(0 < i_len); // must have at least one bit
+ HEI_ASSERT(i_len <= UINT64_BIT_LEN); // i_len length must be valid
+ HEI_ASSERT(i_pos + i_len <= getBitLen()); // field must be within range
// Get the relative address of this byte and the relative starting position
// within the byte.
uint64_t relPos = 0;
- uint8_t * relAddr = getRelativePosition( relPos, i_pos );
+ uint8_t * relAddr = getRelativePosition(relPos, i_pos);
// Get the length of the target bit field within this byte and the length of
// the bit field for any remaining bits.
uint64_t bf_len = i_len;
uint64_t remain_len = 0;
- if ( UINT8_BIT_LEN < relPos + i_len )
+ if (UINT8_BIT_LEN < relPos + i_len)
{
// The target bit field crosses a byte boundary. So truncate the bit
// length for this byte and update the remaining length.
@@ -109,24 +109,24 @@
*relAddr = bf_l | bf | bf_r;
// Check for any remaining bits after this target byte.
- if ( 0 != remain_len )
+ if (0 != remain_len)
{
// Recursively call this function on the remaining bits.
- setFieldLeft( i_pos + bf_len, remain_len, i_val << bf_len );
+ setFieldLeft(i_pos + bf_len, remain_len, i_val << bf_len);
}
}
//------------------------------------------------------------------------------
-void BitString::setPattern( uint64_t i_sPos, uint64_t i_sLen,
- uint64_t i_pattern, uint64_t i_pLen )
+void BitString::setPattern(uint64_t i_sPos, uint64_t i_sLen, uint64_t i_pattern,
+ uint64_t i_pLen)
{
HEI_ASSERT(nullptr != getBufAddr()); // must to have a valid address
HEI_ASSERT(0 < i_sLen); // must have at least one bit
HEI_ASSERT(i_sPos + i_sLen <= getBitLen()); // field must be within range
HEI_ASSERT(0 < i_pLen); // must have at least one bit
- HEI_ASSERT(i_pLen <= UINT64_BIT_LEN); // i_pLen length must be valid
+ HEI_ASSERT(i_pLen <= UINT64_BIT_LEN); // i_pLen length must be valid
// Get a bit string for the pattern subset (right justified).
// Note that we cannot use a BitStringBuffer here because this function
@@ -138,105 +138,105 @@
// Iterate the range in chunks the size of i_pLen.
uint64_t endPos = i_sPos + i_sLen;
- for ( uint64_t pos = i_sPos; pos < endPos; pos += i_pLen )
+ for (uint64_t pos = i_sPos; pos < endPos; pos += i_pLen)
{
// The true chunk size is either i_pLen or the leftovers at the end.
- uint64_t len = std::min( i_pLen, endPos - pos );
+ uint64_t len = std::min(i_pLen, endPos - pos);
// Get this chunk's pattern value, truncate (right justified) if needed.
- uint64_t pattern = bs.getFieldRight( 0, len );
+ uint64_t pattern = bs.getFieldRight(0, len);
// Set the pattern in this string.
- setFieldRight( pos, len, pattern );
+ setFieldRight(pos, len, pattern);
}
}
//------------------------------------------------------------------------------
-void BitString::setString( const BitString & i_sStr, uint64_t i_sPos,
- uint64_t i_sLen, uint64_t i_dPos )
+void BitString::setString(const BitString & i_sStr, uint64_t i_sPos,
+ uint64_t i_sLen, uint64_t i_dPos)
{
// Ensure the source parameters are valid.
- HEI_ASSERT( nullptr != i_sStr.getBufAddr() );
- HEI_ASSERT( 0 < i_sLen ); // at least one bit to copy
- HEI_ASSERT( i_sPos + i_sLen <= i_sStr.getBitLen() );
+ HEI_ASSERT(nullptr != i_sStr.getBufAddr());
+ HEI_ASSERT(0 < i_sLen); // at least one bit to copy
+ HEI_ASSERT(i_sPos + i_sLen <= i_sStr.getBitLen());
// Ensure the destination has at least one bit available to copy.
- HEI_ASSERT( nullptr != getBufAddr() );
- HEI_ASSERT( i_dPos < getBitLen() );
+ HEI_ASSERT(nullptr != getBufAddr());
+ HEI_ASSERT(i_dPos < getBitLen());
// If the source length is greater than the destination length than the
// extra source bits are ignored.
- uint64_t actLen = std::min( i_sLen, getBitLen() - i_dPos );
+ uint64_t actLen = std::min(i_sLen, getBitLen() - i_dPos);
// The bit strings may be in overlapping memory spaces. So we need to copy
// the data in the correct direction to prevent overlapping.
uint64_t sRelOffset = 0, dRelOffset = 0;
- uint8_t * sRelAddr = i_sStr.getRelativePosition( sRelOffset, i_sPos );
- uint8_t * dRelAddr = getRelativePosition( dRelOffset, i_dPos );
+ uint8_t * sRelAddr = i_sStr.getRelativePosition(sRelOffset, i_sPos);
+ uint8_t * dRelAddr = getRelativePosition(dRelOffset, i_dPos);
// Copy the data.
- if ( (dRelAddr == sRelAddr) && (dRelOffset == sRelOffset) )
+ if ((dRelAddr == sRelAddr) && (dRelOffset == sRelOffset))
{
// Do nothing. The source and destination are the same.
}
- else if ( (dRelAddr < sRelAddr) ||
- ((dRelAddr == sRelAddr) && (dRelOffset < sRelOffset)) )
+ else if ((dRelAddr < sRelAddr) ||
+ ((dRelAddr == sRelAddr) && (dRelOffset < sRelOffset)))
{
// Copy the data forward.
- for ( uint64_t pos = 0; pos < actLen; pos += UINT64_BIT_LEN )
+ for (uint64_t pos = 0; pos < actLen; pos += UINT64_BIT_LEN)
{
- uint64_t len = std::min( actLen - pos, UINT64_BIT_LEN );
+ uint64_t len = std::min(actLen - pos, UINT64_BIT_LEN);
- uint64_t value = i_sStr.getFieldRight( i_sPos + pos, len );
- setFieldRight( i_dPos + pos, len, value );
+ uint64_t value = i_sStr.getFieldRight(i_sPos + pos, len);
+ setFieldRight(i_dPos + pos, len, value);
}
}
else // Copy the data backwards.
{
// Get the first position of the last chunk (byte aligned).
- uint64_t lastPos = ((actLen-1) / UINT64_BIT_LEN) * UINT64_BIT_LEN;
+ uint64_t lastPos = ((actLen - 1) / UINT64_BIT_LEN) * UINT64_BIT_LEN;
// Start with the last chunk and work backwards.
- for ( int32_t pos = lastPos; 0 <= pos; pos -= UINT64_BIT_LEN )
+ for (int32_t pos = lastPos; 0 <= pos; pos -= UINT64_BIT_LEN)
{
- uint64_t len = std::min( actLen - pos, UINT64_BIT_LEN );
- uint64_t value = i_sStr.getFieldRight( i_sPos + pos, len );
- setFieldRight( i_dPos + pos, len, value );
+ uint64_t len = std::min(actLen - pos, UINT64_BIT_LEN);
+ uint64_t value = i_sStr.getFieldRight(i_sPos + pos, len);
+ setFieldRight(i_dPos + pos, len, value);
}
}
}
//------------------------------------------------------------------------------
-void BitString::maskString( const BitString & i_mask )
+void BitString::maskString(const BitString & i_mask)
{
// Get the length of the smallest string.
- uint64_t actLen = std::min( getBitLen(), i_mask.getBitLen() );
+ uint64_t actLen = std::min(getBitLen(), i_mask.getBitLen());
- for ( uint64_t pos = 0; pos < actLen; pos += UINT64_BIT_LEN )
+ for (uint64_t pos = 0; pos < actLen; pos += UINT64_BIT_LEN)
{
- uint64_t len = std::min( actLen - pos, UINT64_BIT_LEN );
+ uint64_t len = std::min(actLen - pos, UINT64_BIT_LEN);
- uint64_t dVal = getFieldRight( pos, len );
- uint64_t sVal = i_mask.getFieldRight( pos, len );
+ uint64_t dVal = getFieldRight(pos, len);
+ uint64_t sVal = i_mask.getFieldRight(pos, len);
- setFieldRight( pos, len, dVal & ~sVal );
+ setFieldRight(pos, len, dVal & ~sVal);
}
}
//------------------------------------------------------------------------------
-bool BitString::isEqual( const BitString & i_str ) const
+bool BitString::isEqual(const BitString & i_str) const
{
- if ( getBitLen() != i_str.getBitLen() )
+ if (getBitLen() != i_str.getBitLen())
return false; // size not equal
- for ( uint64_t pos = 0; pos < getBitLen(); pos += UINT64_BIT_LEN )
+ for (uint64_t pos = 0; pos < getBitLen(); pos += UINT64_BIT_LEN)
{
- uint64_t len = std::min( getBitLen() - pos, UINT64_BIT_LEN );
+ uint64_t len = std::min(getBitLen() - pos, UINT64_BIT_LEN);
- if ( getFieldRight(pos, len) != i_str.getFieldRight(pos, len) )
+ if (getFieldRight(pos, len) != i_str.getFieldRight(pos, len))
return false; // bit strings do not match
}
@@ -247,11 +247,11 @@
bool BitString::isZero() const
{
- for ( uint64_t pos = 0; pos < getBitLen(); pos += UINT64_BIT_LEN )
+ for (uint64_t pos = 0; pos < getBitLen(); pos += UINT64_BIT_LEN)
{
- uint64_t len = std::min( getBitLen() - pos, UINT64_BIT_LEN );
+ uint64_t len = std::min(getBitLen() - pos, UINT64_BIT_LEN);
- if ( 0 != getFieldRight(pos, len) )
+ if (0 != getFieldRight(pos, len))
return false; // something is non-zero
}
@@ -260,17 +260,17 @@
//------------------------------------------------------------------------------
-uint64_t BitString::getSetCount( uint64_t i_pos, uint64_t i_len ) const
+uint64_t BitString::getSetCount(uint64_t i_pos, uint64_t i_len) const
{
uint64_t endPos = i_pos + i_len;
- HEI_ASSERT( endPos <= getBitLen() );
+ HEI_ASSERT(endPos <= getBitLen());
uint64_t count = 0;
- for ( uint64_t i = i_pos; i < endPos; i++ )
+ for (uint64_t i = i_pos; i < endPos; i++)
{
- if ( isBitSet(i) ) count++;
+ if (isBitSet(i)) count++;
}
return count;
@@ -280,15 +280,15 @@
BitStringBuffer BitString::operator~() const
{
- BitStringBuffer bsb( getBitLen() );
+ BitStringBuffer bsb(getBitLen());
- for ( uint64_t pos = 0; pos < getBitLen(); pos += UINT64_BIT_LEN )
+ for (uint64_t pos = 0; pos < getBitLen(); pos += UINT64_BIT_LEN)
{
- uint64_t len = std::min( getBitLen() - pos, UINT64_BIT_LEN );
+ uint64_t len = std::min(getBitLen() - pos, UINT64_BIT_LEN);
- uint64_t dVal = getFieldRight( pos, len );
+ uint64_t dVal = getFieldRight(pos, len);
- bsb.setFieldRight( pos, len, ~dVal );
+ bsb.setFieldRight(pos, len, ~dVal);
}
return bsb;
@@ -296,21 +296,21 @@
//------------------------------------------------------------------------------
-BitStringBuffer BitString::operator&( const BitString & i_bs ) const
+BitStringBuffer BitString::operator&(const BitString & i_bs) const
{
// Get the length of the smallest string.
- uint64_t actLen = std::min( getBitLen(), i_bs.getBitLen() );
+ uint64_t actLen = std::min(getBitLen(), i_bs.getBitLen());
- BitStringBuffer bsb( actLen );
+ BitStringBuffer bsb(actLen);
- for ( uint64_t pos = 0; pos < actLen; pos += UINT64_BIT_LEN )
+ for (uint64_t pos = 0; pos < actLen; pos += UINT64_BIT_LEN)
{
- uint64_t len = std::min( actLen - pos, UINT64_BIT_LEN );
+ uint64_t len = std::min(actLen - pos, UINT64_BIT_LEN);
- uint64_t dVal = getFieldRight( pos, len );
- uint64_t sVal = i_bs.getFieldRight( pos, len );
+ uint64_t dVal = getFieldRight(pos, len);
+ uint64_t sVal = i_bs.getFieldRight(pos, len);
- bsb.setFieldRight( pos, len, dVal & sVal );
+ bsb.setFieldRight(pos, len, dVal & sVal);
}
return bsb;
@@ -318,21 +318,21 @@
//------------------------------------------------------------------------------
-BitStringBuffer BitString::operator|( const BitString & i_bs ) const
+BitStringBuffer BitString::operator|(const BitString & i_bs) const
{
// Get the length of the smallest string.
- uint64_t actLen = std::min( getBitLen(), i_bs.getBitLen() );
+ uint64_t actLen = std::min(getBitLen(), i_bs.getBitLen());
- BitStringBuffer bsb( actLen );
+ BitStringBuffer bsb(actLen);
- for ( uint64_t pos = 0; pos < actLen; pos += UINT64_BIT_LEN )
+ for (uint64_t pos = 0; pos < actLen; pos += UINT64_BIT_LEN)
{
- uint64_t len = std::min( actLen - pos, UINT64_BIT_LEN );
+ uint64_t len = std::min(actLen - pos, UINT64_BIT_LEN);
- uint64_t dVal = getFieldRight( pos, len );
- uint64_t sVal = i_bs.getFieldRight( pos, len );
+ uint64_t dVal = getFieldRight(pos, len);
+ uint64_t sVal = i_bs.getFieldRight(pos, len);
- bsb.setFieldRight( pos, len, dVal | sVal );
+ bsb.setFieldRight(pos, len, dVal | sVal);
}
return bsb;
@@ -340,17 +340,17 @@
//------------------------------------------------------------------------------
-BitStringBuffer BitString::operator>>( uint64_t i_shift ) const
+BitStringBuffer BitString::operator>>(uint64_t i_shift) const
{
- BitStringBuffer bsb( getBitLen() ); // default all zeros
+ BitStringBuffer bsb(getBitLen()); // default all zeros
- if ( i_shift < getBitLen() )
+ if (i_shift < getBitLen())
{
// bso overlays bsb, containing the shifted offset.
- BitString bso ( bsb.getBitLen() - i_shift, bsb.getBufAddr(), i_shift );
+ BitString bso (bsb.getBitLen() - i_shift, bsb.getBufAddr(), i_shift);
// Copy this into bso.
- bso.setString( *this );
+ bso.setString(*this);
}
return bsb;
@@ -358,18 +358,18 @@
//------------------------------------------------------------------------------
-BitStringBuffer BitString::operator<<( uint64_t i_shift ) const
+BitStringBuffer BitString::operator<<(uint64_t i_shift) const
{
- BitStringBuffer bsb( getBitLen() ); // default all zeros
+ BitStringBuffer bsb(getBitLen()); // default all zeros
- if ( i_shift < getBitLen() )
+ if (i_shift < getBitLen())
{
// bso overlays *this, containing the shifted offset.
- BitString bso ( this->getBitLen() - i_shift, this->getBufAddr(),
- i_shift );
+ BitString bso (this->getBitLen() - i_shift, this->getBufAddr(),
+ i_shift);
// Copy bso into bsb.
- bsb.setString( bso );
+ bsb.setString(bso);
}
return bsb;
@@ -377,11 +377,11 @@
//------------------------------------------------------------------------------
-uint8_t * BitString::getRelativePosition( uint64_t & o_relPos,
- uint64_t i_absPos ) const
+uint8_t * BitString::getRelativePosition(uint64_t & o_relPos,
+ uint64_t i_absPos) const
{
- HEI_ASSERT( nullptr != getBufAddr() ); // must to have a valid address
- HEI_ASSERT( i_absPos < getBitLen() ); // must be a valid position
+ HEI_ASSERT(nullptr != getBufAddr()); // must to have a valid address
+ HEI_ASSERT(i_absPos < getBitLen()); // must be a valid position
o_relPos = (i_absPos + iv_offset) % UINT8_BIT_LEN;
@@ -392,8 +392,8 @@
// BitStringBuffer class
//##############################################################################
-BitStringBuffer::BitStringBuffer( uint64_t i_bitLen ) :
- BitString( i_bitLen, nullptr )
+BitStringBuffer::BitStringBuffer(uint64_t i_bitLen) :
+ BitString(i_bitLen, nullptr)
{
initBuffer();
}
@@ -407,52 +407,52 @@
//------------------------------------------------------------------------------
-BitStringBuffer::BitStringBuffer( const BitString & i_bs ) :
- BitString( i_bs.getBitLen(), nullptr )
+BitStringBuffer::BitStringBuffer(const BitString & i_bs) :
+ BitString(i_bs.getBitLen(), nullptr)
{
initBuffer();
- if ( !i_bs.isZero() ) setString( i_bs );
+ if (!i_bs.isZero()) setString(i_bs);
}
//------------------------------------------------------------------------------
-BitStringBuffer::BitStringBuffer( const BitStringBuffer & i_bsb ) :
- BitString( i_bsb.getBitLen(), nullptr )
+BitStringBuffer::BitStringBuffer(const BitStringBuffer & i_bsb) :
+ BitString(i_bsb.getBitLen(), nullptr)
{
initBuffer();
- if ( !i_bsb.isZero() ) setString( i_bsb );
+ if (!i_bsb.isZero()) setString(i_bsb);
}
//------------------------------------------------------------------------------
-BitStringBuffer & BitStringBuffer::operator=( const BitString & i_bs )
+BitStringBuffer & BitStringBuffer::operator=(const BitString & i_bs)
{
// The initBuffer() function will deallocate the buffer as well, however we
// also need to deallocate the buffer here before we set the length.
delete [] (uint8_t *)getBufAddr();
- setBufAddr( nullptr );
+ setBufAddr(nullptr);
- setBitLen( i_bs.getBitLen() );
+ setBitLen(i_bs.getBitLen());
initBuffer();
- if ( !i_bs.isZero() ) setString( i_bs );
+ if (!i_bs.isZero()) setString(i_bs);
return *this;
}
//------------------------------------------------------------------------------
-BitStringBuffer & BitStringBuffer::operator=( const BitStringBuffer & i_bsb )
+BitStringBuffer & BitStringBuffer::operator=(const BitStringBuffer & i_bsb)
{
- if ( this != &i_bsb ) // Check for assignment to self
+ if (this != &i_bsb) // Check for assignment to self
{
// The initBuffer() function will deallocate the buffer as well, however
// we also need to deallocate the buffer here before we set the length.
delete [] (uint8_t *)getBufAddr();
- setBufAddr( nullptr );
+ setBufAddr(nullptr);
- setBitLen( i_bsb.getBitLen() );
+ setBitLen(i_bsb.getBitLen());
initBuffer();
- if ( !i_bsb.isZero() ) setString( i_bsb );
+ if (!i_bsb.isZero()) setString(i_bsb);
}
return *this;
@@ -466,7 +466,7 @@
delete [] (uint8_t *)getBufAddr();
// create new buffer, initialized to 0's
- setBufAddr( new uint8_t[ getMinBytes(getBitLen()) ]() );
+ setBufAddr(new uint8_t[ getMinBytes(getBitLen()) ]());
}
} // end namespace libhei
diff --git a/src/util/hei_bit_string.hpp b/src/util/hei_bit_string.hpp
index 127ce61..7f83624 100755
--- a/src/util/hei_bit_string.hpp
+++ b/src/util/hei_bit_string.hpp
@@ -33,7 +33,7 @@
*
* uint8_t a[2]; // 16 bits of memory
* BitString bs { 16, a }; // init BitString for a
- * bs.setFieldRight( 0, 16, 0x1122 ); // set all 16 bits to 0x1122
+ * bs.setFieldRight(0, 16, 0x1122); // set all 16 bits to 0x1122
*
* Results in:
*
@@ -76,8 +76,7 @@
* @pre Use getMinBytes() to calulate the minimum number of bytes needed
* to allocate sufficient memory space for this bit string.
*/
- BitString( uint64_t i_bitLen, void * i_bufAddr,
- uint64_t i_offset = 0 ) :
+ BitString(uint64_t i_bitLen, void * i_bufAddr, uint64_t i_offset = 0) :
iv_bitLen(i_bitLen), iv_bufAddr(i_bufAddr), iv_offset(i_offset)
{}
@@ -98,9 +97,9 @@
* @return The minimum number of bytes required to allocate sufficient
* memory space for a bit string.
*/
- static uint64_t getMinBytes( uint64_t i_bitLen, uint64_t i_offset = 0 )
+ static uint64_t getMinBytes(uint64_t i_bitLen, uint64_t i_offset = 0)
{
- return (i_bitLen + i_offset + UINT8_BIT_LEN-1) / UINT8_BIT_LEN;
+ return (i_bitLen + i_offset + UINT8_BIT_LEN - 1) / UINT8_BIT_LEN;
}
/**
@@ -114,7 +113,7 @@
* @pre i_len <= UINT64_BIT_LEN
* @pre i_pos + i_len <= getBitLen()
*/
- uint64_t getFieldLeft( uint64_t i_pos, uint64_t i_len ) const
+ uint64_t getFieldLeft(uint64_t i_pos, uint64_t i_len) const
{
return getFieldRight(i_pos, i_len) << (UINT64_BIT_LEN - i_len);
}
@@ -130,7 +129,7 @@
* @pre i_len <= UINT64_BIT_LEN
* @pre i_pos + i_len <= getBitLen()
*/
- uint64_t getFieldRight( uint64_t i_pos, uint64_t i_len ) const;
+ uint64_t getFieldRight(uint64_t i_pos, uint64_t i_len) const;
/**
* @brief Sets a left-justified value of the given length into the bit
@@ -143,7 +142,7 @@
* @pre i_len <= UINT64_BIT_LEN
* @pre i_pos + i_len <= getBitLen()
*/
- void setFieldLeft( uint64_t i_pos, uint64_t i_len, uint64_t i_val );
+ void setFieldLeft(uint64_t i_pos, uint64_t i_len, uint64_t i_val);
/**
* @brief Sets a right-justified value of the given length into the bit
@@ -156,9 +155,9 @@
* @pre i_len <= UINT64_BIT_LEN
* @pre i_pos + i_len <= getBitLen()
*/
- void setFieldRight( uint64_t i_pos, uint64_t i_len, uint64_t i_val )
+ void setFieldRight(uint64_t i_pos, uint64_t i_len, uint64_t i_val)
{
- setFieldLeft( i_pos, i_len, i_val << (UINT64_BIT_LEN - i_len) );
+ setFieldLeft(i_pos, i_len, i_val << (UINT64_BIT_LEN - i_len));
}
/**
@@ -166,7 +165,7 @@
* @return True if the bit at the given position is set(1), false otherwise.
* @pre i_pos < getBitLen().
*/
- bool isBitSet( uint64_t i_pos ) const
+ bool isBitSet(uint64_t i_pos) const
{
return 0 != getFieldRight(i_pos, 1);
}
@@ -176,7 +175,7 @@
* @param i_pos The target position.
* @pre i_pos < getBitLen().
*/
- void setBit( uint64_t i_pos ) { setFieldRight( i_pos, 1, 1 ); }
+ void setBit(uint64_t i_pos) { setFieldRight(i_pos, 1, 1); }
/** @brief Sets the entire bit string to 1's. */
void setAll() { setPattern(UINT64_MAX); }
@@ -186,7 +185,7 @@
* @param i_pos The target position.
* @pre i_pos < getBitLen().
*/
- void clearBit( uint64_t i_pos ) { setFieldRight( i_pos, 1, 0 ); }
+ void clearBit(uint64_t i_pos) { setFieldRight(i_pos, 1, 0); }
/** @brief Sets the entire bit string to 0's. */
void clearAll() { setPattern(0); }
@@ -212,8 +211,8 @@
* Old String: 0001001000
* New String: 0000110000
*/
- void setPattern( uint64_t i_sPos, uint64_t i_sLen,
- uint64_t i_pattern, uint64_t i_pLen );
+ void setPattern(uint64_t i_sPos, uint64_t i_sLen, uint64_t i_pattern,
+ uint64_t i_pLen);
/**
* @brief Sets entire string based on the pattern and length provided.
@@ -223,9 +222,9 @@
* @post The entire string is filled with the pattern.
* @post The pattern is repeated/truncated as needed.
*/
- void setPattern( uint64_t i_pattern, uint64_t i_pLen )
+ void setPattern(uint64_t i_pattern, uint64_t i_pLen)
{
- setPattern( 0, getBitLen(), i_pattern, i_pLen );
+ setPattern(0, getBitLen(), i_pattern, i_pLen);
}
/**
@@ -235,9 +234,9 @@
* @post The entire string is filled with the pattern.
* @post The pattern is repeated/truncated as needed.
*/
- void setPattern( uint64_t i_pattern )
+ void setPattern(uint64_t i_pattern)
{
- setPattern( i_pattern, sizeof(i_pattern) * 8 );
+ setPattern(i_pattern, sizeof(i_pattern) * 8);
}
/**
@@ -258,8 +257,8 @@
* string, then the extra bits in this string are not modified.
* @note This string and the source string may specify overlapping memory.
*/
- void setString( const BitString & i_sStr, uint64_t i_sPos,
- uint64_t i_sLen, uint64_t i_dPos = 0 );
+ void setString(const BitString & i_sStr, uint64_t i_sPos, uint64_t i_sLen,
+ uint64_t i_dPos = 0);
/**
* @brief Set bits in this string based on the provided string.
@@ -269,9 +268,9 @@
* @note See the other definition of this function for details and
* restrictions.
*/
- void setString( const BitString & i_sStr )
+ void setString(const BitString & i_sStr)
{
- setString( i_sStr, 0, i_sStr.getBitLen() );
+ setString(i_sStr, 0, i_sStr.getBitLen());
}
/**
@@ -283,7 +282,7 @@
* @note If the length of the given string is less than the length of this
* string, then the extra bits in this string are not modified.
*/
- void maskString( const BitString & i_mask );
+ void maskString(const BitString & i_mask);
/**
* @param i_str The string to compare.
@@ -291,7 +290,7 @@
* @pre Both strings must be of equal length and have same values to be
* equal.
*/
- bool isEqual( const BitString & i_str ) const;
+ bool isEqual(const BitString & i_str) const;
/** @return True if there are no bit set(1) in this bit string, false
* otherwise. */
@@ -304,28 +303,28 @@
* @pre nullptr != getBufAddr()
* @pre i_pos + i_len <= getBitLen()
*/
- uint64_t getSetCount( uint64_t i_pos, uint64_t i_len ) const;
+ uint64_t getSetCount(uint64_t i_pos, uint64_t i_len) const;
/** @return The number of bits that are set(1) in this string. */
- uint64_t getSetCount() const { return getSetCount( 0, getBitLen() ); }
+ uint64_t getSetCount() const { return getSetCount(0, getBitLen()); }
/** @brief Comparison operator. */
- bool operator==( const BitString & i_str ) const { return isEqual(i_str); }
+ bool operator==(const BitString & i_str) const { return isEqual(i_str); }
/** @brief Bitwise NOT operator. */
BitStringBuffer operator~() const;
/** @brief Bitwise AND operator. */
- BitStringBuffer operator&( const BitString & i_bs ) const;
+ BitStringBuffer operator&(const BitString & i_bs) const;
/** @brief Bitwise OR operator. */
- BitStringBuffer operator|( const BitString & i_bs ) const;
+ BitStringBuffer operator|(const BitString & i_bs) const;
/** @brief Right shift operator. */
- BitStringBuffer operator>>( uint64_t i_shift ) const;
+ BitStringBuffer operator>>(uint64_t i_shift) const;
/** @brief Left shift operator. */
- BitStringBuffer operator<<( uint64_t i_shift ) const;
+ BitStringBuffer operator<<(uint64_t i_shift) const;
/**
* @brief Explicitly disables copy from BitString.
@@ -333,7 +332,7 @@
* Prevents assigning a BitString & to a BitString, which would strip
* polymorphism.
*/
- BitString( const BitString & i_bs ) = delete;
+ BitString(const BitString & i_bs) = delete;
/**
* @brief Explicitly disables assignment from BitStringBuffer.
@@ -341,7 +340,7 @@
* Allowing this would be dangerous if the BitStringBuffer goes out of scope
* because the BitString would point to memory that is no longer in context.
*/
- BitString & operator=( const BitStringBuffer & i_bsb ) = delete;
+ BitString & operator=(const BitStringBuffer & i_bsb) = delete;
/**
* @brief Explicitly disables copy from BitStringBuffer.
@@ -349,7 +348,7 @@
* Allowing this would be dangerous if the BitStringBuffer goes out of scope
* because the BitString would point to memory that is no longer in context.
*/
- BitString( const BitStringBuffer & i_bsb ) = delete;
+ BitString(const BitStringBuffer & i_bsb) = delete;
protected: // functions
@@ -358,10 +357,10 @@
* @pre Before calling this function, make sure you deallocate the old
* buffer to avoid memory leaks.
*/
- void setBufAddr( void * i_newBufAddr ) { iv_bufAddr = i_newBufAddr; }
+ void setBufAddr(void * i_newBufAddr) { iv_bufAddr = i_newBufAddr; }
/** @param i_newBitLen The new bit length of this bit string buffer. */
- void setBitLen( uint64_t i_newBitLen ) { iv_bitLen = i_newBitLen; }
+ void setBitLen(uint64_t i_newBitLen) { iv_bitLen = i_newBitLen; }
private: // functions
@@ -375,8 +374,8 @@
* @pre nullptr != getBufAddr()
* @pre i_absPos < getBitLen()
*/
- uint8_t * getRelativePosition( uint64_t & o_relPos,
- uint64_t i_absPos ) const;
+ uint8_t * getRelativePosition(uint64_t & o_relPos,
+ uint64_t i_absPos) const;
private: // instance variables
@@ -402,22 +401,22 @@
* @brief Constructor
* @param i_bitLen Number of bits in the string.
*/
- explicit BitStringBuffer( uint64_t i_bitLen );
+ explicit BitStringBuffer(uint64_t i_bitLen);
/** @brief Destructor */
~BitStringBuffer();
/** @brief Copy constructor from BitString */
- BitStringBuffer( const BitString & i_bs );
+ BitStringBuffer(const BitString & i_bs);
/** @brief Copy constructor from BitStringBuffer */
- BitStringBuffer( const BitStringBuffer & i_bsb );
+ BitStringBuffer(const BitStringBuffer & i_bsb);
/** @brief Assignment from BitString */
- BitStringBuffer & operator=( const BitString & i_bs );
+ BitStringBuffer & operator=(const BitString & i_bs);
/** @brief Assignment from BitStringBuffer */
- BitStringBuffer & operator=( const BitStringBuffer & i_bsb );
+ BitStringBuffer & operator=(const BitStringBuffer & i_bsb);
private: // functions
@@ -427,4 +426,3 @@
};
} // end namespace libhei
-
diff --git a/src/util/hei_flyweight.hpp b/src/util/hei_flyweight.hpp
index f308e3c..cd56d82 100644
--- a/src/util/hei_flyweight.hpp
+++ b/src/util/hei_flyweight.hpp
@@ -20,10 +20,10 @@
~Flyweight() { clear(); }
/** @brief Default copy constructor. */
- Flyweight( const Flyweight & ) = delete;
+ Flyweight(const Flyweight &) = delete;
/** @brief Default assignment operator. */
- Flyweight & operator=( const Flyweight & ) = delete;
+ Flyweight & operator=(const Flyweight &) = delete;
public:
@@ -40,20 +40,21 @@
* @param The target entry.
* @return A reference to this entry in the factory.
*/
- T & get( const T & i_entry )
+ T & get(const T & i_entry)
{
// The index is sorted by the value of the T objects. Check to see if
// this entry already exists in the factory.
- auto itr = std::lower_bound( iv_index.begin(), iv_index.end(), &i_entry,
- [](const T * a, const T * b) { return *a < *b; } );
+ auto itr =
+ std::lower_bound(iv_index.begin(), iv_index.end(), &i_entry,
+ [](const T * a, const T * b) { return *a < *b; });
// std::lower_bound() will return the first element that does not
// compare less than i_entry. So if an entry is found, we must make sure
// it does not have the same value as i_entry.
- if ( iv_index.end() == itr || !(i_entry == *(*itr)) )
+ if (iv_index.end() == itr || !(i_entry == *(*itr)))
{
// Create a new entry and store the pointer in the sorted index.
- itr = iv_index.insert( itr, new T { i_entry } );
+ itr = iv_index.insert(itr, new T { i_entry });
}
// Return a reference to this entry in the factory.
@@ -67,7 +68,7 @@
*/
void clear()
{
- for ( auto i : iv_index ) { delete i; }
+ for (auto i : iv_index) { delete i; }
iv_index.clear();
}
@@ -105,4 +106,3 @@
};
} // end namespace libhei
-
diff --git a/test/bit_string_test.cpp b/test/bit_string_test.cpp
index 8320d97..8745911 100644
--- a/test/bit_string_test.cpp
+++ b/test/bit_string_test.cpp
@@ -14,23 +14,23 @@
// isBitSet()
// getSetCount()
// isZero()
-TEST( BitStringTest, TestSet1 )
+TEST(BitStringTest, TestSet1)
{
BitStringBuffer bs(UINT64_BIT_LEN);
uint32_t i;
// set all bits in ascending order
- for(i = 0; i < UINT64_BIT_LEN; i++)
+ for (i = 0; i < UINT64_BIT_LEN; i++)
{
// Make sure bit gets set and set count
// is increasing
bs.setBit(i);
ASSERT_TRUE(bs.isBitSet(i));
- ASSERT_EQ(bs.getSetCount(), i+1);
+ ASSERT_EQ(bs.getSetCount(), i + 1);
}
// all bits should be set at this point
- ASSERT_EQ(bs.getFieldRight(0,64), UINT64_MAX);
- ASSERT_EQ(bs.getFieldLeft(0,64), UINT64_MAX);
+ ASSERT_EQ(bs.getFieldRight(0, 64), UINT64_MAX);
+ ASSERT_EQ(bs.getFieldLeft(0, 64), UINT64_MAX);
// test clearAll(), setAll()
bs.clearAll();
@@ -39,23 +39,23 @@
ASSERT_EQ(bs.getSetCount(), UINT64_BIT_LEN);
// clear all bits in descending order
- for(i = UINT64_BIT_LEN; 0 != i; i--)
+ for (i = UINT64_BIT_LEN; 0 != i; i--)
{
// make sure bit gets cleared and set count
// is decreasing
ASSERT_EQ(bs.getSetCount(), i);
- bs.clearBit(i-1);
- ASSERT_FALSE(bs.isBitSet(i-1));
+ bs.clearBit(i - 1);
+ ASSERT_FALSE(bs.isBitSet(i - 1));
}
// all bits should be clear at this point
ASSERT_EQ(bs.getSetCount(), 0u);
- ASSERT_EQ(bs.getFieldRight(0,64), 0u);
- ASSERT_EQ(bs.getFieldLeft(0,64), 0u);
+ ASSERT_EQ(bs.getFieldRight(0, 64), 0u);
+ ASSERT_EQ(bs.getFieldLeft(0, 64), 0u);
ASSERT_TRUE(bs.isZero());
}
// setPattern()
-TEST( BitStringTest, TestSet2 )
+TEST(BitStringTest, TestSet2)
{
BitStringBuffer bs(UINT64_BIT_LEN);
uint64_t field = 0xaaaaaaaaaaaaaaaa;
@@ -80,7 +80,7 @@
}
// setString()
-TEST( BitStringTest, TestSet3 )
+TEST(BitStringTest, TestSet3)
{
BitStringBuffer bsb_dest(64);
BitStringBuffer bsb_src(64);
@@ -93,12 +93,12 @@
bsb_dest.setString(bsb_src);
ASSERT_FALSE(bsb_dest.isZero());
- ASSERT_EQ(bsb_dest.getFieldRight(0, 64), bsb_src.getFieldRight(0,64));
- ASSERT_EQ(bsb_dest.getFieldLeft(0, 64), bsb_src.getFieldLeft(0,64));
+ ASSERT_EQ(bsb_dest.getFieldRight(0, 64), bsb_src.getFieldRight(0, 64));
+ ASSERT_EQ(bsb_dest.getFieldLeft(0, 64), bsb_src.getFieldLeft(0, 64));
}
// maskString()
-TEST( BitStringTest, TestSet4 )
+TEST(BitStringTest, TestSet4)
{
BitStringBuffer bsb(64);
bsb.setAll();
@@ -115,49 +115,48 @@
// setFieldLeft()
// getFielRight()
// getFieldLeft()
-TEST( BitStringTest, TestSet5 )
+TEST(BitStringTest, TestSet5)
{
uint64_t field = 0x1234567890abcdef;
BitStringBuffer bsb(64);
// set bitstring to low end of field
bsb.setFieldRight(0, 32, field);
- ASSERT_EQ(field << 32, bsb.getFieldLeft(0,32));
+ ASSERT_EQ(field << 32, bsb.getFieldLeft(0, 32));
// set bitstring to high end of field
bsb.setFieldLeft(0, 32, field);
- ASSERT_EQ(field >> 32, bsb.getFieldRight(0,32));
+ ASSERT_EQ(field >> 32, bsb.getFieldRight(0, 32));
// increasing offset
- for(uint32_t i = 0; i < UINT64_BIT_LEN; i++)
+ for (uint32_t i = 0; i < UINT64_BIT_LEN; i++)
{
// increasing length
- for(uint32_t j = 1; j <= UINT64_BIT_LEN - i; j++)
+ for (uint32_t j = 1; j <= UINT64_BIT_LEN - i; j++)
{
bsb.clearAll();
bsb.setFieldRight(i, j, UINT64_MAX);
// verify
- ASSERT_EQ(bsb.getFieldRight(i, j), \
- UINT64_MAX >> (UINT64_BIT_LEN - j));
-
+ ASSERT_EQ(bsb.getFieldRight(i, j),
+ UINT64_MAX >> (UINT64_BIT_LEN - j));
}
}
- for(uint32_t i = 0; i < UINT64_BIT_LEN; i++)
+ for (uint32_t i = 0; i < UINT64_BIT_LEN; i++)
{
// set 1 bit at offset i
bsb.clearAll();
bsb.setFieldRight(i, 1, 1);
// verify bit is set
- ASSERT_EQ(bsb.getFieldRight(0, 64), (uint64_t)1 << \
- (UINT64_BIT_LEN - i - 1));
+ ASSERT_EQ(bsb.getFieldRight(0, 64),
+ (uint64_t)1 << (UINT64_BIT_LEN - i - 1));
}
}
// operator >>
// operator <<
-TEST( BitStringTest, TestSet6 )
+TEST(BitStringTest, TestSet6)
{
uint64_t field = 0x1234567890abcdef;
BitStringBuffer bsb(64);
diff --git a/test/flyweight_test.cpp b/test/flyweight_test.cpp
index 83b33c0..118f24e 100644
--- a/test/flyweight_test.cpp
+++ b/test/flyweight_test.cpp
@@ -8,20 +8,20 @@
{
public:
Foo() = default;
- explicit Foo( int i ) : iv_i(i) {}
+ explicit Foo(int i) : iv_i(i) {}
int get() const { return iv_i; }
- bool operator==( const Foo & i_r ) const { return iv_i == i_r.iv_i; }
- bool operator<( const Foo & i_r ) const { return iv_i < i_r.iv_i; }
+ bool operator==(const Foo & i_r) const { return iv_i == i_r.iv_i; }
+ bool operator<(const Foo & i_r) const { return iv_i < i_r.iv_i; }
private:
int iv_i = 0;
};
-Foo & addFoo( int i )
+Foo & addFoo(int i)
{
- return Flyweight<Foo>::getSingleton().get( Foo { i } );
+ return Flyweight<Foo>::getSingleton().get(Foo { i });
}
-TEST( FlyweightTest, TestSet1 )
+TEST(FlyweightTest, TestSet1)
{
// Add some unique entries in a random order and keep track of where those
// enties exist in memory.
@@ -34,9 +34,9 @@
// Now add more entries and verify the 'new' entries match the same
// addresses as the previously added entries.
- for ( int i = 4; i >= 0; i-- )
+ for (int i = 4; i >= 0; i--)
{
- ASSERT_EQ( a[i], &(addFoo(i)) );
+ ASSERT_EQ(a[i], &(addFoo(i)));
}
// At this point, we have proven that duplicate entries will return
diff --git a/test/hei_user_defines.hpp b/test/hei_user_defines.hpp
index 8b23473..eec606d 100644
--- a/test/hei_user_defines.hpp
+++ b/test/hei_user_defines.hpp
@@ -1,25 +1,24 @@
#pragma once
/**
-* @file hei_user_defines.hpp
-* @brief The purpose of this file is to create common defines that
-* will be used throughout this library.
-**/
+ * @file hei_user_defines.hpp
+ * @brief The purpose of this file is to create common defines that
+ * will be used throughout this library.
+ */
#include <stdio.h>
#include <assert.h>
-#define HEI_INF( ... ) \
-{ \
- printf( "I> " __VA_ARGS__ ); \
- printf( "\n" ); \
-}
+#define HEI_INF(...) \
+ { \
+ printf("I> " __VA_ARGS__); \
+ printf("\n"); \
+ }
-#define HEI_ERR( ... ) \
-{ \
- printf( "E> " __VA_ARGS__ ); \
- printf( "\n" ); \
-}
+#define HEI_ERR(...) \
+ { \
+ printf("E> " __VA_ARGS__); \
+ printf("\n"); \
+ }
-#define HEI_ASSERT( expression ) \
- assert( expression );
+#define HEI_ASSERT(expression) assert(expression);
diff --git a/test/simulator/hei_sim_main.cpp b/test/simulator/hei_sim_main.cpp
index 46de629..166b54e 100644
--- a/test/simulator/hei_sim_main.cpp
+++ b/test/simulator/hei_sim_main.cpp
@@ -7,7 +7,7 @@
void * buffer = nullptr;
size_t sz_buffer = 0;
- initialize( buffer, sz_buffer );
+ initialize(buffer, sz_buffer);
Chip c1, c2;
@@ -17,7 +17,7 @@
IsolationData isoData;
- isolate( chipList, isoData );
+ isolate(chipList, isoData);
uninitialize();
diff --git a/test/simulator/hei_sim_user_interface.cpp b/test/simulator/hei_sim_user_interface.cpp
index c3baeb3..073ae22 100644
--- a/test/simulator/hei_sim_user_interface.cpp
+++ b/test/simulator/hei_sim_user_interface.cpp
@@ -7,21 +7,21 @@
//------------------------------------------------------------------------------
-ReturnCode registerRead( void * i_chip, void * o_buffer, size_t & io_bufSize,
- uint64_t i_regType, uint64_t i_address )
+ReturnCode registerRead(void * i_chip, void * o_buffer, size_t & io_bufSize,
+ uint64_t i_regType, uint64_t i_address)
{
ReturnCode rc;
- HEI_ASSERT( nullptr != i_chip );
- HEI_ASSERT( nullptr != o_buffer );
- HEI_ASSERT( 0 != io_bufSize );
+ HEI_ASSERT(nullptr != i_chip);
+ HEI_ASSERT(nullptr != o_buffer);
+ HEI_ASSERT(0 != io_bufSize);
- switch ( i_regType )
+ switch (i_regType)
{
default:
rc = RC_REG_ACCESS_FAILURE;
- HEI_ERR( "registerRead(%p,%p,%lx,%lx,%lx)", i_chip, o_buffer,
- io_bufSize, i_regType, i_address );
+ HEI_ERR("registerRead(%p,%p,%lx,%lx,%lx)", i_chip, o_buffer,
+ io_bufSize, i_regType, i_address);
}
return rc;
@@ -31,21 +31,21 @@
#ifndef __HEI_READ_ONLY
-ReturnCode registerWrite( void * i_chip, void * i_buffer, size_t & io_bufSize,
- uint64_t i_regType, uint64_t i_address )
+ReturnCode registerWrite(void * i_chip, void * i_buffer, size_t & io_bufSize,
+ uint64_t i_regType, uint64_t i_address)
{
ReturnCode rc;
- HEI_ASSERT( nullptr != i_chip );
- HEI_ASSERT( nullptr != i_buffer );
- HEI_ASSERT( 0 != io_bufSize );
+ HEI_ASSERT(nullptr != i_chip);
+ HEI_ASSERT(nullptr != i_buffer);
+ HEI_ASSERT(0 != io_bufSize);
- switch ( i_regType )
+ switch (i_regType)
{
default:
rc = RC_REG_ACCESS_FAILURE;
- HEI_ERR( "registerWrite(%p,%p,%lx,%lx,%lx)", i_chip, i_buffer,
- io_bufSize, i_regType, i_address );
+ HEI_ERR("registerWrite(%p,%p,%lx,%lx,%lx)", i_chip, i_buffer,
+ io_bufSize, i_regType, i_address);
}
return rc;
@@ -56,4 +56,3 @@
//------------------------------------------------------------------------------
} // end namespace libhei
-