assert: initial version

Signed-off-by: Simon Rozman <simon@rozman.si>

UnitTests/pch.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include <stdex/assert.hpp>
 #include <stdex/base64.hpp>
 #include <stdex/compat.hpp>
 #include <stdex/exception.hpp>

include/stdex/assert.hpp

@@ -0,0 +1,63 @@
+/*
+	SPDX-License-Identifier: MIT
+	Copyright © 2023-2024 Amebis
+*/
+
+#pragma once
+
+#include "compat.hpp"
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#ifdef NDEBUG
+#define stdex_assert(e) _Analysis_assume_(e)
+#define stdex_verify(e) ((void)(e))
+#else
+#if defined(_WIN32)
+#define stdex_assert(e) (!!(e) ? (void)0 : stdex::do_assert(_L(__FILE__), (unsigned)(__LINE__), _L(#e)))
+#elif defined(__APPLE__)
+#define stdex_assert(e) (!!(e) ? (void)0 : stdex::do_assert(__func__, __ASSERT_FILE_NAME, __LINE__, #e))
+#else
+#error Implement!
+#endif
+#define stdex_verify(e) stdex_assert(e)
+#endif
+
+namespace stdex
+{
+	///
+	/// Terminates process in an abnormal way
+	///
+	/// Intention of this function is to alert any exception interception agent (Windows Error Reporting, Amebis Hroščar, etc.)
+	/// to create an error report and deliver it to developers.
+	///
+	/// \param[in] exception_code  An application-defined exception code
+	///
+	_NoReturn_
+	inline void abort(uint32_t exception_code)
+	{
+#ifdef _WIN32
+		RaiseException(exception_code, EXCEPTION_NONCONTINUABLE, 0, NULL);
+#else
+		_Unreferenced_(exception_code);
+		::abort();
+#endif
+	}
+
+	/// \cond internal
+#if defined(_WIN32)
+	inline void do_assert(const wchar_t *file, unsigned line, const wchar_t *expression)
+	{
+		_wassert(expression, file, line);
+	}
+#elif defined(__APPLE__)
+	inline void do_assert(const char *function, const char *file, int line, const char *expression)
+	{
+		__assert_rtn(function, file, line, expression);
+	}
+#else
+#error Implement!
+#endif
+	/// \endcond
+}

include/stdex/base64.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "assert.hpp"
 #include "compat.hpp"
 #include "stream.hpp"
 #include <cstdint>
