Commit 904d4f7c authored by Marc Vef's avatar Marc Vef
Browse files

Adding Guideline support library

parent 5fb17e06

external/gsl/gsl

0 → 100644
+29 −0
Original line number Diff line number Diff line 
///////////////////////////////////////////////////////////////////////////////

//

// Copyright (c) 2015 Microsoft Corporation. All rights reserved.

//

// This code is licensed under the MIT License (MIT).

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

// THE SOFTWARE.

//

///////////////////////////////////////////////////////////////////////////////



#ifndef GSL_GSL_H

#define GSL_GSL_H



#include <gsl/gsl_algorithm> // copy

#include <gsl/gsl_assert>    // Ensures/Expects

#include <gsl/gsl_byte>      // byte

#include <gsl/gsl_util>      // finally()/narrow()/narrow_cast()...

#include <gsl/multi_span>    // multi_span, strided_span...

#include <gsl/pointers>      // owner, not_null

#include <gsl/span>          // span

#include <gsl/string_span>   // zstring, string_span, zstring_builder...



#endif // GSL_GSL_H

external/gsl/gsl_algorithm

0 → 100644
+60 −0
Original line number Diff line number Diff line 
///////////////////////////////////////////////////////////////////////////////

//

// Copyright (c) 2015 Microsoft Corporation. All rights reserved.

//

// This code is licensed under the MIT License (MIT).

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

// THE SOFTWARE.

//

///////////////////////////////////////////////////////////////////////////////



#ifndef GSL_ALGORITHM_H

#define GSL_ALGORITHM_H



#include <gsl/gsl_assert> // for Expects

#include <gsl/span>       // for dynamic_extent, span



#include <algorithm>   // for copy_n

#include <cstddef>     // for ptrdiff_t

#include <type_traits> // for is_assignable



#ifdef _MSC_VER

#pragma warning(push)



// turn off some warnings that are noisy about our Expects statements

#pragma warning(disable : 4127) // conditional expression is constant

#pragma warning(disable : 4996) // unsafe use of std::copy_n



#endif // _MSC_VER



namespace gsl {

// Note: this will generate faster code than std::copy using span iterator in older msvc+stl

// not necessary for msvc since VS2017 15.8 (_MSC_VER >= 1915)

template<class SrcElementType, std::size_t SrcExtent, class DestElementType,

        std::size_t DestExtent>

void copy(span<SrcElementType, SrcExtent> src, span<DestElementType, DestExtent> dest) {

    static_assert(std::is_assignable<decltype(*dest.data()), decltype(*src.data())>::value,

                  "Elements of source span can not be assigned to elements of destination span");

    static_assert(SrcExtent == dynamic_extent || DestExtent == dynamic_extent ||

                  (SrcExtent <= DestExtent),

                  "Source range is longer than target range");



    Expects(dest.size() >= src.size());

    GSL_SUPPRESS(stl

                         .1) // NO-FORMAT: attribute

    std::copy_n(src.data(), src.size(), dest.data());

}



} // namespace gsl



#ifdef _MSC_VER

#pragma warning(pop)

#endif // _MSC_VER



#endif // GSL_ALGORITHM_H

external/gsl/gsl_assert

0 → 100644
+130 −0
Original line number Diff line number Diff line 
///////////////////////////////////////////////////////////////////////////////

//

// Copyright (c) 2015 Microsoft Corporation. All rights reserved.

//

// This code is licensed under the MIT License (MIT).

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

// THE SOFTWARE.

//

///////////////////////////////////////////////////////////////////////////////



#ifndef GSL_CONTRACTS_H

#define GSL_CONTRACTS_H



//

// Temporary until MSVC STL supports no-exceptions mode.

// Currently terminate is a no-op in this mode, so we add termination behavior back

//

#if defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))



#define GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND

#include <intrin.h>

#define RANGE_CHECKS_FAILURE 0



#if defined(__clang__)

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Winvalid-noreturn"

#endif // defined(__clang__)



#else // defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))



#include <exception>



#endif // defined(_MSC_VER) && (defined(_KERNEL_MODE) || (defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS))



//

// make suppress attributes parse for some compilers

// Hopefully temporary until suppression standardization occurs

//

#if defined(__clang__)

#define GSL_SUPPRESS(x) [[gsl::suppress("x")]]

#else

#if defined(_MSC_VER)

