tier1: Use x86-64 lengths for bitbuf APIs

Author: dimhotepus

public/tier1/bitbuf.h

@@ -169,32 +169,31 @@ class bf_write
 	void			SetDebugName( const char *pDebugName );
 
 
-// Seek to a specific position.
 public:
-	
+	// Seek to a specific position.	
 	void			SeekToBit( intp bitPos );
 
 
 // Bit functions.
 public:
 
-	void			WriteOneBit(int nValue);
-	void			WriteOneBitNoCheck(int nValue);
+	void			WriteOneBit( int nValue );
+	void			WriteOneBitNoCheck( int nValue );
 	void			WriteOneBitAt( int iBit, int nValue );
 
 	// Write signed or unsigned. Range is only checked in debug.
-	void			WriteUBitLong( unsigned int data, int numbits, bool bCheckRange=true );
-	void			WriteSBitLong( int data, int numbits );
+	void			WriteUBitLong( uint32 data, int numbits, bool bCheckRange=true );
+	void			WriteSBitLong( int32 data, int numbits );
 
 	// Tell it whether or not the data is unsigned. If it's signed,
 	// cast to unsigned before passing in (it will cast back inside).
-	void			WriteBitLong(unsigned int data, int numbits, bool bSigned);
+	void			WriteBitLong( uint32 data, int numbits, bool bSigned );
 
 	// Write a list of bits in.
-	bool			WriteBits(const void *pIn, int nBits);
+	bool			WriteBits( const void *pIn, intp nBits );
 
 	// writes an unsigned integer with variable bit length
-	void			WriteUBitVar( unsigned int data );
+	void			WriteUBitVar( uint32 data );
 
 	// writes a varint encoded integer
 	void			WriteVarInt32( uint32 data );
@@ -208,12 +207,12 @@ class bf_write
 
 	// Copy the bits straight out of pIn. This seeks pIn forward by nBits.
 	// Returns an error if this buffer or the read buffer overflows.
-	bool			WriteBitsFromBuffer( class bf_read *pIn, int nBits );
+	bool			WriteBitsFromBuffer( class bf_read *pIn, intp nBits );
 
 	void			WriteBitAngle( float fAngle, int numbits );
-	void			WriteBitCoord (const float f);
+	void			WriteBitCoord( const float f );
 	void			WriteBitCoordMP( const float f, bool bIntegral, bool bLowPrecision );
-	void			WriteBitFloat(float val);
+	void			WriteBitFloat( float val );
 	void			WriteBitVec3Coord( const Vector& fa );
 	void			WriteBitNormal( float f );
 	void			WriteBitVec3Normal( const Vector& fa );
@@ -232,7 +231,7 @@ class bf_write
 	void			WriteLongLong(int64 val);
 	void			WriteULongLong(uint64 val);
 	void			WriteFloat(float val);
-	bool			WriteBytes( const void *pBuf, int nBytes );
+	bool			WriteBytes( const void *pBuf, intp nBytes );
 
 	// Returns false if it overflows the buffer.
 	bool			WriteString(const char *pStr);
@@ -247,8 +246,8 @@ class bf_write
 	[[nodiscard]] intp				GetMaxNumBits() const;
 	[[nodiscard]] intp				GetNumBitsLeft() const;
 	[[nodiscard]] intp				GetNumBytesLeft() const;
-	[[nodiscard]] unsigned char*	GetData();
-	[[nodiscard]] const unsigned char*	GetData() const;
+	[[nodiscard]] byte*	GetData();
+	[[nodiscard]] const byte*	GetData() const;
 
 	// Has the buffer overflowed?
 	[[nodiscard]] bool			CheckForOverflow(intp nBits);
@@ -306,14 +305,14 @@ inline intp bf_write::GetNumBytesLeft() const
 	return GetNumBitsLeft() >> 3;
 }
 
-inline unsigned char* bf_write::GetData() //-V524
+inline byte* bf_write::GetData() //-V524
 {
-	return (unsigned char*) m_pData;
+	return (byte*) m_pData;
 }
 
