p9rs7xtfl
/
p3elvfktj
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
p3elvfktj/AES/include/rw/_traits.h

675 lines
18 KiB
Raw Permalink Blame History

/***************************************************************************
*
* _traits.h - Declarations for char_traits
*
* This is an internal header file used to implement the C++ Standard
* Library. It should never be #included directly by a program.
*
* $Id: _traits.h 172106 2011-11-02 17:04:12Z statham $
*
***************************************************************************
*
* Copyright (c) 1994-2001 Rogue Wave Software, Inc. All Rights Reserved.
*
* This computer software is owned by Rogue Wave Software, Inc. and is
* protected by U.S. copyright laws and other laws and by international
* treaties. This computer software is furnished by Rogue Wave Software,
* Inc. pursuant to a written license agreement and may be used, copied,
* transmitted, and stored only in accordance with the terms of such
* license and with the inclusion of the above copyright notice. This
* computer software or any other copies thereof may not be provided or
* otherwise made available to any other person.
*
* U.S. Government Restricted Rights. This computer software is provided
* with Restricted Rights. Use, duplication, or disclosure by the
* Government is subject to restrictions as set forth in subparagraph (c)
* (1) (ii) of The Rights in Technical Data and Computer Software clause
* at DFARS 252.227-7013 or subparagraphs (c) (1) and (2) of the
* Commercial Computer Software--Restricted Rights at 48 CFR 52.227-19,
* as applicable. Manufacturer is Rogue Wave Software, Inc., 5500
* Flatiron Parkway, Boulder, Colorado 80301 USA.
*
**************************************************************************/
#ifndef _RWSTD_TRAITS_H_INCLUDED
#define _RWSTD_TRAITS_H_INCLUDED
#include <rw/_defs.h>
#include _RWSTD_CSTDDEF
#include _RWSTD_CSTDIO
#include _RWSTD_CSTRING
#include _RWSTD_CWCHAR
#ifdef _WIN64
# include _RWSTD_SYS_TYPES_H
#endif
#if defined (_RWSTD_STRICT_ANSI)
_RWSTD_USING_SNI (uid_t);
#endif
_RWSTD_NAMESPACE_BEGIN (std)
// 27.4.1, p2
typedef _RWSTD_SSIZE_T streamsize;
typedef _RWSTD_SSIZE_T streamoff;
/* fpos<> maintains all the information necessary to restore an arbitrary
* sequence, controlled by the Standard C++ library, to a previous stream
* position and conversion state.
*/
template <class _StateT>
class fpos
{
public:
typedef _StateT state_type;
fpos (streamoff __off = 0) // allowing a default is an extension to the standard
: _C_pos (__off),
_C_state ()
{
}
fpos (streamoff __off, state_type __state) // allowing two arguments is an extension to the standard
: _C_pos (__off),
_C_state (__state)
{ }
operator streamoff () const {
return _C_pos;
}
fpos (const fpos&);
fpos& operator= (const fpos&);
state_type state () const {
return _C_state;
}
void state (state_type __state) {
_C_state = __state;
}
// arithmetic operators
fpos operator- (const fpos &__off) const {
return fpos (*this) -= __off;
}
fpos operator+ (const fpos &__off) const {
return fpos (*this) += __off;
}
fpos& operator-= (const fpos &__off) {
return _C_pos -= __off._C_pos, *this;
}
fpos& operator+= (const fpos &__off) {
return _C_pos += __off._C_pos, *this;
}
fpos operator- (streamoff __off) const {
return fpos (*this) -= __off;
}
fpos operator+ (streamoff __off) const {
return fpos (*this) += __off;
}
fpos& operator-= (streamoff __off) {
return _C_pos -= __off, *this;
}
fpos& operator+= (streamoff __off) {
return _C_pos += __off, *this;
}
// relational operators
bool operator== (const fpos& __rhs) const;
bool operator< (const fpos& __rhs) const {
return _C_pos < __rhs._C_pos;
}
bool operator<= (const fpos& __rhs) const {
return !(__rhs < *this);
}
bool operator>= (const fpos& __rhs) const {
return !(*this < __rhs);
}
bool operator!= (const fpos& __rhs) const {
return !(*this == __rhs);
}
bool operator> (const fpos& __rhs) const {
return __rhs < *this;
}
bool operator== (streamoff __rhs) const {
return _C_pos == __rhs;
}
bool operator< (streamoff __rhs) const {
return _C_pos < __rhs;
}
bool operator<= (streamoff __rhs) const {
return _C_pos <= __rhs;
}
bool operator>= (streamoff __rhs) const {
return _C_pos >= __rhs;
}
bool operator> (streamoff __rhs) const {
return _C_pos > __rhs;
}
bool operator!= (streamoff __rhs) const {
return !(_C_pos == __rhs);
}
private:
streamoff _C_pos; // signed displacement
state_type _C_state; // conversion state
};
template <class _StateT>
inline
fpos<_StateT>::fpos(const fpos<_StateT>& __rhs)
{
_C_pos = __rhs._C_pos;
_C_state = __rhs._C_state;
}
template <class _StateT>
inline fpos<_StateT>&
fpos<_StateT>::operator= (const fpos<_StateT>& __rhs)
{
if (&__rhs != this) {
_C_pos = __rhs._C_pos;
_C_state = __rhs._C_state;
}
return *this;
}
template <class _StateT>
inline bool
fpos<_StateT>::operator== (const fpos<_StateT>& __rhs) const
{
return _C_pos == __rhs._C_pos
#ifndef _RWSTD_NO_MBSTATE_COMPARE
&& _C_state == __rhs._C_state
#endif
;
}
template <class _CharT>
struct char_traits
{
typedef _CharT char_type;
typedef int int_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
typedef fpos<state_type> pos_type;
static int_type eof () {
return EOF;
}
static void assign (char_type& __c1, const char_type& __c2) {
__c1 = __c2;
}
static bool eq (const char_type& __c1, const char_type& __c2) {
return __c1 == __c2;
}
static bool lt (const char_type& __c1, const char_type& __c2) {
return __c1 < __c2;
}
static int compare (const char_type* __s1, const char_type* __s2,
_RWSTD_C::size_t __n) {
_RWSTD_C::size_t __i = 0;
while (__i < __n) {
if (!eq (__s1[__i], __s2[__i])) {
return lt (__s1[__i], __s2[__i]) ? -1 : 1;
}
++__i;
}
return 0;
}
static _RWSTD_C::size_t length (const char_type *__s) {
_RWSTD_C::size_t __len = 0;
while (!eq (*__s++, char_type ()))
++__len;
return __len;
}
static const char_type*
find (const char_type* __s, _RWSTD_C::size_t __n, const char_type& __a) {
while (__n-- > 0 && !eq (*__s, __a) )
++__s;
return eq (*__s, __a) ? __s : 0;
}
static char_type* move (char_type* __s1, const char_type* __s2,
_RWSTD_C::size_t __n) {
if (__s1 < __s2)
copy (__s1, __s2, __n);
else if (__s1 > __s2) {
__s1 += __n;
__s2 += __n;
for (_RWSTD_C::size_t __i = 0; __i < __n; ++__i)
assign (*--__s1, *--__s2);
}
return __s1;
}
static char_type* copy (char_type *__dst, const char_type *__src,
_RWSTD_C::size_t __n) {
memcpy (__dst, __src, __n * sizeof (char_type));
return __dst;
}
static char_type* assign (char_type* __s, _RWSTD_C::size_t __n, char_type __a) {
char_type* __tmp = __s;
while (__n-- > 0)
assign (*__tmp++, __a);
return __s;
}
static bool eq_int_type (const int_type& __c1, const int_type& __c2) {
return __c1 == __c2;
}
static int_type not_eof (const int_type& __c) {
return eq_int_type (eof (), __c) ? 0 : __c;
}
static char_type to_char_type (const int_type& __c) {
return __c;
}
static int_type to_int_type (const char_type& __c) {
return __c;
}
};
// 21.1.3.1
_RWSTD_SPECIALIZED_CLASS
struct char_traits<char>
{
typedef char char_type;
typedef _RWSTD_INT_T int_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
typedef fpos<state_type> pos_type;
static int_type eof () {
return EOF;
}
static void assign (char_type& __c1, const char_type& __c2){
__c1 = __c2;
}
static bool eq (const char_type& __c1, const char_type& __c2) {
return __c1 == __c2;
}
static bool lt (const char_type& __c1, const char_type& __c2) {
return __c1 < __c2;
}
static int compare (const char_type* __s1, const char_type* __s2,
_RWSTD_C::size_t __n) {
return memcmp (__s1, __s2, __n);
}
static const char_type* find (const char_type* __s,
_RWSTD_C::size_t __n, const char_type& __a) {
return (char_type*) memchr (__s, __a, __n);
}
static _RWSTD_C::size_t length (const char_type *__s) {
return strlen (__s);
}
static char_type * move (char_type* __s1, const char_type* __s2,
_RWSTD_C::size_t __n) {
#ifndef _RWSTD_NO_MEMMOVE
memmove (__s1, __s2, __n);
#else
if (__s1 < __s2)
copy (__s1, __s2, __n);
else if (__s1 > __s2) {
__s1 += __n;
__s2 += __n;
for (_RWSTD_C::size_t __i = 0; __i < __n; ++__i)
assign (*--__s1, *--__s2);
}
#endif
return __s1;
}
static char_type *copy (char_type *__dst, const char_type *__src,
_RWSTD_C::size_t __n){
memcpy (__dst, __src, __n);
return __dst;
}
static char_type* assign (char_type* __s, _RWSTD_C::size_t __n, char_type __a) {
memset (__s, __a, __n);
return __s;
}
static bool eq_int_type (const int_type& __c1, const int_type& __c2) {
return __c1 == __c2;
}
static int_type not_eof (const int_type& __c) {
return eq_int_type (eof (), __c) ? 0 : __c;
}
static char_type to_char_type (const int_type& __c) {
return _RWSTD_STATIC_CAST (char_type, __c);
}
static int_type to_int_type (const char_type& __c) {
// make sure (signed char)'\xff' converts to 255 and not -1
return _RWSTD_STATIC_CAST (unsigned char, __c);
}
};
#ifndef _RWSTD_NO_WCHAR_T
// 21.1.3.2
_RWSTD_SPECIALIZED_CLASS
struct char_traits<wchar_t>
{
typedef wchar_t char_type;
typedef _RWSTD_WINT_T int_type;
typedef streamoff off_type;
typedef mbstate_t state_type;
typedef fpos<state_type> pos_type;
#ifndef WEOF
# define WEOF (-1)
#endif
static int_type eof () {
return int_type (WEOF);
}
static void assign (char_type& __c1, const char_type& __c2) {
__c1 = __c2;
}
static bool eq (const char_type& __c1, const char_type& __c2) {
return __c1 == __c2;
}
static bool lt (const char_type& __c1, const char_type& __c2) {
return __c1 < __c2;
}
static int compare (const char_type* __s1, const char_type* __s2,
_RWSTD_C::size_t __n) {
#ifndef _RWSTD_NO_WMEMCMP
return wmemcmp (__s1, __s2, __n);
#else
_RWSTD_C::size_t __i=0;
while (__i < __n) {
if (!eq (__s1[__i], __s2[__i])) {
return lt (__s1[__i], __s2[__i]) ? -1 : 1;
}
++__i;
}
return 0;
#endif
}
static _RWSTD_C::size_t length (const char_type *__s) {
#ifndef _RWSTD_NO_WCSLEN
// [harmless] cast necessary on CygWin
return wcslen (_RWSTD_CONST_CAST (char_type*, __s));
#else
_RWSTD_C::size_t __len = 0;
while (!eq (*__s++, char_type ()))
++__len;
return __len;
#endif
}
static const char_type* find (const char_type* __s, _RWSTD_C::size_t __n,
const char_type& __a) {
#ifndef _RWSTD_NO_WMEMCHR
return _RWSTD_STATIC_CAST (const char_type*, wmemchr (__s, __a, __n));
#else
while (__n-- > 0 && !eq (*__s, __a))
++__s;
return eq (*__s, __a) ? __s : 0;
#endif // _RWSTD_NO_WMEMCHR
}
static char_type * copy (char_type *__dst, const char_type *__src,
_RWSTD_C::size_t __n) {
memcpy (__dst, __src, __n * sizeof (char_type));
return __dst;
}
static char_type * move (char_type* __s1, const char_type* __s2,
_RWSTD_C::size_t __n) {
#ifndef _RWSTD_NO_WMEMMOVE
wmemmove (__s1, __s2, __n);
#else
if (__s1 < __s2)
copy (__s1, __s2, __n);
else if (__s1 > __s2) {
__s1 += __n;
__s2 += __n;
for (_RWSTD_C::size_t __i = 0; __i < __n; ++__i)
assign (*--__s1, *--__s2);
}
#endif // _RWSTD_NO_WMEMMOVE
return __s1;
}
static char_type* assign (char_type* __s, _RWSTD_C::size_t __n, char_type __a){
#ifndef _RWSTD_NO_WMEMSET
wmemset (__s, __a, __n);
#else
char_type* __tmp = __s;
while (__n-- > 0)
assign (*__tmp++, __a);
#endif // _RWSTD_NO_WMEMSET
return __s;
}
static bool eq_int_type (const int_type& __c1, const int_type& __c2) {
return __c1 == __c2;
}
static int_type not_eof (const int_type& __c) {
return eq_int_type (eof (), __c) ? 0 : __c;
}
static char_type to_char_type (const int_type& __c) {
return __c;
}
static int_type to_int_type (const char_type& __c) {
return __c;
}
};
#endif
_RWSTD_NAMESPACE_END // std
_RWSTD_NAMESPACE_BEGIN (__rw)
// Implementation _Traits class, rw_traits, provides specialized
// algorithms to speed up find operations on char and wchar_t strings
template <class _CharT, class _Traits>
struct rw_traits
{
static const _CharT* find (const _CharT* __s, const _CharT* __v) {
_RWSTD_C::size_t __slen = _Traits::length (__s);
_RWSTD_C::size_t __vlen = _Traits::length (__v);
for (_RWSTD_C::size_t __j = 0; (__j + __vlen) <= __slen ; ++__j) {
bool __found = true;
for (_RWSTD_C::size_t __i = 0; __i < __vlen ; ++__i) {
if (!_Traits::eq (__s[__j + __i], __v[__i])) {
__found = false;
break;
}
}
if (__found)
return &__s[__j];
}
return 0;
}
static const _CharT* rfind (const _CharT* __s, _CharT __v, _RWSTD_C::size_t __pos) {
for (const _CharT* __p = __s + __pos; __p >= __s; --__p) {
if (_Traits::eq (*__p, __v))
return __p;
}
return 0;
}
static _RWSTD_C::size_t find_first_of (const _CharT* __s, const _CharT* __v) {
const _CharT* __p = __s;
for (; !_Traits::eq (*__p, _CharT ()); ++__p) {
for (const _CharT* __q = __v; !_Traits::eq (*__q, _CharT ()); ++__q)
if (_Traits::eq (*__p, *__q))
return __p - __s;
}
return __p - __s;
}
static _RWSTD_C::size_t find_first_not_of (const _CharT* __s, const _CharT* __v) {
bool __found;
const _CharT* __p = __s;
for (; !_Traits::eq (*__p, _CharT ()); ++__p) {
__found = false;
for (const _CharT* __q = __v;
!_Traits::eq (*__q, _CharT ()); ++__q){
if (_Traits::eq (*__p, *__q)){
__found = true;
break;
}
}
if (!__found)
return __p - __s;
}
return __p-__s;
}
};
_RWSTD_SPECIALIZED_CLASS
struct rw_traits<char, _STD::char_traits<char> >
{
static const char* find (const char* __s, const char* __v) {
return _RWSTD_C::strstr (__s, __v);
}
static const char* rfind (const char* __s, char __v, _RWSTD_C::size_t __pos) {
const char* __p = __s + __pos;
while (__p >= __s)
{
if (_STD::char_traits<char>::eq (*__p, __v))
return __p;
__p--;
}
return 0;
}
static _RWSTD_C::size_t find_first_of (const char* __s, const char* __v) {
return _RWSTD_C::strcspn (__s, __v);
}
static _RWSTD_C::size_t find_first_not_of (const char* __s, const char* __v) {
return _RWSTD_C::strspn (__s, __v);
}
};
#if !defined(_RWSTD_NO_WCSCHR) && !defined(_RWSTD_NO_WCSSPN) && !defined(_RWSTD_NO_WCSSPN) && !defined(_RWSTD_NO_WCHAR_T)
_RWSTD_SPECIALIZED_CLASS
struct rw_traits<wchar_t, _STD::char_traits<wchar_t> >
{
static const wchar_t* find (const wchar_t* __s, const wchar_t* __v) {
#ifndef _RWSTD_NO_WCSSTR
return _RWSTD_C::wcsstr (__s, __v);
#elif defined (__hpux)
return wcswcs (__s, __v);
#else
_RWSTD_C::size_t __len1 = _STD::char_traits<wchar_t>::length (__s);
_RWSTD_C::size_t __len2 = _STD::char_traits<wchar_t>::length (__v);
for (const wchar_t *__p = __s; (__p = _RWSTD_C::wcschr (__p, *__v));) {
_RWSTD_C::size_t __off = __p - __s;
if (__len1 - __off < __len2)
break;
if (0 == _RWSTD_C::memcmp (__p, __v, sizeof *__v * __len2))
return __p;
++__p;
}
return 0;
#endif // _RWSTD_NO_WCSSTR
}
static const wchar_t* rfind (const wchar_t* __s, wchar_t __v,
_RWSTD_C::size_t __pos) {
const wchar_t* __p = __s + __pos;
while (__p >= __s) {
if (_STD::char_traits<wchar_t>::eq (*__p, __v))
return __p;
__p--;
}
return 0;
}
static _RWSTD_C::size_t find_first_of (const wchar_t* __s, const wchar_t* __v) {
return _RWSTD_C::wcscspn (__s, __v);
}
static _RWSTD_C::size_t find_first_not_of (const wchar_t* __s, const wchar_t* __v) {
return _RWSTD_C::wcsspn (__s, __v);
}
};
#endif /* !defined(_RWSTD_NO_WCSCHR) && !defined(_RWSTD_NO_WCSSPN) && !defined(_RWSTD_NO_WCSSPN) */
_RWSTD_NAMESPACE_END // __rw
#endif // _RWSTD_TRAITS_H_INCLUDED
Reference in new issue View Git Blame Copy Permalink