#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]

#else

#define GSL_SUPPRESS(x)

#endif // _MSC_VER

#endif // __clang__



#define GSL_STRINGIFY_DETAIL(x) #x

#define GSL_STRINGIFY(x) GSL_STRINGIFY_DETAIL(x)



#if defined(__clang__) || defined(__GNUC__)

#define GSL_LIKELY(x) __builtin_expect(!!(x), 1)

#define GSL_UNLIKELY(x) __builtin_expect(!!(x), 0)



#else



#define GSL_LIKELY(x) (!!(x))

#define GSL_UNLIKELY(x) (!!(x))

#endif // defined(__clang__) || defined(__GNUC__)



//

// GSL_ASSUME(cond)

//

// Tell the optimizer that the predicate cond must hold. It is unspecified

// whether or not cond is actually evaluated.

//

#ifdef _MSC_VER

#define GSL_ASSUME(cond) __assume(cond)

#elif defined(__GNUC__)

#define GSL_ASSUME(cond) ((cond) ? static_cast<void>(0) : __builtin_unreachable())

#else

#define GSL_ASSUME(cond) static_cast<void>((cond) ? 0 : 0)

#endif



//

// GSL.assert: assertions

//



namespace gsl {



namespace details {

#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)



typedef void(__cdecl* terminate_handler)();



// clang-format off

GSL_SUPPRESS(f.6) // NO-FORMAT: attribute

// clang-format on

[[noreturn]] inline void __cdecl default_terminate_handler()

{

    __fastfail(RANGE_CHECKS_FAILURE);

}



inline gsl::details::terminate_handler& get_terminate_handler() noexcept

{

    static terminate_handler handler = &default_terminate_handler;

    return handler;

}



#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)



[[noreturn]] inline void terminate() noexcept {

#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)

    (*gsl::details::get_terminate_handler())();

#else

    std::terminate();

#endif // defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND)

}



} // namespace details

} // namespace gsl



#define GSL_CONTRACT_CHECK(type, cond)                                                             \

    (GSL_LIKELY(cond) ? static_cast<void>(0) : gsl::details::terminate())



#define Expects(cond) GSL_CONTRACT_CHECK("Precondition", cond)

#define Ensures(cond) GSL_CONTRACT_CHECK("Postcondition", cond)



#if defined(GSL_MSVC_USE_STL_NOEXCEPTION_WORKAROUND) && defined(__clang__)

#pragma clang diagnostic pop

#endif



#endif // GSL_CONTRACTS_H

external/gsl/gsl_byte

0 → 100644
+194 −0
Original line number Diff line number Diff line 
///////////////////////////////////////////////////////////////////////////////

//

// Copyright (c) 2015 Microsoft Corporation. All rights reserved.

//

// This code is licensed under the MIT License (MIT).

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

// THE SOFTWARE.

//

///////////////////////////////////////////////////////////////////////////////



#ifndef GSL_BYTE_H

#define GSL_BYTE_H



//

// make suppress attributes work for some compilers

// Hopefully temporary until suppression standardization occurs

//

#if defined(__clang__)

#define GSL_SUPPRESS(x) [[gsl::suppress("x")]]

#else

#if defined(_MSC_VER)

#define GSL_SUPPRESS(x) [[gsl::suppress(x)]]

#else

#define GSL_SUPPRESS(x)

#endif // _MSC_VER

#endif // __clang__



#include <type_traits>



// VS2017 15.8 added support for the __cpp_lib_byte definition

// To do: drop _HAS_STD_BYTE when support for pre 15.8 expires

#ifdef _MSC_VER



#pragma warning(push)



// Turn MSVC /analyze rules that generate too much noise. TODO: fix in the tool.

#pragma warning(disable : 26493) // don't use c-style casts // TODO: MSVC suppression in templates does not always work



#ifndef GSL_USE_STD_BYTE

// this tests if we are under MSVC and the standard lib has std::byte and it is enabled

#if (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)



#define GSL_USE_STD_BYTE 1



#else // (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)



#define GSL_USE_STD_BYTE 0



#endif // (defined(_HAS_STD_BYTE) && _HAS_STD_BYTE) || (defined(__cpp_lib_byte) && __cpp_lib_byte >= 201603)

#endif // GSL_USE_STD_BYTE



#else // _MSC_VER



#ifndef GSL_USE_STD_BYTE



