Subversion Repositories Kolibri OS

// -*- C++ -*- header wrapper.

// Copyright (C) 1997-1999, 2000 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 2, 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.

// You should have received a copy of the GNU General Public License along

// with this library; see the file COPYING.  If not, write to the Free

// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,

// USA.

// As a special exception, you may use this file as part of a free software

// library without restriction.  Specifically, if other files instantiate

// templates or use macros or inline functions from this file, or you compile

// this file and link it with other files to produce an executable, this

// file does not by itself cause the resulting executable to be covered by

// the GNU General Public License.  This exception does not however

// invalidate any other reasons why the executable file might be covered by

// the GNU General Public License.

//

// ISO C++ 14882: 20.4.6  C library

//

#ifndef _CPP_CSTRING

#define _CPP_CSTRING 1

# if defined __GLIBC__ && __GLIBC__ >= 2

// We must not see the optimized string functions GNU libc defines.

#  define __NO_STRING_INLINES

# endif

# include 

namespace _C_legacy {

  extern "C" {

#     define _IN_C_LEGACY_

#     pragma GCC system_header

#     include_next 

  }

  // We do inline captures of most of these in case they

  // have been optimized with macros.

  inline void*

  _CPP_memcpy_capture(void* __s1, void const* __s2, size_t __n)

  { return memcpy(__s1, __s2, __n); }

  inline void*

  _CPP_memmove_capture(void* __s1, void const* __s2, size_t __n)

  { return memmove(__s1, __s2, __n); }

  inline void*

  _CPP_strcpy_capture(char* __s1, char const* __s2)

  { return strcpy(__s1, __s2); }

  inline char*

  _CPP_strncpy_capture(char* __s1, char const* __s2, size_t __n)

  { return strncpy(__s1, __s2, __n); }

  inline char*

  _CPP_strcat_capture(char* __s1, char const* __s2)

  { return strcat(__s1, __s2); }

  inline char*

  _CPP_strncat_capture(char* __s1, char const* __s2, size_t __n)

  { return strncat(__s1, __s2, __n); }

  inline int

  _CPP_memcmp_capture(void const* __s1, void const* __s2, size_t __n)

  { return memcmp(__s1, __s2, __n); }

  inline int

  _CPP_strcmp_capture(char const* __s1, char const* __s2)

  { return strcmp(__s1, __s2); }

  inline int

  _CPP_strcoll_capture(char const* __s1, char const* __s2)

  { return strcoll(__s1, __s2); }

  inline int

  _CPP_strncmp_capture(char const* __s1, char const* __s2, size_t __n)

  { return strncmp(__s1, __s2, __n); }

  inline size_t

  _CPP_strxfrm_capture(char* __b, char const* __s, size_t __n)

  { return strxfrm(__b, __s, __n); }

  inline void*

  _CPP_memchr_capture(void const* __s1, int __c, size_t __n)

  { return memchr(__s1, __c, __n); }

  inline char*

  _CPP_strchr_capture(char const* __s1, int __c)

  { return strchr(__s1, __c); }

  inline size_t

  _CPP_strcspn_capture(char const* __s1, char const* __s2)

  { return strcspn(__s1, __s2); }

  inline char*

  _CPP_strpbrk_capture(char const* __s1, char const* __s2)

  { return strpbrk(__s1, __s2); }

  inline char*

  _CPP_strrchr_capture(char const* __s1, int __c)

  { return strrchr(__s1, __c); }

  inline size_t

  _CPP_strspn_capture(char const* __s1, char const* __s2)

  { return strspn(__s1, __s2); }

  inline char*

  _CPP_strstr_capture(char const* __s1, char const* __s2)

  { return strstr(__s1, __s2); }

  inline char*

  _CPP_strtok_capture(char* __s1, char const* __s2)

  { return strtok(__s1, __s2); }

  inline void*

  _CPP_memset_capture(void* __s, int __c, size_t __n)

  { return memset(__s, __c, __n); }

  // inline char*

  // _CPP_strerror_capture(int __num)

  // { return strerror(__num); }

  inline size_t

  _CPP_strlen_capture(char const* __s)

  { return strlen(__s); }

} // namespace _C_legacy

# undef memcpy

# undef memmove

# undef strcpy

# undef strncpy

# undef strcat

# undef strncat

# undef memcmp

# undef strcmp

# undef strcoll

# undef strncmp

