Amebis/stdex
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

assert: initial version

Browse Source 
Signed-off-by: Simon Rozman <simon@rozman.si>
This commit is contained in:
Simon Rozman 2024-05-28 10:22:24 +02:00
parent 146c9c948d
commit 5436dda7f6
18 changed files with 412 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
UnitTests/pch.hpp
View File

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

63
include/stdex/assert.hpp Normal file
View File

@ -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
}

9
include/stdex/base64.hpp
View File

@ -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);

15
include/stdex/compat.hpp
View File

@ -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

9
include/stdex/endian.hpp
View File

@ -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_ uint16_t* value) { _Assume_(value); *value = byteswap(*value); }
inline void byteswap(_Inout_ uint32_t* value) { _Assume_(value); *value = byteswap(*value); }
inline void byteswap(_Inout_ uint64_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) { stdex_assert(value); *value = byteswap(*value); }
inline void byteswap(_Inout_ uint32_t* value) { stdex_assert(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)); }

13
include/stdex/hash.hpp
View File

@ -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);
_Assume_(remainder <= length);
stdex_assert(j < 64 && j + remainder <= 64);
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);
_Assume_(i <= length);
stdex_assert(j < 64 && j + length - i <= 64);
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);
}

3
include/stdex/hex.hpp
View File

@ -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));

57
include/stdex/html.hpp
View File

@ -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);
_Assume_(
stdex_assert(t);
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);

7
include/stdex/minisign.hpp
View File

@ -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;

233
include/stdex/parser.hpp
View File

@ -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);
_Assume_(text || start >= end);
stdex_assert(text || !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);
_Assume_(part2 && num_part2 >= 1);
stdex_assert(part1 || !num_part1);
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);
_Assume_(part2 || !num_part2);
_Assume_(part3 && num_part3 >= 1);
stdex_assert(part1 || !num_part1);
stdex_assert(part2 || !num_part2);
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] == ']' &&

5
include/stdex/ring.hpp
View File

@ -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;

39
include/stdex/sgml.hpp
View File

@ -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);
_Assume_(src || !count_src);
stdex_assert(dst || !count_dst);
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);
_Assume_(src || !count_src);
stdex_assert(dst || !count_dst);
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);

67
include/stdex/stream.hpp
View File

@ -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);
_Assume_(V_VT(&var_data) == (VT_ARRAY | VT_UI1));
stdex_assert(V_VT(&var_amount) == VT_I4);
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);
_Assume_(reserved >= size);
stdex_assert(data || !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);

197
include/stdex/string.hpp
View File

@ -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);
_Assume_(str2);
stdex_assert(str1);
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);
_Assume_(str2 || !count);
stdex_assert(str1 || !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);
_Assume_(str2 || !count2);
stdex_assert(str1 || !count1);
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);
_Assume_(str2 || !count2);
stdex_assert(str1 || !count1);
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);
_Assume_(str2 || !j);
stdex_assert(str1 || !i);
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);
_Assume_(str2 || !j);
stdex_assert(str1 || !i);
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);
_Assume_(str2 || !j);
stdex_assert(str1 || !i);
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);
_Assume_(str2);
stdex_assert(str1);
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);
_Assume_(str2);
stdex_assert(str1);
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);
_Assume_(str2 || !count);
stdex_assert(str1 || !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);
_Assume_(str2 || !count);
stdex_assert(str1 || !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);
_Assume_(str2 || !count2);
stdex_assert(str1 || !count1);
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);
_Assume_(str2 || !count2);
stdex_assert(str1 || !count1);
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);
_Assume_(str2);
stdex_assert(str1);
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);
_Assume_(str2 || !count2);
stdex_assert(str1 || !count1);
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);
_Assume_(sample);
stdex_assert(str);
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);
_Assume_(sample);
stdex_assert(str || !count);
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);
_Assume_(sample);
stdex_assert(str);
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);
_Assume_(sample);
stdex_assert(str);
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);
_Assume_(sample);
stdex_assert(str || !count);
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);
_Assume_(sample);
stdex_assert(str || !count);
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);
_Assume_(src);
stdex_assert(dst);
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);
_Assume_(src || !count);
stdex_assert(dst || !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);
_Assume_(src || !count_src);
stdex_assert(dst || !count_dst);
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);
_Assume_(src);
stdex_assert(dst);
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);
_Assume_(src || !count);
stdex_assert(dst || !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);
_Assume_(src || !count_src);
stdex_assert(dst || !count_dst);
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);
_Assume_(src);
stdex_assert(dst);
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);
_Assume_(src != dst.data());
stdex_assert(src);
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);
_Assume_(radix == 0 || 2 <= radix && radix <= 36);
stdex_assert(str || !count);
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]);

3
include/stdex/sys_info.hpp
View File

@ -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();

15
include/stdex/unicode.hpp
View File

@ -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)

5
include/stdex/uuid.hpp
View File

@ -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,

5
include/stdex/zlib.hpp
View File

@ -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));