Cut-in CRYPTOPP_ASSERT in all remaining header and source files

1 files changed, 38 insertions, 38 deletions

diff --git a/filters.cpp b/filters.cpp
index 1b46127f..20fb1cc1 100644
--- a/filters.cpp
+++ b/filters.cpp
@@ -108,7 +108,7 @@ void Filter::PropagateInitialize(const NameValuePairs &parameters, int propagati
 
 size_t Filter::OutputModifiable(int outputSite, byte *inString, size_t length, int messageEnd, bool blocking, const std::string &channel)
 {
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
 	if (messageEnd)
@@ -121,7 +121,7 @@ size_t Filter::OutputModifiable(int outputSite, byte *inString, size_t length, i
 size_t Filter::Output(int outputSite, const byte *inString, size_t length, int messageEnd, bool blocking, const std::string &channel)
 {
 	// Formerly fired because inString was not NULL, but length was 0.
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
 	if (messageEnd)
@@ -186,7 +186,7 @@ size_t MeterFilter::PutMaybeModifiable(byte *begin, size_t length, int messageEn
 		{
 			FILTER_OUTPUT_MAYBE_MODIFIABLE(1, m_begin, t = (size_t)SaturatingSubtract(m_rangesToSkip.front().position, m_currentMessageBytes), false, modifiable);
 
-			assert(t < m_length);
+			CRYPTOPP_ASSERT(t < m_length);
 			m_begin += t;
 			m_length -= t;
 			m_currentMessageBytes += t;
@@ -197,7 +197,7 @@ size_t MeterFilter::PutMaybeModifiable(byte *begin, size_t length, int messageEn
 			else
 			{
 				t = (size_t)SaturatingSubtract(m_rangesToSkip.front().position + m_rangesToSkip.front().size, m_currentMessageBytes);
-				assert(t <= m_length);
+				CRYPTOPP_ASSERT(t <= m_length);
 				m_rangesToSkip.pop_front();
 			}
 
@@ -299,7 +299,7 @@ size_t FilterWithBufferedInput::BlockQueue::Put(const byte *inString, size_t len
 	if (!inString || !length) return length;
 	if (!m_buffer.data()) return length;
 
-	assert(m_size + length <= m_buffer.size());
+	CRYPTOPP_ASSERT(m_size + length <= m_buffer.size());
 	byte *end = (m_size < size_t(m_buffer.end()-m_begin)) ? m_begin + m_size : m_begin + m_size - m_buffer.size();
 	size_t len = STDMIN(length, size_t(m_buffer.end()-end));
 	memcpy(end, inString, len);
@@ -347,7 +347,7 @@ bool FilterWithBufferedInput::IsolatedFlush(bool hardFlush, bool blocking)
 
 size_t FilterWithBufferedInput::PutMaybeModifiable(byte *inString, size_t length, int messageEnd, bool blocking, bool modifiable)
 {
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
 	if (!blocking)
@@ -362,7 +362,7 @@ size_t FilterWithBufferedInput::PutMaybeModifiable(byte *inString, size_t length
 			size_t len = m_firstSize - m_queue.CurrentSize();
 			m_queue.Put(inString, len);
 			FirstPut(m_queue.GetContigousBlocks(m_firstSize));
-			assert(m_queue.CurrentSize() == 0);
+			CRYPTOPP_ASSERT(m_queue.CurrentSize() == 0);
 			m_queue.ResetQueue(m_blockSize, (2*m_blockSize+m_lastSize-2)/m_blockSize);
 
 			inString += len;
@@ -400,7 +400,7 @@ size_t FilterWithBufferedInput::PutMaybeModifiable(byte *inString, size_t length
 
 				if (newLength >= m_blockSize + m_lastSize && m_queue.CurrentSize() > 0)
 				{
-					assert(m_queue.CurrentSize() < m_blockSize);
+					CRYPTOPP_ASSERT(m_queue.CurrentSize() < m_blockSize);
 					size_t len = m_blockSize - m_queue.CurrentSize();
 					m_queue.Put(inString, len);
 					inString += len;
@@ -458,13 +458,13 @@ void FilterWithBufferedInput::ForceNextPut()
 
 void FilterWithBufferedInput::NextPutMultiple(const byte *inString, size_t length)
 {
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
-	assert(m_blockSize > 1);	// m_blockSize = 1 should always override this function
+	CRYPTOPP_ASSERT(m_blockSize > 1);	// m_blockSize = 1 should always override this function
 	while (length > 0)
 	{
-		assert(length >= m_blockSize);
+		CRYPTOPP_ASSERT(length >= m_blockSize);
 		NextPutSingle(inString);
 		inString += m_blockSize;
 		length -= m_blockSize;
@@ -577,7 +577,7 @@ StreamTransformationFilter::StreamTransformationFilter(StreamTransformation &c,
    : FilterWithBufferedInput(attachment)
 	, m_cipher(c)
 {
-	assert(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize());
+	CRYPTOPP_ASSERT(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize());
 
 	if (!allowAuthenticatedSymmetricCipher && dynamic_cast<AuthenticatedSymmetricCipher *>(&c) != 0)
 		throw InvalidArgument("StreamTransformationFilter: please use AuthenticatedEncryptionFilter and AuthenticatedDecryptionFilter for AuthenticatedSymmetricCipher");
@@ -616,14 +616,14 @@ void StreamTransformationFilter::InitializeDerivedAndReturnNewSizes(const NameVa
 void StreamTransformationFilter::FirstPut(const byte *inString)
 {
 	// FilterWithBufferedInput::PutMaybeModifiable causes this to fire.
-	// assert(inString);
+	// CRYPTOPP_ASSERT(inString);
 	m_optimalBufferSize = m_cipher.OptimalBlockSize();
 	m_optimalBufferSize = (unsigned int)STDMAX(m_optimalBufferSize, RoundDownToMultipleOf(4096U, m_optimalBufferSize));
 }
 
 void StreamTransformationFilter::NextPutMultiple(const byte *inString, size_t length)
 {
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
 	size_t s = m_cipher.MandatoryBlockSize();
@@ -652,7 +652,7 @@ void StreamTransformationFilter::NextPutMultiple(const byte *inString, size_t le
 
 void StreamTransformationFilter::NextPutModifiable(byte *inString, size_t length)
 {
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
 	m_cipher.ProcessString(inString, length);
@@ -661,7 +661,7 @@ void StreamTransformationFilter::NextPutModifiable(byte *inString, size_t length
 
 void StreamTransformationFilter::LastPut(const byte *inString, size_t length)
 {
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
 	byte *space = NULL;
@@ -707,16 +707,16 @@ void StreamTransformationFilter::LastPut(const byte *inString, size_t length)
 	case ONE_AND_ZEROS_PADDING:
 		unsigned int s;
 		s = m_cipher.MandatoryBlockSize();
-		assert(s > 1);
+		CRYPTOPP_ASSERT(s > 1);
 		space = HelpCreatePutSpace(*AttachedTransformation(), DEFAULT_CHANNEL, s, m_optimalBufferSize);
 		if (m_cipher.IsForwardTransformation())
 		{
-			assert(length < s);
+			CRYPTOPP_ASSERT(length < s);
 			if (inString && length)
 				memcpy(space, inString, length);
 			if (m_padding == PKCS_PADDING)
 			{
-				assert(s < 256);
+				CRYPTOPP_ASSERT(s < 256);
 				byte pad = byte(s-length);
 				memset(space+length, pad, s-length);
 			}
@@ -752,7 +752,7 @@ void StreamTransformationFilter::LastPut(const byte *inString, size_t length)
 		break;
 
 	default:
-		assert(false);
+		CRYPTOPP_ASSERT(false);
 	}
 }
 
@@ -774,7 +774,7 @@ void HashFilter::IsolatedInitialize(const NameValuePairs &parameters)
 
 size_t HashFilter::Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
 {
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
 	FILTER_BEGIN;
@@ -816,7 +816,7 @@ void HashVerificationFilter::InitializeDerivedAndReturnNewSizes(const NameValueP
 void HashVerificationFilter::FirstPut(const byte *inString)
 {
 	// FilterWithBufferedInput::PutMaybeModifiable causes this to fire.
-	// assert(inString);
+	// CRYPTOPP_ASSERT(inString);
 
 	if (m_flags & HASH_AT_BEGIN)
 	{
@@ -831,7 +831,7 @@ void HashVerificationFilter::FirstPut(const byte *inString)
 
 void HashVerificationFilter::NextPutMultiple(const byte *inString, size_t length)
 {
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
 	m_hashModule.Update(inString, length);
@@ -841,12 +841,12 @@ void HashVerificationFilter::NextPutMultiple(const byte *inString, size_t length
 
 void HashVerificationFilter::LastPut(const byte *inString, size_t length)
 {
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
 	if (m_flags & HASH_AT_BEGIN)
 	{
-		assert(length == 0);
+		CRYPTOPP_ASSERT(length == 0);
 		m_verified = m_hashModule.TruncatedVerify(m_expectedHash, m_digestSize);
 	}
 	else
@@ -870,7 +870,7 @@ AuthenticatedEncryptionFilter::AuthenticatedEncryptionFilter(AuthenticatedSymmet
 	: StreamTransformationFilter(c, attachment, padding, true)
 	, m_hf(c, new OutputProxy(*this, false), putAAD, truncatedDigestSize, AAD_CHANNEL, macChannel)
 {
-	assert(c.IsForwardTransformation());
+	CRYPTOPP_ASSERT(c.IsForwardTransformation());
 }
 
 void AuthenticatedEncryptionFilter::IsolatedInitialize(const NameValuePairs &parameters)
@@ -903,7 +903,7 @@ size_t AuthenticatedEncryptionFilter::ChannelPut2(const std::string &channel, co
 
 void AuthenticatedEncryptionFilter::LastPut(const byte *inString, size_t length)
 {
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
 	StreamTransformationFilter::LastPut(inString, length);
@@ -917,7 +917,7 @@ AuthenticatedDecryptionFilter::AuthenticatedDecryptionFilter(AuthenticatedSymmet
 	, m_hashVerifier(c, new OutputProxy(*this, false))
 	, m_streamFilter(c, new OutputProxy(*this, false), padding, true)
 {
-	assert(!c.IsForwardTransformation() || c.IsSelfInverting());
+	CRYPTOPP_ASSERT(!c.IsForwardTransformation() || c.IsSelfInverting());
 	IsolatedInitialize(MakeParameters(Name::BlockPaddingScheme(), padding)(Name::AuthenticatedDecryptionFilterFlags(), flags)(Name::TruncatedDigestSize(), truncatedDigestSize));
 }
 
@@ -962,13 +962,13 @@ size_t AuthenticatedDecryptionFilter::ChannelPut2(const std::string &channel, co
 void AuthenticatedDecryptionFilter::FirstPut(const byte *inString)
 {
 	// FilterWithBufferedInput::PutMaybeModifiable causes this to fire.
-	// assert(inString);
+	// CRYPTOPP_ASSERT(inString);
 	m_hashVerifier.Put(inString, m_firstSize);
 }
 
 void AuthenticatedDecryptionFilter::NextPutMultiple(const byte *inString, size_t length)
 {
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
 	m_streamFilter.Put(inString, length);
@@ -976,7 +976,7 @@ void AuthenticatedDecryptionFilter::NextPutMultiple(const byte *inString, size_t
 
 void AuthenticatedDecryptionFilter::LastPut(const byte *inString, size_t length)
 {
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
 	m_streamFilter.MessageEnd();
@@ -993,7 +993,7 @@ void SignerFilter::IsolatedInitialize(const NameValuePairs &parameters)
 
 size_t SignerFilter::Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
 {
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
 	FILTER_BEGIN;
@@ -1022,7 +1022,7 @@ void SignatureVerificationFilter::InitializeDerivedAndReturnNewSizes(const NameV
 	m_flags = parameters.GetValueWithDefault(Name::SignatureVerificationFilterFlags(), (word32)DEFAULT_FLAGS);
 	m_messageAccumulator.reset(m_verifier.NewVerificationAccumulator());
 	size_t size = m_verifier.SignatureLength();
-	assert(size != 0);	// TODO: handle recoverable signature scheme
+	CRYPTOPP_ASSERT(size != 0);	// TODO: handle recoverable signature scheme
 	m_verified = false;
 	firstSize = m_flags & SIGNATURE_AT_BEGIN ? size : 0;
 	blockSize = 1;
@@ -1032,7 +1032,7 @@ void SignatureVerificationFilter::InitializeDerivedAndReturnNewSizes(const NameV
 void SignatureVerificationFilter::FirstPut(const byte *inString)
 {
 	// FilterWithBufferedInput::PutMaybeModifiable causes this to fire.
-	// assert(inString);
+	// CRYPTOPP_ASSERT(inString);
 
 	if (m_flags & SIGNATURE_AT_BEGIN)
 	{
@@ -1049,13 +1049,13 @@ void SignatureVerificationFilter::FirstPut(const byte *inString)
 	}
 	else
 	{
-		assert(!m_verifier.SignatureUpfront());
+		CRYPTOPP_ASSERT(!m_verifier.SignatureUpfront());
 	}
 }
 
 void SignatureVerificationFilter::NextPutMultiple(const byte *inString, size_t length)
 {
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
 	m_messageAccumulator->Update(inString, length);
@@ -1065,12 +1065,12 @@ void SignatureVerificationFilter::NextPutMultiple(const byte *inString, size_t l
 
 void SignatureVerificationFilter::LastPut(const byte *inString, size_t length)
 {
-	assert(inString || (!inString && !length));
+	CRYPTOPP_ASSERT(inString || (!inString && !length));
 	if (inString == NULL) { length = 0; }
 
 	if (m_flags & SIGNATURE_AT_BEGIN)
 	{
-		assert(length == 0);
+		CRYPTOPP_ASSERT(length == 0);
 		m_verifier.InputSignature(*m_messageAccumulator, m_signature, m_signature.size());
 		m_verified = m_verifier.VerifyAndRestart(*m_messageAccumulator);
 	}