@@ -74,7 +75,7 @@ namespace stdex
 		template<class T, class TR, class AX>
 		void encode(_Inout_ std::basic_string<T, TR, AX> &out, _In_bytecount_(size) const void *data, _In_ size_t size, _In_opt_ bool is_last = true)
 		{
-			_Assume_(data || !size);
+			stdex_assert(data || !size);
 
 			// Preallocate output
 			out.reserve(out.size() + enc_size(size));
@@ -194,7 +195,7 @@ namespace stdex
 		virtual _Success_(return != 0) size_t write(
 			_In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
 		{
-			_Assume_(data || !length);
+			stdex_assert(data || !length);
 			for (size_t i = 0;; i++) {
 				if (m_num >= 3) {
 					if (++m_num_blocks > m_max_blocks) {
@@ -318,7 +319,7 @@ namespace stdex
 					break;
 
 				size_t x = static_cast<size_t>(data[i]);
-				_Assume_(m_num < _countof(m_buf));
+				stdex_assert(m_num < _countof(m_buf));
 				if ((m_buf[m_num] = x < _countof(base64_dec_lookup) ? base64_dec_lookup[x] : 255) != 255)
 					m_num++;
 			}
@@ -388,7 +389,7 @@ namespace stdex
 		virtual _Success_(return != 0 || length == 0) size_t read(
 			_Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
 		{
-			_Assume_(data || !length);
+			stdex_assert(data || !length);
 			for (size_t to_read = length;;) {
 				if (m_temp_len >= to_read) {
 					memcpy(data, m_temp + m_temp_off, to_read);

include/stdex/compat.hpp

@@ -5,7 +5,6 @@
 
 #pragma once
 
-#include <assert.h>
 #include <stddef.h>
 #ifdef _WIN32
 #include "windows.h"
@@ -156,6 +155,11 @@
 #define _Null_terminated_
 #endif
 
+#ifndef _L
+#define __L(x) L ## x
+#define _L(x)  __L(x)
+#endif
+
 #ifndef _Likely_
 #if _HAS_CXX20
 #define _Likely_ [[likely]]
@@ -174,8 +178,10 @@
 
 #ifdef _MSC_VER
 #define _Deprecated_(message) __declspec(deprecated(message))
+#define _NoReturn_ __declspec(noreturn)
 #else
 #define _Deprecated_(message) [[deprecated(message)]]
+#define _NoReturn_ [[noreturn]]
 #endif
 
 #ifdef _WIN32
@@ -196,13 +202,6 @@ size_t _countof(const T (&arr)[N])
 #ifndef _Analysis_assume_
 #define _Analysis_assume_(p)
 #endif
-#ifdef NDEBUG
-#define _Assume_(p) _Analysis_assume_(p)
-#define _Verify_(p) ((void)(p))
-#else
-#define _Assume_(p) assert(p)
-#define _Verify_(p) assert(p)
-#endif
 
 #ifdef __APPLE__
 #define off64_t off_t

include/stdex/endian.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "assert.hpp"
 #include "compat.hpp"
 #include "system.hpp"
 #include <stdint.h>
@@ -113,10 +114,10 @@ namespace stdex
 		return *reinterpret_cast<double*>(&r);
 	}
 
-	inline void byteswap(_Inout_ uint8_t* value) { _Assume_(value); *value = byteswap(*value); }
+	inline void byteswap(_Inout_ uint8_t* value) { stdex_assert(value); *value = byteswap(*value); }
-	inline void byteswap(_Inout_ uint16_t* value) { _Assume_(value); *value = byteswap(*value); }
+	inline void byteswap(_Inout_ uint16_t* value) { stdex_assert(value); *value = byteswap(*value); }
-	inline void byteswap(_Inout_ uint32_t* value) { _Assume_(value); *value = byteswap(*value); }
+	inline void byteswap(_Inout_ uint32_t* value) { stdex_assert(value); *value = byteswap(*value); }
-	inline void byteswap(_Inout_ uint64_t* value) { _Assume_(value); *value = byteswap(*value); }
+	inline void byteswap(_Inout_ uint64_t* value) { stdex_assert(value); *value = byteswap(*value); }
 
 	inline void byteswap(_Inout_ char* value) { byteswap(reinterpret_cast<uint8_t*>(value)); }
 	inline void byteswap(_Inout_ int8_t* value) { byteswap(reinterpret_cast<uint8_t*>(value)); }

include/stdex/hash.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "assert.hpp"
 #include "compat.hpp"
 #include "math.h"
 #include "stream.hpp"
@@ -80,7 +81,7 @@ namespace stdex
 
 		virtual void hash(_In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
 		{
-			_Assume_(data || !length);
+			stdex_assert(data || !length);
 
 			// Compute number of bytes mod 64.
 			size_t j = static_cast<size_t>((m_counter[0] >> 3) & 63);
@@ -93,8 +94,8 @@ namespace stdex
 			// Transform as many times as possible.
 			size_t i, remainder = 64 - j;
 			if (length >= remainder) {
-				_Assume_(j < 64 && j + remainder <= 64);
+				stdex_assert(j < 64 && j + remainder <= 64);
-				_Assume_(remainder <= length);
+				stdex_assert(remainder <= length);
 				memcpy(m_queue + j, data, remainder);
 				hash_block();
 				for (i = remainder; i + 64 <= length; i += 64) {
@@ -111,8 +112,8 @@ namespace stdex
 				i = 0;
 
 			// Buffer remaining input.
-			_Assume_(j < 64 && j + length - i <= 64);
+			stdex_assert(j < 64 && j + length - i <= 64);
-			_Assume_(i <= length);
+			stdex_assert(i <= length);
 			memcpy(m_queue + j, reinterpret_cast<const uint8_t*>(data) + i, length - i);
 		}
 
@@ -239,7 +240,7 @@ namespace stdex
 				0x2d02ef8d
 			};
 
-			_Assume_(data || !length);
+			stdex_assert(data || !length);
 			for (size_t i = 0; i < length; i++)
 				m_value = crc32_table[(m_value ^ reinterpret_cast<const uint8_t*>(data)[i]) & 0xff] ^ (m_value >> 8);
 		}

include/stdex/hex.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "assert.hpp"
 #include "compat.hpp"
 #include <cstdint>
 #include <string>
@@ -34,7 +35,7 @@ namespace stdex
 		template<class T, class TR, class AX>
 		void encode(_Inout_ std::basic_string<T, TR, AX> &out, _In_bytecount_(size) const void *data, _In_ size_t size)
 		{
-			_Assume_(data || !size);
+			stdex_assert(data || !size);
 
 			// Preallocate output
 			out.reserve(out.size() + enc_size(size));

include/stdex/html.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "assert.hpp"
 #include "compat.hpp"
 #include "exception.hpp"
 #include "interval.hpp"
@@ -44,7 +45,7 @@ namespace stdex
 			_Inout_ std::basic_string<char, TR, AX>& dst,
 			_In_reads_or_z_opt_(num_chars) const char* src, _In_ size_t num_chars)
 		{
-			_Assume_(src || !num_chars);
+			stdex_assert(src || !num_chars);
 			for (size_t i = 0; i < num_chars && src[i]; ++i) {
 				switch (src[i]) {
 				case '&': dst += "&amp;"; break;
@@ -71,7 +72,7 @@ namespace stdex
 			_Inout_ std::basic_string<wchar_t, TR, AX>& dst,
 			_In_reads_or_z_opt_(num_chars) const wchar_t* src, _In_ size_t num_chars)
 		{
-			_Assume_(src || !num_chars);
+			stdex_assert(src || !num_chars);
 			for (size_t i = 0; i < num_chars && src[i]; ++i) {
 				switch (src[i]) {
 				case L'&': dst += L"&amp;"; break;
@@ -162,7 +163,7 @@ namespace stdex
 			_Inout_ std::basic_string<char, TR, AX>& dst,
 			_In_reads_or_z_opt_(num_chars) const char* src, _In_ size_t num_chars)
 		{
-			_Assume_(src || !num_chars);
+			stdex_assert(src || !num_chars);
 			for (size_t i = 0; i < num_chars && src[i]; ++i) {
 				switch (src[i]) {
 				case '&': dst += "&amp;"; break;
@@ -186,7 +187,7 @@ namespace stdex
 			_Inout_ std::basic_string<wchar_t, TR, AX>& dst,
 			_In_reads_or_z_opt_(num_chars) const wchar_t* src, _In_ size_t num_chars)
 		{
-			_Assume_(src || !num_chars);
+			stdex_assert(src || !num_chars);
 			for (size_t i = 0; i < num_chars && src[i]; ++i) {
 				switch (src[i]) {
 				case L'&': dst += L"&amp;"; break;
@@ -238,7 +239,7 @@ namespace stdex
 			_Inout_ std::basic_string<char, TR, AX>& dst,
 			_In_reads_or_z_opt_(num_chars) const char* src, _In_ size_t num_chars)
 		{
-			_Assume_(src || !num_chars);
+			stdex_assert(src || !num_chars);
 			for (size_t i = 0; i < num_chars && src[i];) {
 				switch (src[i]) {
 				case '+':
@@ -308,7 +309,7 @@ namespace stdex
 			_Inout_ std::basic_string<char, TR, AX>& dst,
 			_In_reads_or_z_opt_(num_chars) const char* src, _In_ size_t num_chars)
 		{
-			_Assume_(src || !num_chars);
+			stdex_assert(src || !num_chars);
 			for (size_t i = 0; i < num_chars && src[i]; ++i) {
 				switch (src[i]) {
 				case ' ': dst += "+"; break;
@@ -387,7 +388,7 @@ namespace stdex
 			_Inout_ std::basic_string<T, TR, AX>& dst,
 			_In_reads_or_z_opt_(num_chars) const T* src, _In_ size_t num_chars)
 		{
-			_Assume_(src || !num_chars);
+			stdex_assert(src || !num_chars);
 			for (size_t i = 0; i < num_chars && src[i];) {
 				if (src[i] != '\\')
 					dst += src[i++];
@@ -485,7 +486,7 @@ namespace stdex
 			_Inout_ std::basic_string<char, TR, AX>& dst,
 			_In_reads_or_z_opt_(num_chars) const char* src, _In_ size_t num_chars)
 		{
-			_Assume_(src || !num_chars);
+			stdex_assert(src || !num_chars);
 			for (size_t i = 0; i < num_chars && src[i]; ++i) {
 				switch (src[i]) {
 				case '\\': dst += "\\\\"; break;
@@ -511,7 +512,7 @@ namespace stdex
 			_Inout_ std::basic_string<wchar_t, TR, AX>& dst,
 			_In_reads_or_z_opt_(num_chars) const wchar_t* src, _In_ size_t num_chars)
 		{
-			_Assume_(src || !num_chars);
+			stdex_assert(src || !num_chars);
 			for (size_t i = 0; i < num_chars && src[i]; ++i) {
 				switch (src[i]) {
 				case L'\\': dst += L"\\\\"; break;
@@ -1232,7 +1233,7 @@ namespace stdex
 			template <class T>
 			static bool is_uri(_In_ element_t code, _In_reads_or_z_opt_(num_chars) const T* attr_name, _In_ size_t num_chars)
 			{
-				_Assume_(attr_name || !num_chars);
+				stdex_assert(attr_name || !num_chars);
 				switch (code) {
 				case element_t::a:          return !stdex::strnicmp(attr_name, num_chars, "href", SIZE_MAX);
 				case element_t::applet:     return !stdex::strnicmp(attr_name, num_chars, "code", SIZE_MAX) ||
@@ -1287,7 +1288,7 @@ namespace stdex
 			template <class T>
 			static bool is_localizable(element_t code, const T* attr_name, size_t num_chars)
 			{
-				_Assume_(attr_name || !num_chars);
+				stdex_assert(attr_name || !num_chars);
 				if (!stdex::strnicmp(attr_name, num_chars, "title", SIZE_MAX))
 					return true;
 				switch (code) {
@@ -1456,10 +1457,10 @@ namespace stdex
 #ifndef NDEBUG
 				// The mapping table MUST be sorted and all names in lowercase.
 				for (size_t i = 1; i < _countof(mapping); i++)
-					_Assume_(stdex::strcmp(mapping[i - 1].name, mapping[i].name) <= 0);
+					stdex_assert(stdex::strcmp(mapping[i - 1].name, mapping[i].name) <= 0);
 				for (size_t i = 0; i < _countof(mapping); i++) {
 					for (size_t j = 0; mapping[i].name[j]; j++)
-						_Assume_(stdex::islower(mapping[i].name[j]) | stdex::isdigit(mapping[i].name[j]));
+						stdex_assert(stdex::islower(mapping[i].name[j]) | stdex::isdigit(mapping[i].name[j]));
 				}
 #endif
 				for (size_t i = 0, j = _countof(mapping); i < j; ) {
@@ -1654,7 +1655,7 @@ namespace stdex
 			///
 			void append(_In_reads_or_z_opt_(num_chars) const T* source, _In_ size_t num_chars)
 			{
-				_Assume_(source || !num_chars);
+				stdex_assert(source || !num_chars);
 				m_source.append(source, stdex::strnlen(source, num_chars));
 				source = m_source.data();
 				num_chars = m_source.size();
@@ -1710,7 +1711,7 @@ namespace stdex
 
 					if (m_is_special_element) {
 						auto parent = active_element();
-						_Assume_(parent);
+						stdex_assert(parent);
 						if (m_tag.match(source, i, num_chars) &&
 							m_tag.type == stdex::parser::html_sequence_t::element_end &&
 							element::element_code(source + m_tag.name.start, m_tag.name.size()) == parent->code)
@@ -1744,7 +1745,7 @@ namespace stdex
 							// Does this tag end any of the started elements?
 							for (size_t j = m_element_stack.size(); j--; ) {
 								auto starting_tag = m_element_stack[j];
-								_Assume_(starting_tag && starting_tag->type == stdex::parser::html_sequence_t::element_start);
+								stdex_assert(starting_tag && starting_tag->type == stdex::parser::html_sequence_t::element_start);
 								if (element_traits::may_contain(starting_tag->code, e->code)) {
 									e->parent = starting_tag;
 									break;
@@ -1805,7 +1806,7 @@ namespace stdex
 
 							for (size_t j = m_element_stack.size(); j--; ) {
 								auto starting_tag = m_element_stack[j];
-								_Assume_(starting_tag && starting_tag->type == stdex::parser::html_sequence_t::element_start);
+								stdex_assert(starting_tag && starting_tag->type == stdex::parser::html_sequence_t::element_start);
 								if (starting_tag->code == e->code ||
 									(starting_tag->code == element_t::unknown && e->code == element_t::unknown && !stdex::strnicmp(source + starting_tag->name.start, starting_tag->name.size(), source + e->name.start, e->name.size())))
 								{
@@ -1904,7 +1905,7 @@ namespace stdex
 			///
 			std::basic_string<T, TR, AX> replace_entities(_In_reads_or_z_opt_(num_chars) const T* input, _In_ size_t num_chars) const
 			{
-				_Assume_(input || !num_chars);
+				stdex_assert(input || !num_chars);
 				const size_t num_entities = m_entities.size();
 				const T* source = m_source.data();
 				std::basic_string<T, TR, AX> output;
@@ -2188,7 +2189,7 @@ namespace stdex
 			///
 			text_token<T, TR, AX>* parse()
 			{
-				_Assume_(m_tokens.empty());
+				stdex_assert(m_tokens.empty());
 
 				if (m_progress) {
 					m_progress->set_range(0, m_document.source().size());
@@ -2208,8 +2209,8 @@ namespace stdex
 			///
 			static void link(_Inout_ std::basic_string<T, TR, AX>& source, _In_ const text_token<T, TR, AX>* t)
 			{
-				_Assume_(t);
+				stdex_assert(t);
-				_Assume_(
+				stdex_assert(
 					t->type == token_t::complete ||
 					t->type == token_t::starting ||
 					t->type == token_t::ending ||
@@ -2218,7 +2219,7 @@ namespace stdex
 				if (t->text_type & has_tokens) {
 					const T* root = t->text.data();
 					for (size_t i = 0, num_chars = t->text.size(); i < num_chars && root[i];) {
-						_Assume_(root[i] != token_tag_end);
+						stdex_assert(root[i] != token_tag_end);
 						const token* t2 = token::parse_tag(root, i);
 						if (t2) {
 							switch (t2->type) {
@@ -2301,7 +2302,7 @@ namespace stdex
 						// End tokens not relevant anymore in reverse order of starting.
 						for (auto i = active_tokens.cend(); i != active_tokens.cbegin(); ) {
 							auto t1 = dynamic_cast<starting_token<T, TR, AX>*>(*(--i));
-							_Assume_(t1 && t1->type == token_t::starting);
+							stdex_assert(t1 && t1->type == token_t::starting);
 
 							std::unique_ptr<text_token<T, TR, AX>> t2(new text_token<T, TR, AX>(token_t::ending));
 							t2->text.reserve(t1->name.size() + 3);
@@ -2340,7 +2341,7 @@ namespace stdex
 			{
 				for (auto i = inserted_tokens.begin(); i != inserted_tokens.end(); ) {
 					auto& t = *i;
-					_Assume_(t.token);
+					stdex_assert(t.token);
 					if (t.word_index == word_index && t.after_word == after_word) {
 						if (t.token->type != token_t::ending)
 							start_tokens(source, active_tokens, t.active_tokens, end_tokens(source, active_tokens, t.active_tokens));
@@ -2455,7 +2456,7 @@ namespace stdex
 					}
 
 					// No token_tag_start and token_tag_end chars, please.
-					_Assume_(
+					stdex_assert(
 						stdex::strnchr(m_source + s->interval.start, s->interval.size(), static_cast<T>(token_tag_start)) == stdex::npos &&
 						stdex::strnchr(m_source + s->interval.start, s->interval.size(), static_cast<T>(token_tag_end)) == stdex::npos);
 
@@ -2471,7 +2472,7 @@ namespace stdex
 					}
 					else if (s->type == stdex::parser::html_sequence_t::element || s->type == stdex::parser::html_sequence_t::element_start) {
 						const element* s_el = static_cast<const element*>(s.get());
-						_Assume_(s_el);
+						stdex_assert(s_el);
 						const element_start* s_el_start = s->type == stdex::parser::html_sequence_t::element_start ? static_cast<const element_start*>(s.get()) : nullptr;
 						if (s_el->code == element_t::frameset && !m_parse_frames)
 							throw std::invalid_argument("<frameset> detected");
@@ -2535,7 +2536,7 @@ namespace stdex
 							{
 								// Non-localizable
 								auto s_end = s_el_start->end;
-								_Assume_(s_end);
+								stdex_assert(s_end);
 
 								if (s->interval.end < s_end->interval.start) {
 									if (s_el_start->code != element_t::style) {
@@ -2552,7 +2553,7 @@ namespace stdex
 									else {
 										// Partially parse CSS. It may contain URLs we need to make absolute.
 										auto t = parse_css(s->interval.end, s_end->interval.start);
-										_Assume_(t);
+										stdex_assert(t);
 										rel.from = s->interval.start;
 										token->mapping.push_back(rel);
 										rel.to += t->append_tag(token->text);

include/stdex/minisign.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "assert.hpp"
 #include "base64.hpp"
 #include "compat.hpp"
 #include "parser.hpp"
@@ -30,7 +31,7 @@ namespace stdex
 				_In_ int flags = stdex::parser::match_default)
 			{
 				_Unreferenced_(flags);
-				_Assume_(text || start + 17 >= end);
+				stdex_assert(text || start + 17 >= end);
 				if (start + 17 < end &&
 					text[start + 0] == 'u' &&
 					text[start + 1] == 'n' &&
@@ -72,7 +73,7 @@ namespace stdex
 				_In_ int flags = stdex::parser::match_default)
 			{
 				_Unreferenced_(flags);
-				_Assume_(text || start + 1 >= end);
+				stdex_assert(text || start + 1 >= end);
 				if (start + 1 < end &&
 					text[start + 0] == '\r' &&
 					text[start + 1] == '\n')
@@ -80,7 +81,7 @@ namespace stdex
 					this->interval.end = (this->interval.start = start) + 2;
 					return true;
 				}
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start] == '\n') {
 					this->interval.end = (this->interval.start = start) + 1;
 					return true;

include/stdex/parser.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "assert.hpp"
 #include "compat.hpp"
 #include "endian.hpp"
 #include "interval.hpp"
@@ -188,7 +189,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					this->interval.start = this->interval.end = start;
 					return true;
@@ -223,7 +224,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					this->interval.end = (this->interval.start = start) + 1;
 					return true;
@@ -256,7 +257,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					if (text[start] == '&') {
 						// SGML entity
@@ -299,7 +300,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					bool r;
 					if (flags & match_case_insensitive) {
@@ -339,7 +340,7 @@ namespace stdex
 				sgml_parser(locale),
 				m_invert(invert)
 			{
-				_Assume_(chr || !count);
+				stdex_assert(chr || !count);
 				wchar_t buf[5];
 				size_t chr_end;
 				m_chr.assign(count ? next_sgml_cp(chr, 0, count, chr_end, buf) : L"");
@@ -352,7 +353,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					wchar_t buf[5];
 					const wchar_t* chr = next_sgml_cp(text, start, end, this->interval.end, buf);
@@ -391,7 +392,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					bool r =
 						((flags & match_multiline) || !stdex::islbreak(text[start])) &&
@@ -433,7 +434,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					wchar_t buf[5];
 					const wchar_t* chr = next_sgml_cp(text, start, end, this->interval.end, buf);
@@ -471,7 +472,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					bool r = std::use_facet<std::ctype<T>>(this->m_locale).is(std::ctype_base::punct, text[start]);
 					if ((r && !m_invert) || (!r && m_invert)) {
@@ -511,7 +512,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					wchar_t buf[5];
 					const wchar_t* chr = next_sgml_cp(text, start, end, this->interval.end, buf);
@@ -546,7 +547,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					bool r =
 						((flags & match_multiline) || !stdex::islbreak(text[start])) &&
@@ -588,7 +589,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					wchar_t buf[5];
 					const wchar_t* chr = next_sgml_cp(text, start, end, this->interval.end, buf);
@@ -622,8 +623,8 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || !end);
+				stdex_assert(text || !end);
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				bool r = start == 0 || (start <= end && stdex::islbreak(text[start - 1]));
 				if ((r && !m_invert) || (!r && m_invert)) {
 					this->interval.end = this->interval.start = start;
@@ -661,7 +662,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				bool r = start >= end || !text[start] || stdex::islbreak(text[start]);
 				if ((r && !m_invert) || (!r && m_invert)) {
 					this->interval.end = this->interval.start = start;
@@ -736,7 +737,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					const T* set = m_set.data();
 					size_t r = (flags & match_case_insensitive) ?
@@ -784,7 +785,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					wchar_t buf[5];
 					const wchar_t* chr = next_sgml_cp(text, start, end, this->interval.end, buf);
@@ -828,7 +829,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				size_t
 					m = m_str.size(),
 					n = std::min<size_t>(end - start, m);
@@ -872,7 +873,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				const wchar_t* str = m_str.data();
 				const bool case_insensitive = flags & match_case_insensitive ? true : false;
 				const auto& ctype = std::use_facet<std::ctype<wchar_t>>(m_locale);
@@ -922,7 +923,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.start = this->interval.end = start;
 				for (size_t i = 0; ; i++) {
 					if ((!m_greedy && i >= m_min_iterations) || i >= m_max_iterations)
@@ -973,7 +974,7 @@ namespace stdex
 				_In_ const std::locale& locale = std::locale()) :
 				basic_parser<T>(locale)
 			{
-				_Assume_(el || !count);
+				stdex_assert(el || !count);
 				m_collection.reserve(count);
 				for (size_t i = 0; i < count; i++)
 					m_collection.push_back(el[i]);
@@ -1024,7 +1025,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				for (auto i = this->m_collection.begin(); i != this->m_collection.end(); ++i) {
 					if (!(*i)->match(text, this->interval.end, end, flags)) {
@@ -1092,7 +1093,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				hit_offset = 0;
 				for (auto i = this->m_collection.begin(); i != this->m_collection.end(); ++i, ++hit_offset) {
 					if ((*i)->match(text, start, end, flags)) {
@@ -1154,7 +1155,7 @@ namespace stdex
 		protected:
 			void build(_In_reads_(count) const T* str_z, _In_ size_t count)
 			{
-				_Assume_(str_z || !count);
+				stdex_assert(str_z || !count);
 				if (count) {
 					size_t offset, n;
 					for (
@@ -1216,7 +1217,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				for (auto& el : this->m_collection)
 					el->invalidate();
 				if (match_recursively(text, start, end, flags)) {
@@ -1326,7 +1327,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				for (this->interval.end = start, this->value = 0; this->interval.end < end && text[this->interval.end];) {
 					size_t dig;
 					if (m_digit_0->match(text, this->interval.end, end, flags)) { dig = 0; this->interval.end = m_digit_0->interval.end; }
@@ -1407,7 +1408,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (m_digits->match(text, start, end, flags)) {
 					// Leading part match.
 					this->value = m_digits->value;
@@ -1503,7 +1504,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				for (this->interval.end = start, this->value = 0; this->interval.end < end && text[this->interval.end];) {
 					size_t dig;
 					if (m_digit_0->match(text, this->interval.end, end, flags)) { dig = 0; this->interval.end = m_digit_0->interval.end; }
@@ -1598,7 +1599,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				size_t
 					dig[5] = { SIZE_MAX, SIZE_MAX, SIZE_MAX, SIZE_MAX, SIZE_MAX },
 					end2;
@@ -1714,7 +1715,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (numerator->match(text, start, end, flags) &&
 					fraction_line->match(text, numerator->interval.end, end, flags) &&
 					denominator->match(text, fraction_line->interval.end, end, flags))
@@ -1779,7 +1780,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 
 				const int space_match_flags = flags & ~match_multiline; // Spaces in score must never be broken in new line.
@@ -1867,7 +1868,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				if (positive_sign && positive_sign->match(text, this->interval.end, end, flags)) {
 					this->interval.end = positive_sign->interval.end;
@@ -1959,7 +1960,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 
 				if (positive_sign && positive_sign->match(text, this->interval.end, end, flags)) {
@@ -2105,7 +2106,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 
 				if (positive_sign && positive_sign->match(text, this->interval.end, end, flags)) {
@@ -2259,7 +2260,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 
 				if (positive_sign->match(text, this->interval.end, end, flags)) {
@@ -2395,7 +2396,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				value.s_addr = 0;
 
@@ -2489,7 +2490,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					if (text[start] == '-' ||
 						text[start] == '_' ||
@@ -2528,7 +2529,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					wchar_t buf[5];
 					const wchar_t* chr = next_sgml_cp(text, start, end, this->interval.end, buf);
@@ -2633,7 +2634,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				memset(&value, 0, sizeof(value));
 
@@ -2791,7 +2792,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					if (('A' <= text[start] && text[start] <= 'Z') ||
 						('a' <= text[start] && text[start] <= 'z') ||
@@ -2842,7 +2843,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					wchar_t buf[5];
 					const wchar_t* chr = next_sgml_cp(text, start, end, this->interval.end, buf);
@@ -2892,7 +2893,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				size_t i = start, count;
 				for (count = 0; i < end && text[i] && count < 127; count++) {
 					if (m_domain_char->match(text, i, end, flags) &&
@@ -2966,7 +2967,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					if (text[start] == '-' ||
 						text[start] == '.' ||
@@ -3018,7 +3019,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					wchar_t buf[5];
 					const wchar_t* chr = next_sgml_cp(text, start, end, this->interval.end, buf);
@@ -3067,7 +3068,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					if (text[start] == '-' ||
 						text[start] == '.' ||
@@ -3120,7 +3121,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					wchar_t buf[5];
 					const wchar_t* chr = next_sgml_cp(text, start, end, this->interval.end, buf);
@@ -3169,7 +3170,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					if (text[start] == '/' ||
 						text[start] == '-' ||
@@ -3226,7 +3227,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start]) {
 					wchar_t buf[5];
 					const wchar_t* chr = next_sgml_cp(text, start, end, this->interval.end, buf);
@@ -3303,7 +3304,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 
 				this->interval.end = start;
 				path.start = start;
@@ -3482,7 +3483,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 
 				this->interval.end = start;
 
@@ -3806,7 +3807,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 
 				if (username->match(text, start, end, flags) &&
 					m_at->match(text, username->interval.end, end, flags))
@@ -3907,7 +3908,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 
 				if (emoticon && emoticon->match(text, start, end, flags)) {
 					if (apex) apex->invalidate();
@@ -4031,7 +4032,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 
 				const int space_match_flags = flags & ~match_multiline; // Spaces in dates must never be broken in new line.
 				if ((m_format_mask & date_format_dmy) == date_format_dmy) {
@@ -4295,7 +4296,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 
 				if (hour->match(text, start, end, flags) &&
 					m_separator->match(text, hour->interval.end, end, flags) &&
@@ -4405,7 +4406,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 
 				this->interval.end = start;
 
@@ -4514,7 +4515,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 
 				size_t safe_digit_end = start, safe_value_size = 0;
 				bool has_digits = false, after_digit = false, in_parentheses = false, after_parentheses = false;
@@ -4532,7 +4533,7 @@ namespace stdex
 				}
 
 				for (;;) {
-					_Assume_(text || this->interval.end >= end);
+					stdex_assert(text || this->interval.end >= end);
 					if (this->interval.end >= end || !text[this->interval.end])
 						break;
 					if (m_digit->match(text, this->interval.end, end, flags)) {
@@ -4667,7 +4668,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				const auto& ctype = std::use_facet<std::ctype<T>>(this->m_locale);
 				const bool case_insensitive = flags & match_case_insensitive ? true : false;
 				struct country_t {
@@ -4953,7 +4954,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				const auto& ctype = std::use_facet<std::ctype<T>>(this->m_locale);
 				const bool case_insensitive = flags & match_case_insensitive ? true : false;
 				size_t n, available, next;
@@ -5080,7 +5081,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				for (;;) {
 					if (this->interval.end >= end || !text[this->interval.end])
@@ -5126,7 +5127,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start < end && text[start] == '-') {
 					this->interval.end = (this->interval.start = start) + 1;
 					return true;
@@ -5193,7 +5194,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				const auto& ctype = std::use_facet<std::ctype<T>>(this->m_locale);
 				const bool case_insensitive = flags & match_case_insensitive ? true : false;
 
@@ -5420,7 +5421,7 @@ namespace stdex
 			static bool check11(
 				_In_count_(num_part1) const T* part1, _In_ size_t num_part1)
 			{
-				_Assume_(part1 && num_part1 >= 1);
+				stdex_assert(part1 && num_part1 >= 1);
 				uint32_t nominator = 0, ponder = 2;
 				for (size_t i = num_part1 - 1; i--; ++ponder)
 					nominator += static_cast<uint32_t>(part1[i] - '0') * ponder;
@@ -5434,8 +5435,8 @@ namespace stdex
 				_In_count_(num_part1) const T* part1, _In_ size_t num_part1,
 				_In_count_(num_part2) const T* part2, _In_ size_t num_part2)
 			{
-				_Assume_(part1 || !num_part1);
+				stdex_assert(part1 || !num_part1);
-				_Assume_(part2 && num_part2 >= 1);
+				stdex_assert(part2 && num_part2 >= 1);
 				uint32_t nominator = 0, ponder = 2;
 				for (size_t i = num_part2 - 1; i--; ++ponder)
 					nominator += static_cast<uint32_t>(part2[i] - '0') * ponder;
@@ -5452,9 +5453,9 @@ namespace stdex
 				_In_count_(num_part2) const T* part2, _In_ size_t num_part2,
 				_In_count_(num_part3) const T* part3, _In_ size_t num_part3)
 			{
-				_Assume_(part1 || !num_part1);
+				stdex_assert(part1 || !num_part1);
-				_Assume_(part2 || !num_part2);
+				stdex_assert(part2 || !num_part2);
-				_Assume_(part3 && num_part3 >= 1);
+				stdex_assert(part3 && num_part3 >= 1);
 				uint32_t nominator = 0, ponder = 2;
 				for (size_t i = num_part3 - 1; i--; ++ponder)
 					nominator += static_cast<uint32_t>(part3[i] - '0') * ponder;
@@ -5518,7 +5519,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 
 				has_digits = false;
 				has_charge = false;
@@ -5574,10 +5575,10 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 
-				_Assume_(text || this->interval.end >= end);
+				stdex_assert(text || this->interval.end >= end);
 				if (this->interval.end < end && text[this->interval.end]) {
 					if (text[this->interval.end] == '\r') {
 						this->interval.end++;
@@ -5610,7 +5611,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				if (m_line_break.match(text, this->interval.end, end, flags)) {
 					this->interval.end = m_line_break.interval.end;
@@ -5646,10 +5647,10 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 
-				_Assume_(text || this->interval.end >= end);
+				stdex_assert(text || this->interval.end >= end);
 				if (m_space.match(text, this->interval.end, end, flags)) {
 					this->interval.start = start;
 					this->interval.end = m_space.interval.end;
@@ -5679,7 +5680,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				for (;;) {
 					if (this->interval.end < end && text[this->interval.end]) {
@@ -5743,14 +5744,14 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				if (this->interval.end < end && text[this->interval.end] != '"')
 					goto error;
 				this->interval.end++;
 				content.start = this->interval.end;
 				for (;;) {
-					_Assume_(text || this->interval.end >= end);
+					stdex_assert(text || this->interval.end >= end);
 					if (this->interval.end < end && text[this->interval.end]) {
 						if (text[this->interval.end] == '"') {
 							content.end = this->interval.end;
@@ -5807,7 +5808,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				if (string.match(text, this->interval.end, end, flags)) {
 					token.invalidate();
@@ -5851,7 +5852,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				if (name.match(text, this->interval.end, end, flags))
 					this->interval.end = name.interval.end;
@@ -5859,7 +5860,7 @@ namespace stdex
 					goto error;
 				while (m_space.match(text, this->interval.end, end, flags))
 					this->interval.end = m_space.interval.end;
-				_Assume_(text || this->interval.end >= end);
+				stdex_assert(text || this->interval.end >= end);
 				if (this->interval.end < end && text[this->interval.end] == '=')
 					this->interval.end++;
 				else
@@ -5892,7 +5893,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start + 2 < end &&
 					text[start] == '*' &&
 					text[start + 1] == '/' &&
@@ -5935,7 +5936,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				if (type.match(text, this->interval.end, end, flags))
 					this->interval.end = type.interval.end;
@@ -5985,7 +5986,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (!http_media_range::do_match(text, start, end, flags))
 					goto error;
 				params.clear();
@@ -6032,7 +6033,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				for (;;) {
 					if (this->interval.end < end && text[this->interval.end]) {
@@ -6083,7 +6084,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				value = 0;
 				this->interval.end = start;
 				for (;;) {
@@ -6125,7 +6126,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				for (;;) {
 					if (this->interval.end < end && text[this->interval.end]) {
@@ -6167,11 +6168,11 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				http_url_path_segment s;
 				this->interval.end = start;
 				segments.clear();
-				_Assume_(text || this->interval.end >= end);
+				stdex_assert(text || this->interval.end >= end);
 				if (this->interval.end < end && text[this->interval.end] != '/')
 					goto error;
 				this->interval.end++;
@@ -6226,7 +6227,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				name.start = this->interval.end;
 				for (;;) {
@@ -6310,7 +6311,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 
 				if (this->interval.end + 7 <= end && stdex::strnicmp(text + this->interval.end, 7, "http://", SIZE_MAX, m_locale) == 0) {
@@ -6397,7 +6398,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				components.clear();
 				for (;;) {
@@ -6465,7 +6466,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				size_t celi_del = 0, decimalni_del = 0, decimalni_del_n = 1;
 				this->interval.end = start;
 				for (;;) {
@@ -6520,7 +6521,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || end <= start);
+				stdex_assert(text || end <= start);
 				if (start < end && text[start] == '*') {
 					this->interval.end = (this->interval.start = start) + 1;
 					return true;
@@ -6561,7 +6562,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				size_t konec_vrednosti;
 				this->interval.end = start;
 				if (asterisk.match(text, this->interval.end, end, flags)) {
@@ -6626,7 +6627,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				if (this->interval.end < end && text[this->interval.end] == '$')
 					this->interval.end++;
@@ -6684,7 +6685,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				if (name.match(text, this->interval.end, end, flags))
 					this->interval.end = name.interval.end;
@@ -6762,7 +6763,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				type.start = this->interval.end;
 				for (;;) {
@@ -6847,7 +6848,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				type.start = this->interval.end;
 				for (;;) {
@@ -6945,7 +6946,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 
 				for (;;) {
@@ -7070,7 +7071,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 
 				if (m_line_break.match(text, this->interval.end, end, flags) ||
@@ -7241,7 +7242,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_default)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				this->interval.end = start;
 				if (m_quote->match(text, this->interval.end, end, flags)) {
 					this->interval.end = m_quote->interval.end;
@@ -7286,7 +7287,7 @@ namespace stdex
 								m_hex->match(text, m_uni->interval.end, std::min(m_uni->interval.end + 4, end), flags | match_case_insensitive) &&
 								m_hex->interval.size() == 4 /* JSON requests 4-digit Unicode sequneces: \u.... */)
 							{
-								_Assume_(m_hex->value <= 0xffff);
+								stdex_assert(m_hex->value <= 0xffff);
 								if (sizeof(T) == 1) {
 									if (m_hex->value > 0x7ff) {
 										value += (T)(0xe0 | ((m_hex->value >> 12) & 0x0f));
@@ -7367,7 +7368,7 @@ namespace stdex
 				_In_ int flags = match_multiline)
 			{
 				_Unreferenced_(flags);
-				_Assume_(text || start + 1 >= end);
+				stdex_assert(text || start + 1 >= end);
 				if (start + 1 < end &&
 					text[start] == '/' &&
 					text[start + 1] == '*')
@@ -7418,7 +7419,7 @@ namespace stdex
 				_In_ int flags = match_multiline)
 			{
 				_Unreferenced_(flags);
-				_Assume_(text || start + 3 >= end);
+				stdex_assert(text || start + 3 >= end);
 				if (start + 3 < end &&
 					text[start] == '<' &&
 					text[start + 1] == '!' &&
@@ -7456,7 +7457,7 @@ namespace stdex
 				_In_ int flags = match_multiline)
 			{
 				_Unreferenced_(flags);
-				_Assume_(text || start + 2 >= end);
+				stdex_assert(text || start + 2 >= end);
 				if (start + 2 < end &&
 					text[start] == '-' &&
 					text[start + 1] == '-' &&
@@ -7503,7 +7504,7 @@ namespace stdex
 			{
 				_Unreferenced_(flags);
 				this->interval.end = start;
-				_Assume_(text || this->interval.end >= end);
+				stdex_assert(text || this->interval.end >= end);
 				if (this->interval.end < end &&
 					(text[this->interval.end] == '\"' || text[this->interval.end] == '\''))
 				{
@@ -7570,7 +7571,7 @@ namespace stdex
 			{
 				_Unreferenced_(flags);
 				this->interval.end = start;
-				_Assume_(text || this->interval.end + 3 >= end);
+				stdex_assert(text || this->interval.end + 3 >= end);
 				if (this->interval.end + 3 < end &&
 					(text[this->interval.end] == 'u' || text[this->interval.end] == 'U') &&
 					(text[this->interval.end + 1] == 'r' || text[this->interval.end + 1] == 'R') &&
@@ -7680,7 +7681,7 @@ namespace stdex
 			{
 				_Unreferenced_(flags);
 				this->interval.end = start;
-				_Assume_(text || this->interval.end + 6 >= end);
+				stdex_assert(text || this->interval.end + 6 >= end);
 				if (this->interval.end + 6 < end &&
 					text[this->interval.end] == '@' &&
 					(text[this->interval.end + 1] == 'i' || text[this->interval.end + 1] == 'I') &&
@@ -7772,7 +7773,7 @@ namespace stdex
 				this->interval.end = start;
 				this->base_type.start = this->interval.end;
 				for (;;) {
-					_Assume_(text || this->interval.end >= end);
+					stdex_assert(text || this->interval.end >= end);
 					if (this->interval.end >= end || !text[this->interval.end])
 						break;
 					if (text[this->interval.end] == '/' ||
@@ -7890,7 +7891,7 @@ namespace stdex
 				const auto& ctype = std::use_facet<std::ctype<T>>(this->m_locale);
 				this->interval.end = start;
 				for (;;) {
-					_Assume_(text || this->interval.end >= end);
+					stdex_assert(text || this->interval.end >= end);
 					if (this->interval.end >= end || !text[this->interval.end]) {
 						if (start < this->interval.end) {
 							this->interval.start = start;
@@ -7944,7 +7945,7 @@ namespace stdex
 			{
 				_Unreferenced_(flags);
 				this->interval.end = start;
-				_Assume_(text || this->interval.end >= end);
+				stdex_assert(text || this->interval.end >= end);
 				if (this->interval.end < end &&
 					(text[this->interval.end] == '\"' || text[this->interval.end] == '\''))
 				{
@@ -7973,7 +7974,7 @@ namespace stdex
 				this->content.start = this->interval.end;
 				const auto& ctype = std::use_facet<std::ctype<T>>(this->m_locale);
 				for (;;) {
-					_Assume_(text || this->interval.end >= end);
+					stdex_assert(text || this->interval.end >= end);
 					if (this->interval.end >= end || !text[this->interval.end]) {
 						this->content.end = this->interval.end;
 						this->interval.start = start;
@@ -8056,7 +8057,7 @@ namespace stdex
 				_In_ size_t end = SIZE_MAX,
 				_In_ int flags = match_multiline)
 			{
-				_Assume_(text || start >= end);
+				stdex_assert(text || start >= end);
 				if (start >= end || text[start] != '<')
 					goto error;
 				this->interval.end = start + 1;
@@ -8207,7 +8208,7 @@ namespace stdex
 						if (this->m_ident.match(text, this->interval.end, end, flags)) {
 							this->attributes.push_back(std::move(html_attribute{ this->m_ident.interval }));
 							a = &this->attributes.back();
-							_Assume_(a);
+							stdex_assert(a);
 							this->interval.end = this->m_ident.interval.end;
 						}
 						else {
@@ -8284,7 +8285,7 @@ namespace stdex
 				_In_ int flags = match_multiline)
 			{
 				_Unreferenced_(flags);
-				_Assume_(text || start + 2 >= end);
+				stdex_assert(text || start + 2 >= end);
 				if (start + 2 < end &&
 					text[start] == '<' &&
 					text[start + 1] == '!' &&
@@ -8341,7 +8342,7 @@ namespace stdex
 				_In_ int flags = match_multiline)
 			{
 				_Unreferenced_(flags);
-				_Assume_(text || start + 2 >= end);
+				stdex_assert(text || start + 2 >= end);
 				if (start + 2 < end &&
 					text[start] == ']' &&
 					text[start + 1] == ']' &&

include/stdex/ring.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "assert.hpp"
 #include "compat.hpp"
 #include <condition_variable>
 #include <mutex>
@@ -62,7 +63,7 @@ namespace stdex
 				const std::lock_guard<std::mutex> lg(m_mutex);
 #ifndef NDEBUG
 				size_t tail = wrap(m_head + m_size);
-				_Assume_(size <= (m_head <= tail ? N_cap - tail : m_head - tail));
+				stdex_assert(size <= (m_head <= tail ? N_cap - tail : m_head - tail));
 #endif
 				m_size += size;
 			}
@@ -97,7 +98,7 @@ namespace stdex
 				const std::lock_guard<std::mutex> lg(m_mutex);
 #ifndef NDEBUG
 				size_t tail = wrap(m_head + m_size);
-				_Assume_(size <= (m_head < tail ? m_size : N_cap - m_head));
+				stdex_assert(size <= (m_head < tail ? m_size : N_cap - m_head));
 #endif
 				m_head = wrap(m_head + size);
 				m_size -= size;

include/stdex/sgml.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "assert.hpp"
 #include "compat.hpp"
 #include "mapping.hpp"
 #include "sgml_unicode.hpp"
@@ -24,7 +25,7 @@ namespace stdex
 	template <class T>
 	const utf32_t* sgml2uni(_In_reads_or_z_(count) const T* entity, _In_ size_t count, utf32_t buf[2])
 	{
-		_Assume_(entity && count);
+		stdex_assert(entity && count);
 
 		if (count < 2 || entity[0] != '#') {
 			for (size_t i = 0, j = _countof(sgml_unicode); i < j; ) {
@@ -83,7 +84,7 @@ namespace stdex
 	const T* sgmlend(
 		_In_reads_or_z_opt_(count) const T* str, _In_ size_t count)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		for (size_t i = 0; i < count; i++) {
 			if (str[i] == ';')
 				return str + i;
@@ -127,7 +128,7 @@ namespace stdex
 		_In_reads_or_z_opt_(count_src) const T_from* src, _In_ size_t count_src,
 		_In_ int what = 0)
 	{
-		_Assume_(src || !count_src);
+		stdex_assert(src || !count_src);
 
 		const bool
 			do_ascii = (what & sgml_full) == 0;
@@ -196,7 +197,7 @@ namespace stdex
 		_In_ const mapping<size_t>& offset = mapping<size_t>(0, 0),
 		_Inout_opt_ mapping_vector<size_t>* map = nullptr)
 	{
-		_Assume_(src || !count_src);
+		stdex_assert(src || !count_src);
 
 		const bool
 			skip_quot = (skip & sgml_quot) == 0,
@@ -219,7 +220,7 @@ namespace stdex
 				auto end = sgmlend(&src[i + 1], count_src - i - 1);
 				if (end) {
 					utf32_t chr32[2];
-					_Assume_(&src[i + 1] <= end);
+					stdex_assert(&src[i + 1] <= end);
 					size_t n = static_cast<size_t>(end - src) - i - 1;
 					T_to chr[5];
 					auto entity_w = utf32_to_wstr(sgml2uni(&src[i + 1], n, chr32), chr);
@@ -239,7 +240,7 @@ namespace stdex
 					{
 						if (map) map->push_back(mapping<size_t>(offset.from + i, offset.to + dst.size()));
 						dst.append(entity_w);
-						_Assume_(src <= end);
+						stdex_assert(src <= end);
 						i = static_cast<size_t>(end - src) + 1;
 						if (map) map->push_back(mapping<size_t>(offset.from + i, offset.to + dst.size()));
 						continue;
@@ -291,8 +292,8 @@ namespace stdex
 		_In_ const mapping<size_t>& offset = mapping<size_t>(0, 0),
 		_Inout_opt_ mapping_vector<size_t>* map = nullptr)
 	{
-		_Assume_(dst || !count_dst);
+		stdex_assert(dst || !count_dst);
-		_Assume_(src || !count_src);
+		stdex_assert(src || !count_src);
 
 		static const std::invalid_argument buffer_overrun("buffer overrun");
 		const bool
@@ -419,7 +420,7 @@ namespace stdex
 		_In_ const mapping<size_t>& offset = mapping<size_t>(0, 0),
 		_Inout_opt_ mapping_vector<size_t>* map = nullptr)
 	{
-		_Assume_(dst || !count_dst);
+		stdex_assert(dst || !count_dst);
 		if (count_dst)
 			dst[0] = 0;
 		if (map)
@@ -473,7 +474,7 @@ namespace stdex
 	/// \cond internal
 	inline const char* chr2sgml(_In_reads_or_z_(count) const utf16_t* entity, _In_ size_t count)
 	{
-		_Assume_(entity && count);
+		stdex_assert(entity && count);
 
 		utf32_t e2;
 		size_t offset;
@@ -509,7 +510,7 @@ namespace stdex
 
 	inline const char* chr2sgml(_In_reads_or_z_(count) const utf32_t* entity, _In_ size_t count)
 	{
-		_Assume_(entity && count);
+		stdex_assert(entity && count);
 
 		utf32_t e2 = entity[0];
 		for (size_t i = 0, j = _countof(unicode_sgml); i < j; ) {
@@ -536,7 +537,7 @@ namespace stdex
 
 	inline utf32_t wstr_to_utf32(_In_reads_(end) const utf16_t* src, _Inout_ size_t& i, _In_ size_t end)
 	{
-		_Assume_(i < end);
+		stdex_assert(i < end);
 		if (i + 1 >= end || !is_surrogate_pair(src + i))
 			return src[i++];
 
@@ -548,7 +549,7 @@ namespace stdex
 	inline utf32_t wstr_to_utf32(_In_reads_(end) const utf32_t* src, _Inout_ size_t& i, _In_ size_t end)
 	{
 		_Unreferenced_(end);
-		_Assume_(i < end);
+		stdex_assert(i < end);
 		return src[i++];
 	}
 	/// \endcond
@@ -567,7 +568,7 @@ namespace stdex
 		_In_reads_or_z_opt_(count_src) const T_from* src, _In_ size_t count_src,
 		_In_ int what = 0)
 	{
-		_Assume_(src || !count_src);
+		stdex_assert(src || !count_src);
 
 		const bool
 			do_ascii = (what & sgml_full) == 0,
@@ -679,8 +680,8 @@ namespace stdex
 		_In_reads_or_z_opt_(count_src) const T_from* src, _In_ size_t count_src,
 		_In_ int what = 0)
 	{
-		_Assume_(dst || !count_dst);
+		stdex_assert(dst || !count_dst);
-		_Assume_(src || !count_src);
+		stdex_assert(src || !count_src);
 
 		static const std::invalid_argument buffer_overrun("buffer overrun");
 		const bool
@@ -742,7 +743,7 @@ namespace stdex
 					else {
 						char tmp[3 + 8 + 1 + 1];
 						int m = snprintf(tmp, _countof(tmp), "&#x%x;", static_cast<unsigned int>(src[i++]));
-						_Assume_(m >= 0);
+						stdex_assert(m >= 0);
 						if (static_cast<size_t>(m) >= count_dst)
 							throw buffer_overrun;
 						memcpy(dst + j, tmp, static_cast<size_t>(m) * sizeof(char));
@@ -770,7 +771,7 @@ namespace stdex
 						else {
 							char tmp[3 + 8 + 1 + 1];
 							int m = snprintf(tmp, _countof(tmp), "&#x%x;", static_cast<unsigned int>(wstr_to_utf32(src, i, end)));
-							_Assume_(m >= 0);
+							stdex_assert(m >= 0);
 							if (static_cast<size_t>(m) >= count_dst)
 								throw buffer_overrun;
 							memcpy(dst + j, tmp, static_cast<size_t>(m) * sizeof(char));
@@ -837,7 +838,7 @@ namespace stdex
 		_In_reads_or_z_opt_(count_src) const T_from* src, _In_ size_t count_src,
 		_In_ int what = 0)
 	{
-		_Assume_(dst || !count_dst);
+		stdex_assert(dst || !count_dst);
 		if (count_dst)
 			dst[0] = 0;
 		return str2sgmlcat(dst, count_dst, src, count_src, what);

include/stdex/stream.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "assert.hpp"
 #include "compat.hpp"
 #include "endian.hpp"
 #include "interval.hpp"
@@ -963,7 +964,7 @@ namespace stdex
 			///
 			LPSAFEARRAY read_sa()
 			{
-				_Assume_(size() <= SIZE_MAX);
+				stdex_assert(size() <= SIZE_MAX);
 				if (size() > ULONG_MAX)
 					throw std::range_error("data too big");
 				ULONG length = static_cast<ULONG>(size());
@@ -1270,7 +1271,7 @@ namespace stdex
 			virtual _Success_(return != 0 || length == 0) size_t read(
 				_Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 				for (size_t to_read = length;;) {
 					uint8_t* ptr; size_t num_read;
 					std::tie(ptr, num_read) = m_ring.front();
@@ -1336,7 +1337,7 @@ namespace stdex
 			virtual _Success_(return != 0) size_t write(
 				_In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 				for (size_t to_write = length;;) {
 					uint8_t* ptr; size_t num_write;
 					std::tie(ptr, num_write) = m_ring.back();
@@ -1424,7 +1425,7 @@ namespace stdex
 			virtual _Success_(return != 0 || length == 0) size_t read(
 				_Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 				for (size_t to_read = length;;) {
 					size_t buffer_size = m_read_buffer.tail - m_read_buffer.head;
 					if (to_read <= buffer_size) {
@@ -1460,7 +1461,7 @@ namespace stdex
 			virtual _Success_(return != 0) size_t write(
 				_In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 				if (!length) _Unlikely_ {
 					// Pass null writes (zero-byte length). Null write operations have special meaning with with Windows pipes.
 					flush_write();
@@ -1703,7 +1704,7 @@ namespace stdex
 			virtual _Success_(return != 0 || length == 0) size_t read(
 				_Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 				if (m_region.contains(m_offset)) {
 					size_t num_read = m_source.read(data, static_cast<size_t>(std::min<fpos_t>(length, m_region.end - m_offset)));
 					m_state = m_source.state();
@@ -1717,7 +1718,7 @@ namespace stdex
 			virtual _Success_(return != 0) size_t write(
 				_In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 				if (m_region.contains(m_offset)) {
 					size_t num_written = m_source.write(data, static_cast<size_t>(std::min<fpos_t>(length, m_region.end - m_offset)));
 					m_state = m_source.state();
@@ -1871,7 +1872,7 @@ namespace stdex
 			virtual _Success_(return != 0 || length == 0) size_t read(
 				_Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 #if SET_FILE_OP_TIMES
 				m_atime = time_point::now();
 #endif
@@ -1937,7 +1938,7 @@ namespace stdex
 			virtual _Success_(return != 0) size_t write(
 				_In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 #if SET_FILE_OP_TIMES
 				m_atime = m_mtime = time_point::now();
 #endif
@@ -2152,7 +2153,7 @@ namespace stdex
 
 			void load_cache(_In_ fpos_t start)
 			{
-				_Assume_(m_cache.status != cache_t::cache_t::status_t::dirty);
+				stdex_assert(m_cache.status != cache_t::cache_t::status_t::dirty);
 				start -= start % m_cache.capacity; // Align to cache block size.
 				m_source->seekbeg(m_cache.region.start = start);
 				if (m_source->ok()) {
@@ -2166,7 +2167,7 @@ namespace stdex
 
 			void write_cache()
 			{
-				_Assume_(m_cache.status == cache_t::cache_t::status_t::dirty);
+				stdex_assert(m_cache.status == cache_t::cache_t::status_t::dirty);
 				m_source->seekbeg(m_cache.region.start);
 				m_source->write(m_cache.data, static_cast<size_t>(m_cache.region.size()));
 				m_state = m_source->state();
@@ -2218,7 +2219,7 @@ namespace stdex
 			virtual _Success_(return != 0 || length == 0) size_t read(
 				_Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 				// Windows Server 2003 and Windows XP:  Pipe write operations across a network are limited in size per write.
 				// The amount varies per platform. For x86 platforms it's 63.97 MB. For x64 platforms it's 31.97 MB. For Itanium
 				// it's 63.95 MB. For more information regarding pipes, see the Remarks section.
@@ -2420,7 +2421,7 @@ namespace stdex
 			virtual _Success_(return != 0 || length == 0) size_t read(
 				_Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 				constexpr int block_size = 0x10000000;
 				for (size_t to_read = length;;) {
 					auto num_read = recv(m_h, reinterpret_cast<char*>(data),
@@ -2450,7 +2451,7 @@ namespace stdex
 			virtual _Success_(return != 0) size_t write(
 				_In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 				constexpr int block_size = 0x10000000;
 				for (size_t to_write = length;;) {
 					auto num_written = send(m_h, reinterpret_cast<const char*>(data),
@@ -2506,7 +2507,7 @@ namespace stdex
 			virtual _Success_(return != 0 || length == 0) size_t read(
 				_Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 				for (size_t to_read = length;;) {
 					HRESULT hr;
 					ULONG num_read = 0;
@@ -2532,7 +2533,7 @@ namespace stdex
 			virtual _Success_(return != 0) size_t write(
 				_In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 				for (size_t to_write = length;;) {
 					HRESULT hr;
 					ULONG num_written = 0;
@@ -2584,7 +2585,7 @@ namespace stdex
 			virtual _Success_(return != 0 || length == 0) size_t read(
 				_Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 				if (!m_request) _Unlikely_ {
 					m_state = state_t::fail;
 					return 0;
@@ -2602,8 +2603,8 @@ namespace stdex
 						m_state = to_read < length ? state_t::ok : state_t::fail;
 						return length - to_read;
 					}
-					_Assume_(V_VT(&var_amount) == VT_I4);
+					stdex_assert(V_VT(&var_amount) == VT_I4);
-					_Assume_(V_VT(&var_data) == (VT_ARRAY | VT_UI1));
+					stdex_assert(V_VT(&var_data) == (VT_ARRAY | VT_UI1));
 					std::unique_ptr<SAFEARRAY, SafeArrayDestroy_delete> sa(V_ARRAY(&var_data));
 					if (!V_I4(&var_amount)) _Unlikely_ {
 						m_state = to_read < length || !length ? state_t::ok : state_t::eof;
@@ -3019,7 +3020,7 @@ namespace stdex
 
 			virtual void set_ctime(time_point date)
 			{
-				_Assume_(m_h != invalid_handle);
+				stdex_assert(m_h != invalid_handle);
 #ifdef _WIN32
 				FILETIME ft;
 				tp2ft(date, ft);
@@ -3034,7 +3035,7 @@ namespace stdex
 
 			virtual void set_atime(time_point date)
 			{
-				_Assume_(m_h != invalid_handle);
+				stdex_assert(m_h != invalid_handle);
 #ifdef _WIN32
 				FILETIME ft;
 				tp2ft(date, ft);
@@ -3273,8 +3274,8 @@ namespace stdex
 				m_reserved(reserved),
 				m_manage(manage)
 			{
-				_Assume_(data || !size);
+				stdex_assert(data || !size);
-				_Assume_(reserved >= size);
+				stdex_assert(reserved >= size);
 #if SET_FILE_OP_TIMES
 				m_ctime = m_atime = m_mtime = time_point::now();
 #endif
@@ -3553,7 +3554,7 @@ namespace stdex
 			virtual _Success_(return != 0 || length == 0) size_t read(
 				_Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 #if SET_FILE_OP_TIMES
 				m_atime = time_point::now();
 #endif
@@ -3663,7 +3664,7 @@ namespace stdex
 			virtual _Success_(return != 0) size_t write(
 				_In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 #if SET_FILE_OP_TIMES
 				m_atime = m_mtime = time_point::now();
 #endif
@@ -3969,7 +3970,7 @@ namespace stdex
 		protected:
 			///
 			/// Writes data to specified file location
-			/// This does not move file pointer nor update file size. It checks for reserved space _Assume_-only (in Debug builds). Use with caution!
+			/// This does not move file pointer nor update file size. It checks for reserved space stdex_assert-only (in Debug builds). Use with caution!
 			///
 			/// \param[in] offset  Offset in file where to write data
 			/// \param[in] data    Data to write
@@ -3980,7 +3981,7 @@ namespace stdex
 #if SET_FILE_OP_TIMES
 				m_atime = m_mtime = time_point::now();
 #endif
-				_Assume_(offset + sizeof(T) < m_size);
+				stdex_assert(offset + sizeof(T) < m_size);
 				(*reinterpret_cast<T*>(m_data + offset)) = HE2LE(data);
 			}
 
@@ -4002,7 +4003,7 @@ namespace stdex
 
 			///
 			/// Reads data from specified file location
-			/// This does not move file pointer. It checks for data size _Assume_-only (in Debug builds). Use with caution!
+			/// This does not move file pointer. It checks for data size stdex_assert-only (in Debug builds). Use with caution!
 			///
 			/// \param[in] offset  Offset in file where to write data
 			/// \param[in] data    Data to write
@@ -4011,7 +4012,7 @@ namespace stdex
 			template <class T>
 			void get(_In_ fpos_t offset, _Out_ T & data)
 			{
-				_Assume_(offset + sizeof(T) < m_size);
+				stdex_assert(offset + sizeof(T) < m_size);
 				data = LE2HE(*(T*)(m_data + offset));
 #if SET_FILE_OP_TIMES
 				m_atime = time_point::now();
@@ -4106,7 +4107,7 @@ namespace stdex
 			virtual _Success_(return != 0 || length == 0) size_t read(
 				_Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 				for (size_t to_read = length;;) {
 					if (!m_head) _Unlikely_ {
 						m_state = to_read < length || !length ? state_t::ok : state_t::eof;
@@ -4134,7 +4135,7 @@ namespace stdex
 			virtual _Success_(return != 0) size_t write(
 				_In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 				try {
 					std::unique_ptr<node_t> n(reinterpret_cast<node_t*>(new uint8_t[sizeof(node_t) + length]));
 					n->next = nullptr;
@@ -4193,13 +4194,13 @@ namespace stdex
 			virtual _Success_(return != 0 || length == 0) size_t read(
 				_Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
 			{
-				_Assume_(data || !length);
+				stdex_assert(data || !length);
 				if (m_files.empty()) {
 					m_state = state_t::fail;
 					return 0;
 				}
 				size_t result = m_files[0]->read(data, length);
-				_Assume_(result <= length);
+				stdex_assert(result <= length);
 				m_state = m_files[0]->state();
 				if (length > m_tmp.size())
 					m_tmp.resize(length);

include/stdex/string.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "assert.hpp"
 #include "compat.hpp"
 #include "locale.hpp"
 #include <ctype.h>
@@ -71,7 +72,7 @@ namespace stdex
 	///
 	inline utf32_t surrogate_pair_to_ucs4(_In_reads_(2) const utf16_t* str)
 	{
-		_Assume_(is_surrogate_pair(str));
+		stdex_assert(is_surrogate_pair(str));
 		return
 			(static_cast<utf32_t>(str[0] - 0xd800) << 10) +
 			static_cast<utf32_t>(str[1] - 0xdc00) +
@@ -85,7 +86,7 @@ namespace stdex
 	///
 	inline void ucs4_to_surrogate_pair(_Out_writes_(2) utf16_t* str, _In_ utf32_t chr)
 	{
-		_Assume_(chr >= 0x10000);
+		stdex_assert(chr >= 0x10000);
 		chr -= 0x10000;
 		str[0] = 0xd800 + static_cast<utf16_t>((chr >> 10) & 0x3ff);
 		str[1] = 0xdc00 + static_cast<utf16_t>(chr & 0x3ff);
@@ -127,7 +128,7 @@ namespace stdex
 	template <class T>
 	size_t islbreak(_In_reads_or_z_opt_(count) const T* chr, _In_ size_t count)
 	{
-		_Assume_(chr || !count);
+		stdex_assert(chr || !count);
 		if (count >= 2 && ((chr[0] == '\r' && chr[1] == '\n') || (chr[0] == '\n' && chr[1] == '\r')))
 			return 2;
 		if (count > 1 && (chr[0] == '\n' || chr[0] == '\r'))
@@ -209,7 +210,7 @@ namespace stdex
 	///
 	inline size_t glyphlen(_In_reads_or_z_opt_(count) const utf16_t* glyph, _In_ size_t count)
 	{
-		_Assume_(glyph || !count);
+		stdex_assert(glyph || !count);
 		if (count) {
 			size_t i = count < 2 || !is_surrogate_pair(glyph) ? 1 : 2;
 			for (; i < count && iscombining(glyph[i]); ++i);
@@ -226,7 +227,7 @@ namespace stdex
 	///
 	inline size_t glyphlen(_In_reads_or_z_opt_(count) const utf32_t* glyph, _In_ size_t count)
 	{
-		_Assume_(glyph || !count);
+		stdex_assert(glyph || !count);
 		if (count) {
 			size_t i = 1;
 			for (; i < count && iscombining(glyph[i]); ++i);
@@ -243,7 +244,7 @@ namespace stdex
 	///
 	inline size_t glyphrlen(_In_reads_or_z_opt_(count) const utf16_t* str, _In_ size_t count)
 	{
-		_Assume_(count && str && str[count - 1]);
+		stdex_assert(count && str && str[count - 1]);
 		for (size_t i = count; i--;) {
 			if (!iscombining(str[i]))
 				return count - (!is_low_surrogate(str[i]) || i == 0 || !is_high_surrogate(str[i - 1]) ? i : i - 1);
@@ -259,7 +260,7 @@ namespace stdex
 	///
 	inline size_t glyphrlen(_In_reads_or_z_opt_(count) const utf32_t* str, _In_ size_t count)
 	{
-		_Assume_(count && str && str[count - 1]);
+		stdex_assert(count && str && str[count - 1]);
 		for (size_t i = count; i--;) {
 			if (!iscombining(str[i]))
 				return count - (i == 0 ? i : i - 1);
@@ -303,7 +304,7 @@ namespace stdex
 	template <class T>
 	size_t strlen(_In_z_ const T* str)
 	{
-		_Assume_(str);
+		stdex_assert(str);
 		size_t i;
 		for (i = 0; str[i]; ++i);
 		return i;
@@ -320,7 +321,7 @@ namespace stdex
 	template <class T>
 	size_t strnlen(_In_reads_or_z_opt_(count) const T* str, _In_ size_t count)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		size_t i;
 		for (i = 0; i < count && str[i]; ++i);
 		return i;
@@ -352,7 +353,7 @@ namespace stdex
 	template <class T>
 	size_t strchr(_In_z_ const T* str, _In_ T chr)
 	{
-		_Assume_(str);
+		stdex_assert(str);
 		for (size_t i = 0; str[i]; ++i)
 			if (str[i] == chr) return i;
 		return npos;
@@ -373,7 +374,7 @@ namespace stdex
 		_In_ size_t count,
 		_In_ T chr)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		for (size_t i = 0; i < count && str[i]; ++i)
 			if (str[i] == chr) return i;
 		return npos;
@@ -408,7 +409,7 @@ namespace stdex
 		_In_z_ const T* str,
 		_In_ T chr)
 	{
-		_Assume_(str);
+		stdex_assert(str);
 		size_t z = npos;
 		for (size_t i = 0; str[i]; ++i)
 			if (str[i] == chr) z = i;
@@ -430,7 +431,7 @@ namespace stdex
 		_In_ size_t count,
 		_In_ T chr)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		size_t z = npos;
 		for (size_t i = 0; i < count && str[i]; ++i)
 			if (str[i] == chr) z = i;
@@ -466,7 +467,7 @@ namespace stdex
 		_In_z_ const T* str,
 		_In_ T chr)
 	{
-		_Assume_(str);
+		stdex_assert(str);
 		chr = tolower(chr);
 		for (size_t i = 0; str[i]; ++i)
 			if (tolower(str[i]) == chr) return i;
@@ -488,7 +489,7 @@ namespace stdex
 		_In_ T chr,
 		_In_ const std::locale& locale)
 	{
-		_Assume_(str);
+		stdex_assert(str);
 		const auto& ctype = std::use_facet<std::ctype<T>>(locale);
 		chr = ctype.tolower(chr);
 		for (size_t i = 0; str[i]; ++i)
@@ -511,7 +512,7 @@ namespace stdex
 		_In_ size_t count,
 		_In_ T chr)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		chr = tolower(chr);
 		for (size_t i = 0; i < count && str[i]; ++i)
 			if (tolower(str[i]) == chr) return i;
@@ -535,7 +536,7 @@ namespace stdex
 		_In_ T chr,
 		_In_ const std::locale& locale)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		const auto& ctype = std::use_facet<std::ctype<T>>(locale);
 		chr = ctype.tolower(chr);
 		for (size_t i = 0; i < count && str[i]; ++i)
@@ -590,7 +591,7 @@ namespace stdex
 		_In_z_ const T* str,
 		_In_ T chr)
 	{
-		_Assume_(str);
+		stdex_assert(str);
 		chr = tolower(chr);
 		size_t z = npos;
 		for (size_t i = 0; str[i]; ++i)
@@ -613,7 +614,7 @@ namespace stdex
 		_In_ T chr,
 		_In_ const std::locale& locale)
 	{
-		_Assume_(str);
+		stdex_assert(str);
 		const auto& ctype = std::use_facet<std::ctype<T>>(locale);
 		chr = ctype.tolower(chr);
 		size_t z = npos;
@@ -637,7 +638,7 @@ namespace stdex
 		_In_ size_t count,
 		_In_ T chr)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		chr = tolower(chr);
 		size_t z = npos;
 		for (size_t i = 0; i < count && str[i]; ++i)
@@ -662,7 +663,7 @@ namespace stdex
 		_In_ T chr,
 		_In_ const std::locale& locale)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		const auto& ctype = std::use_facet<std::ctype<T>>(locale);
 		chr = ctype.tolower(chr);
 		size_t z = npos;
@@ -715,7 +716,7 @@ namespace stdex
 	//template <class T>
 	//bool isblank(_In_z_ const T* str)
 	//{
-	//	_Assume_(str);
+	//	stdex_assert(str);
 	//	for (size_t i = 0; str[i]; ++i)
 	//		if (!isspace(str[i]))
 	//			return false;
@@ -735,7 +736,7 @@ namespace stdex
 	//	_In_z_ const T* str,
 	//	_In_ const std::locale& locale)
 	//{
-	//	_Assume_(str);
+	//	stdex_assert(str);
 	//	const auto& ctype = std::use_facet<std::ctype<T>>(locale);
 	//	for (size_t i = 0; str[i]; ++i)
 	//		if (!ctype.is(ctype.space, str[i]))
@@ -756,7 +757,7 @@ namespace stdex
 		_In_reads_or_z_opt_(count) const T* str,
 		_In_ size_t count)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		for (size_t i = 0; i < count && str[i]; ++i)
 			if (!isspace(str[i]))
 				return false;
@@ -777,7 +778,7 @@ namespace stdex
 		_In_reads_or_z_opt_(count) const T* str, _In_ size_t count,
 		_In_ const std::locale& locale)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		const auto& ctype = std::use_facet<std::ctype<T>>(locale);
 		for (size_t i = 0; i < count && str[i]; ++i)
 			if (!ctype.is(ctype.space, str[i]))
@@ -824,7 +825,7 @@ namespace stdex
 	// template <class T>
 	// bool is7bit(_In_z_ const T* str)
 	// {
-	// 	_Assume_(str);
+	// 	stdex_assert(str);
 	// 	for (size_t i = 0; str[i]; i++)
 	// 		if (!is7bit(str[i]))
 	// 			return false;
@@ -842,7 +843,7 @@ namespace stdex
 	template <class T>
 	bool is7bit(_In_reads_or_z_opt_(count) const T* str, _In_ size_t count)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		for (size_t i = 0; i < count && str[i]; i++)
 			if (!is7bit(str[i]))
 				return false;
@@ -873,8 +874,8 @@ namespace stdex
 	template <class T1, class T2>
 	int strcmp(_In_z_ const T1* str1, _In_z_ const T2* str2)
 	{
-		_Assume_(str1);
+		stdex_assert(str1);
-		_Assume_(str2);
+		stdex_assert(str2);
 		size_t i; T1 a; T2 b;
 		for (i = 0; (a = str1[i]) | (b = str2[i]); ++i) {
 			if (a > b) return +1;
@@ -897,8 +898,8 @@ namespace stdex
 	template <class T1, class T2>
 	int strncmp(_In_reads_or_z_opt_(count) const T1* str1, _In_reads_or_z_opt_(count) const T2* str2, _In_ size_t count)
 	{
-		_Assume_(str1 || !count);
+		stdex_assert(str1 || !count);
-		_Assume_(str2 || !count);
+		stdex_assert(str2 || !count);
 		size_t i; T1 a; T2 b;
 		for (i = 0; i < count && ((a = str1[i]) | (b = str2[i])); ++i) {
 			if (a > b) return +1;
@@ -924,8 +925,8 @@ namespace stdex
 		_In_reads_or_z_opt_(count1) const T1* str1, _In_ size_t count1,
 		_In_reads_or_z_opt_(count2) const T2* str2, _In_ size_t count2)
 	{
-		_Assume_(str1 || !count1);
+		stdex_assert(str1 || !count1);
-		_Assume_(str2 || !count2);
+		stdex_assert(str2 || !count2);
 		size_t i;
 		for (i = 0; i < count1 && i < count2; ++i) {
 			auto a = str1[i];
@@ -969,8 +970,8 @@ namespace stdex
 		_In_reads_or_z_opt_(count1) const utf32_t* str1, _In_ size_t count1,
 		_In_reads_or_z_opt_(count2) const utf16_t* str2, _In_ size_t count2)
 	{
-		_Assume_(str1 || !count1);
+		stdex_assert(str1 || !count1);
-		_Assume_(str2 || !count2);
+		stdex_assert(str2 || !count2);
 		size_t i, j, j_next; utf32_t a, b;
 		for (i = 0, j = 0; i < count1 && j < count2; ++i, j = j_next) {
 			a = str1[i];
@@ -1024,8 +1025,8 @@ namespace stdex
 		size_t
 			i = strlen(str1),
 			j = strlen(str2);
-		_Assume_(str1 || !i);
+		stdex_assert(str1 || !i);
-		_Assume_(str2 || !j);
+		stdex_assert(str2 || !j);
 		size_t k; T1 a; T2 b;
 		for (k = 1; i && j; k++) {
 			i--; j--;
@@ -1052,8 +1053,8 @@ namespace stdex
 		size_t
 			i = strnlen(str1, count),
 			j = strnlen(str2, count);
-		_Assume_(str1 || !i);
+		stdex_assert(str1 || !i);
-		_Assume_(str2 || !j);
+		stdex_assert(str2 || !j);
 		size_t k; T1 a; T2 b;
 		for (k = 1; i && j; k++) {
 			i--; j--;
@@ -1083,8 +1084,8 @@ namespace stdex
 		size_t
 			i = strnlen(str1, count1),
 			j = strnlen(str2, count2);
-		_Assume_(str1 || !i);
+		stdex_assert(str1 || !i);
-		_Assume_(str2 || !j);
+		stdex_assert(str2 || !j);
 		size_t k; T1 a; T2 b;
 		for (k = 1; i && j; k++) {
 			i--; j--;
@@ -1123,8 +1124,8 @@ namespace stdex
 	template <class T1, class T2>
 	int stricmp(_In_z_ const T1* str1, _In_z_ const T2* str2)
 	{
-		_Assume_(str1);
+		stdex_assert(str1);
-		_Assume_(str2);
+		stdex_assert(str2);
 		size_t i;
 		for (i = 0; ; ++i) {
 			auto a = tolower(str1[i]);
@@ -1147,8 +1148,8 @@ namespace stdex
 	template <class T1, class T2>
 	int stricmp(_In_z_ const T1* str1, _In_z_ const T2* str2, _In_ const std::locale& locale)
 	{
-		_Assume_(str1);
+		stdex_assert(str1);
-		_Assume_(str2);
+		stdex_assert(str2);
 		size_t i;
 		const auto& ctype1 = std::use_facet<std::ctype<T1>>(locale);
 		const auto& ctype2 = std::use_facet<std::ctype<T2>>(locale);
@@ -1176,8 +1177,8 @@ namespace stdex
 	template <class T1, class T2>
 	int strnicmp(_In_reads_or_z_opt_(count) const T1* str1, _In_reads_or_z_opt_(count) const T2* str2, _In_ size_t count)
 	{
-		_Assume_(str1 || !count);
+		stdex_assert(str1 || !count);
-		_Assume_(str2 || !count);
+		stdex_assert(str2 || !count);
 		size_t i;
 		for (i = 0; i < count; ++i) {
 			auto a = tolower(str1[i]);
@@ -1204,8 +1205,8 @@ namespace stdex
 	template <class T1, class T2>
 	int strnicmp(_In_reads_or_z_opt_(count) const T1* str1, _In_reads_or_z_opt_(count) const T2* str2, _In_ size_t count, _In_ const std::locale& locale)
 	{
-		_Assume_(str1 || !count);
+		stdex_assert(str1 || !count);
-		_Assume_(str2 || !count);
+		stdex_assert(str2 || !count);
 		size_t i;
 		const auto& ctype1 = std::use_facet<std::ctype<T1>>(locale);
 		const auto& ctype2 = std::use_facet<std::ctype<T2>>(locale);
@@ -1236,8 +1237,8 @@ namespace stdex
 		_In_reads_or_z_opt_(count1) const T1* str1, _In_ size_t count1,
 		_In_reads_or_z_opt_(count2) const T2* str2, _In_ size_t count2)
 	{
-		_Assume_(str1 || !count1);
+		stdex_assert(str1 || !count1);
-		_Assume_(str2 || !count2);
+		stdex_assert(str2 || !count2);
 		size_t i;
 		for (i = 0; i < count1 && i < count2; ++i) {
 			auto a = tolower(str1[i]);
@@ -1268,8 +1269,8 @@ namespace stdex
 		_In_reads_or_z_opt_(count2) const T2* str2, _In_ size_t count2,
 		_In_ const std::locale& locale)
 	{
-		_Assume_(str1 || !count1);
+		stdex_assert(str1 || !count1);
-		_Assume_(str2 || !count2);
+		stdex_assert(str2 || !count2);
 		size_t i;
 		const auto& ctype1 = std::use_facet<std::ctype<T1>>(locale);
 		const auto& ctype2 = std::use_facet<std::ctype<T2>>(locale);
@@ -1334,8 +1335,8 @@ namespace stdex
 		_In_z_ const T* str2,
 		_In_ const std::locale& locale)
 	{
-		_Assume_(str1);
+		stdex_assert(str1);
-		_Assume_(str2);
+		stdex_assert(str2);
 		auto& collate = std::use_facet<std::collate<T>>(locale);
 		return collate.compare(str1, str1 + strlen(str1), str2, str2 + strlen(str2));
 	}
@@ -1357,8 +1358,8 @@ namespace stdex
 		_In_reads_or_z_opt_(count2) const T* str2, _In_ size_t count2,
 		_In_ const std::locale& locale)
 	{
-		_Assume_(str1 || !count1);
+		stdex_assert(str1 || !count1);
-		_Assume_(str2 || !count2);
+		stdex_assert(str2 || !count2);
 		auto& collate = std::use_facet<std::collate<T>>(locale);
 		return collate.compare(str1, str1 + count1, str2, str2 + count2);
 	}
@@ -1394,8 +1395,8 @@ namespace stdex
 		_In_z_ const T1* str,
 		_In_z_ const T2* sample)
 	{
-		_Assume_(str);
+		stdex_assert(str);
-		_Assume_(sample);
+		stdex_assert(sample);
 		for (size_t offset = 0;; ++offset) {
 			for (size_t i = offset, j = 0;; ++i, ++j) {
 				if (!sample[j])
@@ -1422,8 +1423,8 @@ namespace stdex
 		_In_reads_or_z_opt_(count) const T1* str, _In_ size_t count,
 		_In_z_ const T2* sample)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
-		_Assume_(sample);
+		stdex_assert(sample);
 		for (size_t offset = 0;; ++offset) {
 			for (size_t i = offset, j = 0;; ++i, ++j) {
 				if (!sample[j])
@@ -1465,8 +1466,8 @@ namespace stdex
 		_In_z_ const T1* str,
 		_In_z_ const T2* sample)
 	{
-		_Assume_(str);
+		stdex_assert(str);
-		_Assume_(sample);
+		stdex_assert(sample);
 		for (size_t offset = 0;; ++offset) {
 			for (size_t i = offset, j = 0;; ++i, ++j) {
 				if (!sample[j])
@@ -1494,8 +1495,8 @@ namespace stdex
 		_In_z_ const T2* sample,
 		_In_ const std::locale& locale)
 	{
-		_Assume_(str);
+		stdex_assert(str);
-		_Assume_(sample);
+		stdex_assert(sample);
 		const auto& ctype1 = std::use_facet<std::ctype<T1>>(locale);
 		const auto& ctype2 = std::use_facet<std::ctype<T2>>(locale);
 		for (size_t offset = 0;; ++offset) {
@@ -1525,8 +1526,8 @@ namespace stdex
 		_In_ size_t count,
 		_In_z_ const T2* sample)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
-		_Assume_(sample);
+		stdex_assert(sample);
 		for (size_t offset = 0;; ++offset) {
 			for (size_t i = offset, j = 0;; ++i, ++j) {
 				if (!sample[j])
@@ -1556,8 +1557,8 @@ namespace stdex
 		_In_z_ const T2* sample,
 		_In_ const std::locale& locale)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
-		_Assume_(sample);
+		stdex_assert(sample);
 		const auto& ctype1 = std::use_facet<std::ctype<T1>>(locale);
 		const auto& ctype2 = std::use_facet<std::ctype<T2>>(locale);
 		for (size_t offset = 0;; ++offset) {
@@ -1619,8 +1620,8 @@ namespace stdex
 		_Out_writes_z_(_String_length_(src) + 1) T1* dst,
 		_In_z_ const T2* src)
 	{
-		_Assume_(dst);
+		stdex_assert(dst);
-		_Assume_(src);
+		stdex_assert(src);
 		for (size_t i = 0; ; ++i) {
 			if ((dst[i] = static_cast<T1>(src[i])) == 0)
 				return i;
@@ -1641,8 +1642,8 @@ namespace stdex
 		_Out_writes_(count) _Post_maybez_ T1* dst,
 		_In_reads_or_z_opt_(count) const T2* src, _In_ size_t count)
 	{
-		_Assume_(dst || !count);
+		stdex_assert(dst || !count);
-		_Assume_(src || !count);
+		stdex_assert(src || !count);
 		for (size_t i = 0; ; ++i) {
 			if (i >= count)
 				return i;
@@ -1666,8 +1667,8 @@ namespace stdex
 		_Out_writes_(count_dst) _Post_maybez_ T1* dst, _In_ size_t count_dst,
 		_In_reads_or_z_opt_(count_src) const T2* src, _In_ size_t count_src)
 	{
-		_Assume_(dst || !count_dst);
+		stdex_assert(dst || !count_dst);
-		_Assume_(src || !count_src);
+		stdex_assert(src || !count_src);
 		for (size_t i = 0; ; ++i)
 		{
 			if (i >= count_dst)
@@ -1710,8 +1711,8 @@ namespace stdex
 		_In_z_ _Out_writes_z_(_String_length_(dst) + _String_length_(src) + 1) T1* dst,
 		_In_z_ const T2* src)
 	{
-		_Assume_(dst);
+		stdex_assert(dst);
-		_Assume_(src);
+		stdex_assert(src);
 		for (size_t i = 0, j = stdex::strlen<T1>(dst); ; ++i, ++j) {
 			if ((dst[j] = static_cast<T1>(src[i])) == 0)
 				return j;
@@ -1732,8 +1733,8 @@ namespace stdex
 		_Inout_z_ T1* dst,
 		_In_reads_or_z_opt_(count) const T2* src, _In_ size_t count)
 	{
-		_Assume_(dst || !count);
+		stdex_assert(dst || !count);
-		_Assume_(src || !count);
+		stdex_assert(src || !count);
 		for (size_t i = 0, j = stdex::strlen<T1>(dst); ; ++i, ++j) {
 			if (i >= count)
 				return j;
@@ -1757,8 +1758,8 @@ namespace stdex
 		_Out_writes_(count_dst) _Post_maybez_ T1* dst, _In_ size_t count_dst,
 		_In_reads_or_z_opt_(count_src) const T2* src, _In_ size_t count_src)
 	{
-		_Assume_(dst || !count_dst);
+		stdex_assert(dst || !count_dst);
-		_Assume_(src || !count_src);
+		stdex_assert(src || !count_src);
 		for (size_t i = 0, j = stdex::strnlen<T1>(dst, count_dst); ; ++i, ++j)
 		{
 			if (j >= count_dst)
@@ -1842,8 +1843,8 @@ namespace stdex
 	template <class T>
 	size_t crlf2nl(_Out_writes_z_(_String_length_(src) + 1) T* dst, _In_z_ const T* src)
 	{
-		_Assume_(dst);
+		stdex_assert(dst);
-		_Assume_(src);
+		stdex_assert(src);
 		size_t i, j;
 		for (i = j = 0; src[j];) {
 			if (src[j] != '\r' || src[j + 1] != '\n')
@@ -1866,8 +1867,8 @@ namespace stdex
 	template<class T, class TR = std::char_traits<T>, class AX = std::allocator<T>>
 	void crlf2nl(_Inout_ std::basic_string<T, TR, AX>& dst, _In_z_ const T* src)
 	{
-		_Assume_(src);
+		stdex_assert(src);
-		_Assume_(src != dst.data());
+		stdex_assert(src != dst.data());
 		dst.clear();
 		dst.reserve(strlen(src));
 		for (size_t j = 0; src[j];) {
@@ -1908,8 +1909,8 @@ namespace stdex
 		_In_ int radix,
 		_Out_ uint8_t& flags)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
-		_Assume_(radix == 0 || 2 <= radix && radix <= 36);
+		stdex_assert(radix == 0 || 2 <= radix && radix <= 36);
 
 		size_t i = 0;
 		T_bin value = 0, digit,
@@ -2378,7 +2379,7 @@ namespace stdex
 		_In_opt_ locale_t locale)
 	{
 		count = strnlen(str, count);
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		std::string tmp(str, count);
 		char* _end;
 		double r;
@@ -2407,7 +2408,7 @@ namespace stdex
 		_In_opt_ locale_t locale)
 	{
 		count = strnlen(str, count);
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		std::wstring tmp(str, count);
 		wchar_t* _end;
 		double r;
@@ -2473,7 +2474,7 @@ namespace stdex
 			switch (errno) {
 			case 0:
 				count = vsnprintf(NULL, 0, format, locale, arg);
-				_Assume_(count >= 0);
+				stdex_assert(count >= 0);
 				break;
 			case EINVAL: throw std::invalid_argument("invalid vsnprintf arguments");
 			case EILSEQ: throw std::runtime_error("encoding error");
@@ -2683,7 +2684,7 @@ namespace stdex
 	//template<class T>
 	//void strlwr(_Inout_z_ T* str)
 	//{
-	//	_Assume_(str);
+	//	stdex_assert(str);
 	//	for (size_t i = 0; str[i]; ++i)
 	//		str[i] = tolower(str[i]);
 	//}
@@ -2697,7 +2698,7 @@ namespace stdex
 	//template<class T>
 	//void strlwr(_Inout_z_ T* str, _In_ const std::locale& locale)
 	//{
-	//	_Assume_(str);
+	//	stdex_assert(str);
 	//	const auto& ctype = std::use_facet<std::ctype<T>>(locale);
 	//	for (size_t i = 0; str[i]; ++i)
 	//		str[i] = ctype.tolower(str[i]);
@@ -2712,7 +2713,7 @@ namespace stdex
 	template<class T>
 	void strlwr(_Inout_updates_z_(count) T* str, _In_ size_t count)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		for (size_t i = 0; i < count && str[i]; ++i)
 			str[i] = tolower(str[i]);
 	}
@@ -2727,7 +2728,7 @@ namespace stdex
 	template<class T>
 	void strlwr(_Inout_updates_z_(count) T* str, _In_ size_t count, _In_ const std::locale& locale)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		const auto& ctype = std::use_facet<std::ctype<T>>(locale);
 		for (size_t i = 0; i < count && str[i]; ++i)
 			str[i] = ctype.tolower(str[i]);
@@ -2790,7 +2791,7 @@ namespace stdex
 	//template<class T>
 	//void strupr(_Inout_z_ T* str)
 	//{
-	//	_Assume_(str);
+	//	stdex_assert(str);
 	//	for (size_t i = 0; str[i]; ++i)
 	//		str[i] = toupper(str[i]);
 	//}
@@ -2804,7 +2805,7 @@ namespace stdex
 	//template<class T>
 	//void strupr(_Inout_z_ T* str, _In_ const std::locale& locale)
 	//{
-	//	_Assume_(str);
+	//	stdex_assert(str);
 	//	const auto& ctype = std::use_facet<std::ctype<T>>(locale);
 	//	for (size_t i = 0; str[i]; ++i)
 	//		str[i] = ctype.toupper(str[i]);
@@ -2819,7 +2820,7 @@ namespace stdex
 	template<class T>
 	void strupr(_Inout_updates_z_(count) T* str, _In_ size_t count)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		for (size_t i = 0; i < count && str[i]; ++i)
 			str[i] = toupper(str[i]);
 	}
@@ -2834,7 +2835,7 @@ namespace stdex
 	template<class T>
 	void strupr(_Inout_updates_z_(count) T* str, _In_ size_t count, _In_ const std::locale& locale)
 	{
-		_Assume_(str || !count);
+		stdex_assert(str || !count);
 		const auto& ctype = std::use_facet<std::ctype<T>>(locale);
 		for (size_t i = 0; i < count && str[i]; ++i)
 			str[i] = ctype.toupper(str[i]);

include/stdex/sys_info.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "assert.hpp"
 #include "compat.hpp"
 #include "string.hpp"
 #include "system.hpp"
@@ -129,7 +130,7 @@ namespace stdex
 #ifdef _WIN32
 			HMODULE kernel32_handle;
 			kernel32_handle = LoadLibrary(_T("kernel32.dll"));
-			_Assume_(kernel32_handle);
+			stdex_assert(kernel32_handle);
 			BOOL(WINAPI * IsWow64Process2)(HANDLE hProcess, USHORT * pProcessMachine, USHORT * pNativeMachine);
 			*reinterpret_cast<FARPROC*>(&IsWow64Process2) = GetProcAddress(kernel32_handle, "IsWow64Process2");
 			HANDLE process = GetCurrentProcess();

include/stdex/unicode.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "assert.hpp"
 #include "compat.hpp"
 #include "endian.hpp"
 #include "math.hpp"
@@ -176,7 +177,7 @@ namespace stdex
 			_Inout_ std::basic_string<T_to, TR_to, AX_to>& dst,
 			_In_reads_or_z_opt_(count_src) const T_from* src, _In_ size_t count_src)
 		{
-			_Assume_(src || !count_src);
+			stdex_assert(src || !count_src);
 			count_src = strnlen<T_from>(src, count_src);
 			if (!count_src) _Unlikely_
 				return;
@@ -185,7 +186,7 @@ namespace stdex
 			constexpr DWORD dwFlagsWCMB = 0;
 			constexpr LPCCH lpDefaultChar = NULL;
 
-			_Assume_(src);
+			stdex_assert(src);
 			if (m_from_wincp == m_to_wincp) _Unlikely_{
 				dst.append(reinterpret_cast<const T_to*>(src), count_src);
 				return;
@@ -193,7 +194,7 @@ namespace stdex
 
 #pragma warning(suppress: 4127)
 			if constexpr (sizeof(T_from) == sizeof(char) && sizeof(T_to) == sizeof(wchar_t)) {
-				_Assume_(count_src < INT_MAX || count_src == SIZE_MAX);
+				stdex_assert(count_src < INT_MAX || count_src == SIZE_MAX);
 
 				// Try to convert to stack buffer first.
 				DWORD dwFlagsMBWC = static_cast<UINT>(m_from_wincp) < CP_UTF7 ? MB_PRECOMPOSED : 0;
@@ -220,7 +221,7 @@ namespace stdex
 
 #pragma warning(suppress: 4127)
 			if constexpr (sizeof(T_from) == sizeof(wchar_t) && sizeof(T_to) == sizeof(char)) {
-				_Assume_(count_src < INT_MAX || count_src == SIZE_MAX);
+				stdex_assert(count_src < INT_MAX || count_src == SIZE_MAX);
 
 				// Try to convert to stack buffer first.
 				CHAR szStackBuffer[1024 / sizeof(CHAR)];
@@ -246,7 +247,7 @@ namespace stdex
 
 #pragma warning(suppress: 4127)
 			if constexpr (sizeof(T_from) == sizeof(char) && sizeof(T_to) == sizeof(char)) {
-				_Assume_(count_src < INT_MAX || count_src == SIZE_MAX);
+				stdex_assert(count_src < INT_MAX || count_src == SIZE_MAX);
 
 				// Try to convert to stack buffer first.
 				DWORD dwFlagsMBWC = static_cast<UINT>(m_from_wincp) < CP_UTF7 ? MB_PRECOMPOSED : 0, dwResult;
@@ -256,7 +257,7 @@ namespace stdex
 				if (cch) {
 					// Append from stack.
 					size_t count_inter = count_src != SIZE_MAX ? wcsnlen(szStackBufferMBWC, cch) : static_cast<size_t>(cch) - 1;
-					_Assume_(count_inter < INT_MAX);
+					stdex_assert(count_inter < INT_MAX);
 
 					// Try to convert to stack buffer first.
 					CHAR szStackBufferWCMB[512 / sizeof(CHAR)];
@@ -843,7 +844,7 @@ namespace stdex
 		count_src = strnlen(src, count_src);
 		size_t count_dst = dst.size();
 		dst.resize(count_dst + count_src);
-		_Assume_(count_src + 1 < INT_MAX);
+		stdex_assert(count_src + 1 < INT_MAX);
 #pragma warning(suppress: 6387) // Testing indicates src may be NULL when count_src is also 0. Is SAL of the lpSrcString parameter wrong?
 		int r = NormalizeString(NormalizationC, src, static_cast<int>(count_src), dst.data() + count_dst, static_cast<int>(count_src + 1));
 		if (r >= 0)

include/stdex/uuid.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "assert.hpp"
 #include "compat.hpp"
 #include <stdint.h>
 #include <stdio.h>
@@ -26,7 +27,7 @@ namespace stdex
 	///
 	inline void uuidtostr(_Out_writes_z_(39) char str[39], _In_ const uuid_t& id)
 	{
-		_Assume_(str);
+		stdex_assert(str);
 #ifdef _WIN32
 		_snprintf_s_l(str, 39, _TRUNCATE, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", NULL,
 			id.Data1,
@@ -52,7 +53,7 @@ namespace stdex
 	///
 	inline void uuidtostr(_Out_writes_z_(39) wchar_t str[39], _In_ const uuid_t& id)
 	{
-		_Assume_(str);
+		stdex_assert(str);
 #ifdef _WIN32
 		_snwprintf_s_l(str, 39, _TRUNCATE, L"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", NULL,
 			id.Data1,

include/stdex/zlib.hpp

@@ -5,6 +5,7 @@
 
 #pragma once
 
+#include "assert.hpp"
 #include "compat.hpp"
 #include "stream.hpp"
 #if _MSC_VER
@@ -79,7 +80,7 @@ namespace stdex
 		virtual _Success_(return != 0) size_t write(
 			_In_reads_bytes_opt_(length) const void* data, _In_ size_t length)
 		{
-			_Assume_(data || !length);
+			stdex_assert(data || !length);
 			size_t num_written = 0;
 			while (length) {
 				uInt num_inflated = static_cast<uInt>(std::min<size_t>(length, UINT_MAX));
@@ -136,7 +137,7 @@ namespace stdex
 		virtual _Success_(return != 0 || length == 0) size_t read(
 			_Out_writes_bytes_to_opt_(length, return) void* data, _In_ size_t length)
 		{
-			_Assume_(data || !length);
+			stdex_assert(data || !length);
 			size_t num_read = 0;
 			while (length) {
 				uInt num_deflated = static_cast<uInt>(std::min<size_t>(length, UINT_MAX));