-inline const unsigned char* bf_write::GetData()	const
+inline const byte* bf_write::GetData()	const
 {
-	return (unsigned char*) m_pData;
+	return (byte*) m_pData;
 }
 
 BITBUF_INLINE bool bf_write::CheckForOverflow(intp nBits)
@@ -391,7 +390,7 @@ inline void	bf_write::WriteOneBitAt( int iBit, int nValue )
 #endif
 }
 
-BITBUF_INLINE void bf_write::WriteUBitLong( unsigned int curData, int numbits, [[maybe_unused]] bool bCheckRange )
+BITBUF_INLINE void bf_write::WriteUBitLong( uint32 curData, int numbits, [[maybe_unused]] bool bCheckRange )
 {
 #ifdef _DEBUG
 	// Make sure it doesn't overflow.
@@ -444,7 +443,7 @@ BITBUF_INLINE void bf_write::WriteUBitLong( unsigned int curData, int numbits, [
 }
 
 // writes an unsigned integer with variable bit length
-BITBUF_INLINE void bf_write::WriteUBitVar( unsigned int data )
+BITBUF_INLINE void bf_write::WriteUBitVar( uint32 data )
 {
 	/* Reference:
 	if ( data < 0x10u )
@@ -544,7 +543,7 @@ class bf_read
 	// Get the base pointer.
 	[[nodiscard]] const unsigned char*	GetBasePointer() const { return m_pData; }
 
-	[[nodiscard]] BITBUF_INLINE intp TotalBytesAvailable( void ) const
+	[[nodiscard]] BITBUF_INLINE intp TotalBytesAvailable() const
 	{
 		return m_nDataBytes;
 	}
@@ -554,23 +553,23 @@ class bf_read
 	// Read a list of bits in, but don't overrun the destination buffer.
 	// Returns the number of bits read into the buffer. The remaining
 	// bits are skipped over.
-	int             ReadBitsClamped_ptr(void *pOut, size_t outSizeBytes, size_t nBits);
+	intp            ReadBitsClamped_ptr(void *pOut, intp outSizeBytes, intp nBits);
 	// Helper 'safe' template function that infers the size of the destination
 	// array. This version of the function should be preferred.
 	// Usage: char databuffer[100];
 	//        ReadBitsClamped( dataBuffer, msg->m_nLength );
-	template <typename T, size_t N>
-	int ReadBitsClamped( T (&pOut)[N], size_t nBits )
+	template <typename T, intp N>
+	intp ReadBitsClamped( T (&pOut)[N], intp nBits )
 	{
 		return ReadBitsClamped_ptr( pOut, N * sizeof(T), nBits );
 	}
 
 	[[nodiscard]] float			ReadBitAngle( int numbits );
 
-	[[nodiscard]] unsigned int	ReadUBitLong( int numbits );
-	[[nodiscard]] unsigned int	ReadUBitLongNoInline( int numbits );
-	[[nodiscard]] unsigned int	PeekUBitLong( int numbits );
-	[[nodiscard]] int			ReadSBitLong( int numbits );
+	[[nodiscard]] uint32		ReadUBitLong( int numbits );
+	[[nodiscard]] uint32		ReadUBitLongNoInline( int numbits );
+	[[nodiscard]] uint32		PeekUBitLong( int numbits );
+	[[nodiscard]] int32			ReadSBitLong( int numbits );
 
 	// reads an unsigned integer with variable bit length
 	[[nodiscard]] unsigned int	ReadUBitVar();
@@ -792,7 +791,7 @@ BITBUF_INLINE unsigned int bf_read::ReadUBitVar()
 	return sixbits >> 2;
 }
 
-BITBUF_INLINE unsigned int bf_read::ReadUBitLong( int numbits )
+BITBUF_INLINE uint32 bf_read::ReadUBitLong( int numbits )
 {
 	Assert( numbits > 0 && numbits <= 32 );
 

tier1/bitbuf.cpp

@@ -193,12 +193,12 @@ void bf_write::SeekToBit( intp bitPos )
 
 
 // Sign bit comes first
-void bf_write::WriteSBitLong( int data, int numbits )
+void bf_write::WriteSBitLong( int32 data, int numbits )
 {
 	// Force the sign-extension bit to be correct even in the case of overflow.
-	int nValue = data;
-	int nPreserveBits = ( 0x7FFFFFFF >> ( static_cast<int>(CHAR_BIT * sizeof(int32)) - numbits ) );
-	int nSignExtension = ( nValue >> 31 ) & ~nPreserveBits;
+	int32 nValue = data;
+	int32 nPreserveBits = ( 0x7FFFFFFF >> ( static_cast<int32>(CHAR_BIT * sizeof(int32)) - numbits ) );
+	int32 nSignExtension = ( nValue >> 31 ) & ~nPreserveBits;
 	nValue &= nPreserveBits;
 	nValue |= nSignExtension;
 
@@ -423,22 +423,22 @@ int bf_write::ByteSizeSignedVarInt64( int64 data )
 	return ByteSizeVarInt64( bitbuf::ZigZagEncode64( data ) );
 }
 
-void bf_write::WriteBitLong(unsigned int data, int numbits, bool bSigned)
+void bf_write::WriteBitLong(uint32 data, int numbits, bool bSigned)
 {
 	if(bSigned)
-		WriteSBitLong((int)data, numbits);
+		WriteSBitLong((int32)data, numbits);
 	else
 		WriteUBitLong(data, numbits);
 }
 
-bool bf_write::WriteBits(const void *pInData, int nBits)
+bool bf_write::WriteBits(const void *pInData, intp nBits)
 {
 #if defined( BB_PROFILING )
 	VPROF( "bf_write::WriteBits" );
 #endif
 
-	unsigned char *pOut = (unsigned char*)pInData;
-	int nBitsLeft = nBits;
+	const auto *pOut = (const unsigned char*)pInData;
+	intp nBitsLeft = nBits;
 
 	// Bounds checking..
 	if ( (m_iCurBit+nBits) > m_nDataBits )
@@ -459,8 +459,8 @@ bool bf_write::WriteBits(const void *pInData, int nBits)
 	if ( (nBitsLeft >= 32) && (m_iCurBit & 7) == 0 )
 	{
 		// current bit is byte aligned, do block copy
-		int numbytes = nBitsLeft / CHAR_BIT; 
-		int numbits = numbytes * CHAR_BIT;
+		intp numbytes = nBitsLeft / CHAR_BIT; 
+		intp numbits = numbytes * CHAR_BIT;
 
 		Q_memcpy( (char*)m_pData+(m_iCurBit>>3), pOut, numbytes );
 		pOut += numbytes;
@@ -513,14 +513,14 @@ bool bf_write::WriteBits(const void *pInData, int nBits)
 	// write remaining bits
 	if ( nBitsLeft )
 	{
-		WriteUBitLong( *pOut, nBitsLeft, false );
+		WriteUBitLong( *pOut, static_cast<int>(nBitsLeft), false );
 	}
 
 	return !IsOverflowed();
 }
 
 
-bool bf_write::WriteBitsFromBuffer( bf_read *pIn, int nBits )
+bool bf_write::WriteBitsFromBuffer( bf_read *pIn, intp nBits )
 {
 	constexpr int kUint32Bits = CHAR_BIT * sizeof(uint32);
 
@@ -531,7 +531,7 @@ bool bf_write::WriteBitsFromBuffer( bf_read *pIn, int nBits )
 		nBits -= kUint32Bits;
 	}
 
-	WriteUBitLong( pIn->ReadUBitLong( nBits ), nBits );
+	WriteUBitLong( pIn->ReadUBitLong( static_cast<int>(nBits) ), static_cast<int>(nBits) );
 	return !IsOverflowed() && !pIn->IsOverflowed();
 }
 
@@ -766,7 +766,7 @@ void bf_write::WriteFloat(float val)
 	WriteBits(&val, sizeof(val) * CHAR_BIT);
 }
 
-bool bf_write::WriteBytes( const void *pBuf, int nBytes )
+bool bf_write::WriteBytes( const void *pBuf, intp nBytes )
 {
 	return WriteBits(pBuf, nBytes * CHAR_BIT);
 }
@@ -887,7 +887,7 @@ void bf_read::ReadBits(void *pOutData, intp nBits)
 #endif
 
 	uint8 *pOut = static_cast<uint8 *>(pOutData);
-	int nBitsLeft = nBits;
+	intp nBitsLeft = nBits;
 
 	// align output to dword boundary
 	while( ((size_t)pOut & 3) != 0 && nBitsLeft >= CHAR_BIT )
@@ -919,23 +919,22 @@ void bf_read::ReadBits(void *pOutData, intp nBits)
 	// read remaining bits
 	if ( nBitsLeft )
 	{
-		*pOut = static_cast<uint8>(ReadUBitLong(nBitsLeft));
+		*pOut = static_cast<uint8>(ReadUBitLong(static_cast<int>(nBitsLeft)));
 	}
-
 }
 
-int bf_read::ReadBitsClamped_ptr(void *pOutData, size_t outSizeBytes, size_t nBits)
+intp bf_read::ReadBitsClamped_ptr(void *pOutData, intp outSizeBytes, intp nBits)
 {
-	size_t outSizeBits = outSizeBytes * CHAR_BIT;
-	size_t readSizeBits = nBits;
-	int skippedBits = 0;
+	intp outSizeBits = outSizeBytes * CHAR_BIT;
+	intp readSizeBits = nBits;
+	intp skippedBits = 0;
 	if ( readSizeBits > outSizeBits )
 	{
 		// Should we print a message when we clamp the data being read? Only
 		// in debug builds I think.
 		AssertMsg( 0, "Oversized network packet received, and clamped." );
 		readSizeBits = outSizeBits;
-		skippedBits = (int)( nBits - outSizeBits );
+		skippedBits = nBits - outSizeBits;
 		// What should we do in this case, which should only happen if nBits
 		// is negative for some reason?
 		//if ( skippedBits < 0 )
@@ -946,7 +945,7 @@ int bf_read::ReadBitsClamped_ptr(void *pOutData, size_t outSizeBytes, size_t nBi
 	SeekRelative( skippedBits );
 
 	// Return the number of bits actually read.
-	return (int)readSizeBits;
+	return readSizeBits;
 }
 
 float bf_read::ReadBitAngle( int numbits )
@@ -959,15 +958,15 @@ float bf_read::ReadBitAngle( int numbits )
 	return fReturn;
 }
 
-unsigned int bf_read::PeekUBitLong( int numbits )
+uint32 bf_read::PeekUBitLong( int numbits )
 {
 #ifdef BIT_VERBOSE
 	int nShifts = numbits;
 #endif
 
 	bf_read savebf = *this;  // Save current state info
 
-	unsigned r = 0;
+	uint32 r = 0;
 	for(int i=0; i < numbits; i++)
 	{
 		int nBitValue = ReadOneBit();
@@ -988,7 +987,7 @@ unsigned int bf_read::PeekUBitLong( int numbits )
 	return r;
 }
 
-unsigned int bf_read::ReadUBitLongNoInline( int numbits )
+uint32 bf_read::ReadUBitLongNoInline( int numbits )
 {
 	return ReadUBitLong( numbits );
 }
@@ -1002,10 +1001,10 @@ unsigned int bf_read::ReadUBitVarInternal( int encodingType )
 }
 
 // Append numbits least significant bits from data to the current bit stream
-int bf_read::ReadSBitLong( int numbits )
+int32 bf_read::ReadSBitLong( int numbits )
 {
-	unsigned int r = ReadUBitLong(numbits);
-	unsigned int s = 1 << (numbits-1);
+	uint32 r = ReadUBitLong(numbits);
+	uint32 s = 1 << (numbits-1);
 	if (r >= s)
 	{
 		// sign-extend by removing sign bit and then subtracting sign bit again