File Manager

Hackfut Security File Manager

Current Path: /usr/include/c++/4.4.4/bits

📁 ..
📄 algorithmfwd.h(20.26 KB)
📄 allocator.h(5.07 KB)
📄 atomic_0.h(13.64 KB)
📄 atomic_2.h(12.48 KB)
📄 atomicfwd_c.h(4.64 KB)
📄 atomicfwd_cxx.h(2.85 KB)
📄 basic_ios.h(14.6 KB)
📄 basic_ios.tcc(5.9 KB)
📄 basic_string.h(97.38 KB)
📄 basic_string.tcc(38.41 KB)
📄 boost_concept_check.h(26.38 KB)
📄 char_traits.h(16.03 KB)
📄 cmath.tcc(1.61 KB)
📄 codecvt.h(16.12 KB)
📄 concept_check.h(3.24 KB)
📄 cpp_type_traits.h(9.44 KB)
📄 deque.tcc(26.29 KB)
📄 forward_list.h(43.7 KB)
📄 forward_list.tcc(15.44 KB)
📄 fstream.tcc(26.6 KB)
📄 functexcept.h(2.67 KB)
📄 functional_hash.h(2 KB)
📄 gslice.h(5.32 KB)
📄 gslice_array.h(7.54 KB)
📄 hashtable.h(1.83 KB)
📄 indirect_array.h(7.63 KB)
📄 ios_base.h(27.54 KB)
📄 istream.tcc(28.77 KB)
📄 list.tcc(11.01 KB)
📄 locale_classes.h(23 KB)
📄 locale_classes.tcc(7.12 KB)
📄 locale_facets.h(88.42 KB)
📄 locale_facets.tcc(37.85 KB)
📄 locale_facets_nonio.h(63.95 KB)
📄 locale_facets_nonio.tcc(40.15 KB)
📄 localefwd.h(4.94 KB)
📄 mask_array.h(7.37 KB)
📄 move.h(2.64 KB)
📄 ostream.tcc(12.15 KB)
📄 ostream_insert.h(3.86 KB)
📄 postypes.h(8.01 KB)
📄 shared_ptr.h(47.51 KB)
📄 slice_array.h(9.07 KB)
📄 sstream.tcc(8.84 KB)
📄 stl_algo.h(203 KB)
📄 stl_algobase.h(39.03 KB)
📄 stl_bvector.h(25.58 KB)
📄 stl_construct.h(4.84 KB)
📄 stl_deque.h(59.5 KB)
📄 stl_function.h(21.74 KB)
📄 stl_heap.h(19.59 KB)
📄 stl_iterator.h(32.24 KB)
📄 stl_iterator_base_funcs.h(6.65 KB)
📄 stl_iterator_base_types.h(6.33 KB)
📄 stl_list.h(48.04 KB)
📄 stl_map.h(30.72 KB)
📄 stl_multimap.h(28.77 KB)
📄 stl_multiset.h(24.12 KB)
📄 stl_numeric.h(12.96 KB)
📄 stl_pair.h(8.23 KB)
📄 stl_queue.h(18.34 KB)
📄 stl_raw_storage_iter.h(3.31 KB)
📄 stl_relops.h(4.38 KB)
📄 stl_set.h(24.3 KB)
📄 stl_stack.h(9.51 KB)
📄 stl_tempbuf.h(6.34 KB)
📄 stl_tree.h(42.62 KB)
📄 stl_uninitialized.h(14.76 KB)
📄 stl_vector.h(41.33 KB)
📄 stream_iterator.h(6.27 KB)
📄 streambuf.tcc(4.81 KB)
📄 streambuf_iterator.h(11.89 KB)
📄 stringfwd.h(2.15 KB)
📄 unique_ptr.h(12.41 KB)
📄 valarray_after.h(22.02 KB)
📄 valarray_array.h(21.23 KB)
📄 valarray_array.tcc(7.02 KB)
📄 valarray_before.h(17.78 KB)
📄 vector.tcc(20.63 KB)

Editing: locale_classes.tcc

// Locale support -*- C++ -*-

// Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// <http://www.gnu.org/licenses/>.

/** @file locale_classes.tcc
 *  This is an internal header file, included by other library headers.
 *  You should not attempt to use it directly.
 */

//
// ISO C++ 14882: 22.1  Locales
//

#ifndef _LOCALE_CLASSES_TCC
#define _LOCALE_CLASSES_TCC 1

#pragma GCC system_header

_GLIBCXX_BEGIN_NAMESPACE(std)

template<typename _Facet>
    locale::
    locale(const locale& __other, _Facet* __f)
    {
      _M_impl = new _Impl(*__other._M_impl, 1);

__try
	{ _M_impl->_M_install_facet(&_Facet::id, __f); }
      __catch(...)
	{
	  _M_impl->_M_remove_reference();
	  __throw_exception_again;
	}
      delete [] _M_impl->_M_names[0];
      _M_impl->_M_names[0] = 0;   // Unnamed.
    }

template<typename _Facet>
    locale
    locale::
    combine(const locale& __other) const
    {
      _Impl* __tmp = new _Impl(*_M_impl, 1);
      __try
	{
	  __tmp->_M_replace_facet(__other._M_impl, &_Facet::id);
	}
      __catch(...)
	{
	  __tmp->_M_remove_reference();
	  __throw_exception_again;
	}
      return locale(__tmp);
    }

