/*
 *
 * Copyright (c) 1998-2005
 * John Maddock
 *
 * Use, modification and distribution are subject to the
 * Boost Software License, Version 1.0. (See accompanying file
 * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 *
 */

/*
 *   LOCATION:    see http://www.boost.org for most recent version.
 *   FILE         regex_workarounds.cpp
 *   VERSION      see <boost/version.hpp>
 *   DESCRIPTION: Declares Misc workarounds.
 */

#ifndef BOOST_REGEX_WORKAROUND_HPP
#define BOOST_REGEX_WORKAROUND_HPP

#include <boost/config.hpp>
#include <new>
#include <cstring>
#include <cstdlib>
#include <cstddef>
#include <cassert>
#include <cstdio>
#include <climits>
#include <string>
#include <stdexcept>
#include <iterator>
#include <algorithm>
#include <iosfwd>
#include <vector>
#include <set>
#include <map>
#include <boost/limits.hpp>
#include <boost/assert.hpp>
#include <boost/cstdint.hpp>
#include <boost/throw_exception.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/scoped_array.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/mpl/bool_fwd.hpp>
#include <boost/regex/config.hpp>
#ifndef BOOST_NO_STD_LOCALE
#   include <locale>
#endif

#if defined(BOOST_NO_STDC_NAMESPACE)
namespace std {
using ::sprintf;
using ::strcpy;
using ::strcat;
using ::strlen;
}
#endif

namespace boost {
namespace BOOST_REGEX_DETAIL_NS {
#ifdef BOOST_NO_STD_DISTANCE
template <class T>
std::ptrdiff_t
distance(const T& x, const T& y)
{
    return y - x;
}
#else
using std::distance;
#endif
}
}

#ifdef BOOST_REGEX_NO_BOOL
#  define BOOST_REGEX_MAKE_BOOL(x) static_cast<bool>((x) ? true : false)
#else
#  define BOOST_REGEX_MAKE_BOOL(x) static_cast<bool>(x)
#endif

/*****************************************************************************
 *
 *  Fix broken namespace support:
 *
 ****************************************************************************/

#if defined(BOOST_NO_STDC_NAMESPACE) && defined(__cplusplus)

namespace std {
using ::ptrdiff_t;
using ::size_t;
using ::abs;
using ::memset;
using ::memcpy;
}

#endif

/*****************************************************************************
 *
 *  helper functions pointer_construct/pointer_destroy:
 *
 ****************************************************************************/

#ifdef __cplusplus
namespace boost {
namespace BOOST_REGEX_DETAIL_NS {

#ifdef BOOST_MSVC
#pragma warning (push)
#pragma warning (disable : 4100)
#endif

template <class T>
inline void
pointer_destroy(T* p)
{
    p->~T();
    (void)p;
}

#ifdef BOOST_MSVC
#pragma warning (pop)
#endif

template <class T>
inline void
pointer_construct(T* p, const T& t)
{
    new (p) T(t);
}

}
} // namespaces
#endif

/*****************************************************************************
 *
 *  helper function copy:
 *
 ****************************************************************************/

#ifdef __cplusplus
namespace boost {
namespace BOOST_REGEX_DETAIL_NS {
#if BOOST_WORKAROUND(BOOST_MSVC,>=1400) && BOOST_WORKAROUND(BOOST_MSVC, <1600) && defined(_CPPLIB_VER) && defined(BOOST_DINKUMWARE_STDLIB) && !(defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION))
//
// MSVC 8 will either emit warnings or else refuse to compile
// code that makes perfectly legitimate use of std::copy, when
// the OutputIterator type is a user-defined class (apparently all user
// defined iterators are "unsafe").  This code works around that:
//
template<class InputIterator, class OutputIterator>
inline OutputIterator
copy(
    InputIterator first,
    InputIterator last,
    OutputIterator dest
)
{
    return stdext::unchecked_copy(first, last, dest);
}
template<class InputIterator1, class InputIterator2>
inline bool
equal(
    InputIterator1 first,
    InputIterator1 last,
    InputIterator2 with
)
{
    return stdext::unchecked_equal(first, last, with);
}
#elif BOOST_WORKAROUND(BOOST_MSVC, > 1500)
//
// MSVC 10 will either emit warnings or else refuse to compile
// code that makes perfectly legitimate use of std::copy, when
// the OutputIterator type is a user-defined class (apparently all user
// defined iterators are "unsafe").  What's more Microsoft have removed their
// non-standard "unchecked" versions, even though their still in the MS
// documentation!! Work around this as best we can:
//
template<class InputIterator, class OutputIterator>
inline OutputIterator
copy(
    InputIterator first,
    InputIterator last,
    OutputIterator dest
)
{
    while (first != last)
    {
        *dest++ = *first++;
    }

    return dest;
}
template<class InputIterator1, class InputIterator2>
inline bool
equal(
    InputIterator1 first,
    InputIterator1 last,
    InputIterator2 with
)
{
    while (first != last)
        if (*first++ != *with++)
        {
            return false;
        }

    return true;
}
#else
using std::copy;
using std::equal;
#endif
#if BOOST_WORKAROUND(BOOST_MSVC,>=1400) && defined(__STDC_WANT_SECURE_LIB__) && __STDC_WANT_SECURE_LIB__

// use safe versions of strcpy etc:
using ::strcpy_s;
using ::strcat_s;
#else
inline std::size_t
strcpy_s(
    char *strDestination,
    std::size_t sizeInBytes,
    const char *strSource
)
{
    std::size_t lenSourceWithNull = std::strlen(strSource) + 1;

    if (lenSourceWithNull > sizeInBytes)
    {
        return 1;
    }

    std::memcpy(strDestination, strSource, lenSourceWithNull);
    return 0;
}
inline std::size_t
strcat_s(
    char *strDestination,
    std::size_t sizeInBytes,
    const char *strSource
)
{
    std::size_t lenSourceWithNull = std::strlen(strSource) + 1;
    std::size_t lenDestination = std::strlen(strDestination);

    if (lenSourceWithNull + lenDestination > sizeInBytes)
    {
        return 1;
    }

    std::memcpy(strDestination + lenDestination, strSource, lenSourceWithNull);
    return 0;
}

#endif

inline void
overflow_error_if_not_zero(std::size_t i)
{
    if (i)
    {
        std::overflow_error e("String buffer too small");
        boost::throw_exception(e);
    }
}

}
} // namespaces

#endif // __cplusplus

#endif // include guard