# undef strxfrm

# undef memchr

# undef strchr

# undef strcspn

# undef strpbrk

# undef strrchr

# undef strspn

# undef strstr

# undef strtok

# undef memset

# undef strerror

# undef strlen

namespace std {

  // Redefine most of these inline.  Note that the

  // C++ definition differs from C in some cases.

  inline void*

  memcpy(void* __s1, void const* __s2, size_t __n)

  { return _C_legacy::_CPP_memcpy_capture(__s1, __s2, __n); }

  inline void*

  memmove(void* __s1, void const* __s2, size_t __n)

  { return _C_legacy::_CPP_memmove_capture(__s1, __s2, __n); }

  inline void*

  strcpy(char* __s1, char const* __s2)

  { return _C_legacy::_CPP_strcpy_capture(__s1, __s2); }

  inline char*

  strncpy(char* __s1, char const* __s2, size_t __n)

  { return _C_legacy::_CPP_strncpy_capture(__s1, __s2, __n); }

  inline char*

  strcat(char* __s1, char const* __s2)

  { return _C_legacy::_CPP_strcat_capture(__s1, __s2); }

  inline char*

  strncat(char* __s1, char const* __s2, size_t __n)

  { return _C_legacy::_CPP_strncat_capture(__s1, __s2, __n); }

  inline int

  memcmp(void const* __s1, void const* __s2, size_t __n)

  { return _C_legacy::_CPP_memcmp_capture(__s1, __s2, __n); }

  inline int

  strcmp(char const* __s1, char const* __s2)

  { return _C_legacy::_CPP_strcmp_capture(__s1, __s2); }

  inline int

  strcoll(char const* __s1, char const* __s2)

  { return _C_legacy::_CPP_strcoll_capture(__s1, __s2); }

  inline int

  strncmp(char const* __s1, char const* __s2, size_t __n)

  { return _C_legacy::_CPP_strncmp_capture(__s1, __s2, __n); }

  inline size_t

  strxfrm(char* __b, char const* __s, size_t __n)

  { return _C_legacy::_CPP_strxfrm_capture(__b, __s, __n); }

  inline void

  const* memchr(void const* __s1, int __c, size_t __n)

  { return _C_legacy::_CPP_memchr_capture(__s1, __c, __n); }

  inline void*

  memchr(void* __s1, int __c, size_t __n)

  { return _C_legacy::_CPP_memchr_capture(__s1, __c, __n); }

  inline char const*

  strchr(char const* __s1, int __c)

  { return _C_legacy::_CPP_strchr_capture(__s1, __c); }

  inline char*

  strchr(char* __s1, int __c)

  { return _C_legacy::_CPP_strchr_capture(__s1, __c); }

  inline size_t

  strcspn(char const* __s1, char const* __s2)

  { return _C_legacy::_CPP_strcspn_capture(__s1, __s2); }

  inline char const*

  strpbrk(char const* __s1, char const* __s2)

  { return _C_legacy::_CPP_strpbrk_capture(__s1, __s2); }

  inline char*

  strpbrk(char* __s1, char const* __s2)

  { return _C_legacy::_CPP_strpbrk_capture(__s1, __s2); }

  inline char const*

  strrchr(char const* __s1, int __c)

  { return _C_legacy::_CPP_strrchr_capture(__s1, __c); }

  inline char*

  strrchr(char* __s1, int __c)

  { return _C_legacy::_CPP_strrchr_capture(__s1, __c); }

  inline size_t

  strspn(char const* __s1, char const* __s2)

  { return _C_legacy::_CPP_strspn_capture(__s1, __s2); }

  inline char const*

  strstr(char const* __s1, char const* __s2)

  { return _C_legacy::_CPP_strstr_capture(__s1, __s2); }

  inline char*

  strstr(char* __s1, char const* __s2)

  { return _C_legacy::_CPP_strstr_capture(__s1, __s2); }

  inline char*

  strtok(char* __s1, char const* __s2)

  { return _C_legacy::_CPP_strtok_capture(__s1, __s2); }

  inline void*

  memset(void* __s, int __c, size_t __n)

  { return _C_legacy::_CPP_memset_capture(__s, __c, __n); }

  using _C_legacy::strerror;

  inline size_t

  strlen(char const* __s)

  { return _C_legacy::_CPP_strlen_capture(__s); }

} // namespace std

# undef _IN_C_LEGACY_

#endif