template<typename _CharT, typename _Traits, typename _Alloc>
    bool
    locale::
    operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1,
	       const basic_string<_CharT, _Traits, _Alloc>& __s2) const
    {
      typedef std::collate<_CharT> __collate_type;
      const __collate_type& __collate = use_facet<__collate_type>(*this);
      return (__collate.compare(__s1.data(), __s1.data() + __s1.length(),
				__s2.data(), __s2.data() + __s2.length()) < 0);
    }

template<typename _Facet>
    bool
    has_facet(const locale& __loc) throw()
    {
      const size_t __i = _Facet::id._M_id();
      const locale::facet** __facets = __loc._M_impl->_M_facets;
      return (__i < __loc._M_impl->_M_facets_size
#ifdef __GXX_RTTI
	      && dynamic_cast<const _Facet*>(__facets[__i]));
#else
              && static_cast<const _Facet*>(__facets[__i]));
#endif
    }

template<typename _Facet>
    const _Facet&
    use_facet(const locale& __loc)
    {
      const size_t __i = _Facet::id._M_id();
      const locale::facet** __facets = __loc._M_impl->_M_facets;
      if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i])
        __throw_bad_cast();
#ifdef __GXX_RTTI
      return dynamic_cast<const _Facet&>(*__facets[__i]);
#else
      return static_cast<const _Facet&>(*__facets[__i]);
#endif
    }

// Generic version does nothing.
  template<typename _CharT>
    int
    collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const
    { return 0; }

// Generic version does nothing.
  template<typename _CharT>
    size_t
    collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const
    { return 0; }

template<typename _CharT>
    int
    collate<_CharT>::
    do_compare(const _CharT* __lo1, const _CharT* __hi1,
	       const _CharT* __lo2, const _CharT* __hi2) const
    {
      // strcoll assumes zero-terminated strings so we make a copy
      // and then put a zero at the end.
      const string_type __one(__lo1, __hi1);
      const string_type __two(__lo2, __hi2);

const _CharT* __p = __one.c_str();
      const _CharT* __pend = __one.data() + __one.length();
      const _CharT* __q = __two.c_str();
      const _CharT* __qend = __two.data() + __two.length();

// strcoll stops when it sees a nul character so we break
      // the strings into zero-terminated substrings and pass those
      // to strcoll.
      for (;;)
	{
	  const int __res = _M_compare(__p, __q);
	  if (__res)
	    return __res;

__p += char_traits<_CharT>::length(__p);
	  __q += char_traits<_CharT>::length(__q);
	  if (__p == __pend && __q == __qend)
	    return 0;
	  else if (__p == __pend)
	    return -1;
	  else if (__q == __qend)
	    return 1;

__p++;
	  __q++;
	}
    }

template<typename _CharT>
    typename collate<_CharT>::string_type
    collate<_CharT>::
    do_transform(const _CharT* __lo, const _CharT* __hi) const
    {
      string_type __ret;

// strxfrm assumes zero-terminated strings so we make a copy
      const string_type __str(__lo, __hi);

const _CharT* __p = __str.c_str();
      const _CharT* __pend = __str.data() + __str.length();

size_t __len = (__hi - __lo) * 2;

_CharT* __c = new _CharT[__len];

__try
	{
	  // strxfrm stops when it sees a nul character so we break
	  // the string into zero-terminated substrings and pass those
	  // to strxfrm.
	  for (;;)
	    {
	      // First try a buffer perhaps big enough.
	      size_t __res = _M_transform(__c, __p, __len);
	      // If the buffer was not large enough, try again with the
	      // correct size.
	      if (__res >= __len)
		{
		  __len = __res + 1;
		  delete [] __c, __c = 0;
		  __c = new _CharT[__len];
		  __res = _M_transform(__c, __p, __len);
		}

__ret.append(__c, __res);
	      __p += char_traits<_CharT>::length(__p);
	      if (__p == __pend)
		break;

__p++;
	      __ret.push_back(_CharT());
	    }
	}
      __catch(...)
	{
	  delete [] __c;
	  __throw_exception_again;
	}

delete [] __c;

return __ret;
    }

template<typename _CharT>
    long
    collate<_CharT>::
    do_hash(const _CharT* __lo, const _CharT* __hi) const
    {
      unsigned long __val = 0;
      for (; __lo < __hi; ++__lo)
	__val =
	  *__lo + ((__val << 7)
		   | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>::
				__digits - 7)));
      return static_cast<long>(__val);
    }

// Inhibit implicit instantiations for required instantiations,
  // which are defined via explicit instantiations elsewhere.
  // NB: This syntax is a GNU extension.
#if _GLIBCXX_EXTERN_TEMPLATE
  extern template class collate<char>;
  extern template class collate_byname<char>;

extern template
    const collate<char>&
    use_facet<collate<char> >(const locale&);

extern template
    bool
    has_facet<collate<char> >(const locale&);

#ifdef _GLIBCXX_USE_WCHAR_T
  extern template class collate<wchar_t>;
  extern template class collate_byname<wchar_t>;

extern template
    const collate<wchar_t>&
    use_facet<collate<wchar_t> >(const locale&);

extern template
    bool
    has_facet<collate<wchar_t> >(const locale&);
#endif
#endif

_GLIBCXX_END_NAMESPACE

#endif

Hackfut Security File Manager

Editing: locale_classes.tcc

Upload File

Create Folder