#include <cstddef> /* __cpp_lib_byte */

// this tests if we are under GCC or Clang with enough -std:c++1z power to get us std::byte

// also check if libc++ version is sufficient (> 5.0) or libstc++ actually contains std::byte

#if defined(__cplusplus) && (__cplusplus >= 201703L) && \

  (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603) || \

   defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))



#define GSL_USE_STD_BYTE 1



#else // defined(__cplusplus) && (__cplusplus >= 201703L) &&

//   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||

//    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))



#define GSL_USE_STD_BYTE 0



#endif //defined(__cplusplus) && (__cplusplus >= 201703L) &&

//   (defined(__cpp_lib_byte) && (__cpp_lib_byte >= 201603)  ||

//    defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION >= 5000))

#endif // GSL_USE_STD_BYTE



#endif // _MSC_VER



// Use __may_alias__ attribute on gcc and clang

#if defined __clang__ || (defined(__GNUC__) && __GNUC__ > 5)

#define byte_may_alias __attribute__((__may_alias__))

#else // defined __clang__ || defined __GNUC__

#define byte_may_alias

#endif // defined __clang__ || defined __GNUC__



#if GSL_USE_STD_BYTE

#include <cstddef>

#endif



namespace gsl {

#if GSL_USE_STD_BYTE



using std::byte;

using std::to_integer;



#else // GSL_USE_STD_BYTE



// This is a simple definition for now that allows

// use of byte within span<> to be standards-compliant

enum class byte_may_alias byte : unsigned char {

};



template<class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>

constexpr byte& operator<<=(byte& b, IntegerType shift) noexcept {

    return b = byte(static_cast<unsigned char>(b) << shift);

}



template<class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>

constexpr byte operator<<(byte b, IntegerType shift) noexcept {

    return byte(static_cast<unsigned char>(b) << shift);

}



template<class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>

constexpr byte& operator>>=(byte& b, IntegerType shift) noexcept {

    return b = byte(static_cast<unsigned char>(b) >> shift);

}



template<class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>

constexpr byte operator>>(byte b, IntegerType shift) noexcept {

    return byte(static_cast<unsigned char>(b) >> shift);

}



constexpr byte& operator|=(byte& l, byte r) noexcept {

    return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));

}



constexpr byte operator|(byte l, byte r) noexcept {

    return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));

}



constexpr byte& operator&=(byte& l, byte r) noexcept {

    return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));

}



constexpr byte operator&(byte l, byte r) noexcept {

    return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));

}



constexpr byte& operator^=(byte& l, byte r) noexcept {

    return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));

}



constexpr byte operator^(byte l, byte r) noexcept {

    return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));

}



constexpr byte operator~(byte b) noexcept { return byte(~static_cast<unsigned char>(b)); }



template<class IntegerType, class = std::enable_if_t<std::is_integral<IntegerType>::value>>

constexpr IntegerType to_integer(byte b) noexcept {

    return static_cast<IntegerType>(b);

}



#endif // GSL_USE_STD_BYTE



template<bool E, typename T>

constexpr byte to_byte_impl(T t) noexcept {

    static_assert(

            E, "gsl::to_byte(t) must be provided an unsigned char, otherwise data loss may occur. "

               "If you are calling to_byte with an integer contant use: gsl::to_byte<t>() version.");

    return static_cast<byte>(t);

}



template<>

// NOTE: need suppression since c++14 does not allow "return {t}"

// GSL_SUPPRESS(type.4) // NO-FORMAT: attribute // TODO: suppression does not work

constexpr byte to_byte_impl<true, unsigned char>(unsigned char t) noexcept {

    return byte(t);

}



template<typename T>

constexpr byte to_byte(T t) noexcept {

    return to_byte_impl<std::is_same<T, unsigned char>::value, T>(t);

}



template<int I>

constexpr byte to_byte() noexcept {

    static_assert(I >= 0 && I <= 255,

                  "gsl::byte only has 8 bits of storage, values must be in range 0-255");

    return static_cast<byte>(I);

}



} // namespace gsl



#ifdef _MSC_VER

#pragma warning(pop)

#endif // _MSC_VER



#endif // GSL_BYTE_H

external/gsl/gsl_util

0 → 100644
+153 −0
Original line number Diff line number Diff line 
///////////////////////////////////////////////////////////////////////////////

//

// Copyright (c) 2015 Microsoft Corporation. All rights reserved.

//

// This code is licensed under the MIT License (MIT).

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

// THE SOFTWARE.

//

///////////////////////////////////////////////////////////////////////////////



#ifndef GSL_UTIL_H

#define GSL_UTIL_H



#include <gsl/gsl_assert> // for Expects



#include <array>

#include <cstddef>          // for ptrdiff_t, size_t

#include <initializer_list> // for initializer_list

#include <type_traits>      // for is_signed, integral_constant

#include <utility>          // for exchange, forward



#if defined(_MSC_VER) && !defined(__clang__)



#pragma warning(push)

#pragma warning(disable : 4127) // conditional expression is constant



#endif            // _MSC_VER



namespace gsl {

//

// GSL.util: utilities

//



// index type for all container indexes/subscripts/sizes

using index = std::ptrdiff_t;



// final_action allows you to ensure something gets run at the end of a scope

template<class F>

class final_action {

public:

    explicit final_action(F f) noexcept : f_(std::move(f)) {}



    final_action(final_action&& other) noexcept : f_(std::move(other.f_)),

                                                  invoke_(std::exchange(other.invoke_, false)) {}



    final_action(const final_action&) = delete;



    final_action& operator=(const final_action&) = delete;



    final_action& operator=(final_action&&) = delete;



    GSL_SUPPRESS(f

                         .6) // NO-FORMAT: attribute // terminate if throws

    ~final_action() noexcept {

        if (invoke_) f_();

    }



private:

    F f_;

    bool invoke_{true};

};



// finally() - convenience function to generate a final_action

template<class F>

final_action<F> finally(const F& f) noexcept {

    return final_action<F>(f);

}



template<class F>

final_action<F> finally(F&& f) noexcept {

    return final_action<F>(std::forward<F>(f));

}



// narrow_cast(): a searchable way to do narrowing casts of values

template<class T, class U>

GSL_SUPPRESS(type

                     .1) // NO-FORMAT: attribute

constexpr T narrow_cast(U&& u) noexcept {

    return static_cast<T>(std::forward<U>(u));

}



struct narrowing_error : public std::exception {

};



namespace details {

template<class T, class U>

struct is_same_signedness

        : public std::integral_constant<bool, std::is_signed<T>::value == std::is_signed<U>::value> {

};

} // namespace details



// narrow() : a checked version of narrow_cast() that throws if the cast changed the value

template<class T, class U>

GSL_SUPPRESS(type

                     .1) // NO-FORMAT: attribute

GSL_SUPPRESS(f

                     .6) // NO-FORMAT: attribute // TODO: MSVC /analyze does not recognise noexcept(false)

constexpr

T narrow(U u) noexcept(false) {

    T t = narrow_cast<T>(u);

    if (static_cast<U>(t) != u) throw narrowing_error{};

    if (!details::is_same_signedness<T, U>::value && ((t < T{}) != (u < U{})))

        throw narrowing_error{};

    return t;

}



//

// at() - Bounds-checked way of accessing builtin arrays, std::array, std::vector

//

template<class T, std::size_t N>

GSL_SUPPRESS(bounds

                     .4) // NO-FORMAT: attribute

GSL_SUPPRESS(bounds

                     .2) // NO-FORMAT: attribute

constexpr T& at(T (& arr)[N], const index i) {

    Expects(i >= 0 && i < narrow_cast<index>(N));

    return arr[narrow_cast<std::size_t>(i)];

}



template<class Cont>

GSL_SUPPRESS(bounds

                     .4) // NO-FORMAT: attribute

GSL_SUPPRESS(bounds

                     .2) // NO-FORMAT: attribute

constexpr auto at(Cont& cont, const index i) -> decltype(cont[cont.size()]) {

    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));

    using size_type = decltype(cont.size());

    return cont[narrow_cast<size_type>(i)];

}



template<class T>

GSL_SUPPRESS(bounds

                     .1) // NO-FORMAT: attribute

constexpr T at(const std::initializer_list<T> cont, const index i) {

    Expects(i >= 0 && i < narrow_cast<index>(cont.size()));

    return *(cont.begin() + i);

}



} // namespace gsl



#if defined(_MSC_VER) && !defined(__clang__)



#pragma warning(pop)



#endif // _MSC_VER



#endif // GSL_UTIL_H