gccxml_gem 0.9.3-x86-darwin-10

data/share/gccxml-0.9/GCC/4.5/gccxml_builtins.h

@@ -0,0 +1,154 @@
+#define __builtin_apply(x,y,z) ((void*)0)
+#define __builtin_nan(x) (0.0)
+#define __builtin_nanf(x) (0.0f)
+#define __builtin_nanl(x) (0.0l)
+#define __builtin_huge_val(x) (0.0)
+#define __builtin_huge_valf(x) (0.0f)
+#define __builtin_huge_vall(x) (0.0l)
+#define __builtin_apply_args(x) ((void*)0)
+#define __builtin_types_compatible_p(x,y) 0
+#define __builtin_choose_expr(x,y,z) int
+#define __builtin_constant_p(x) 0
+void* __builtin_memchr(void const*, int, unsigned int);
+void __builtin_return (void *RESULT);
+void * __builtin_return_address (unsigned int LEVEL);
+void * __builtin_frame_address (unsigned int LEVEL);
+long __builtin_expect (long EXP, long C);
+void __builtin_prefetch (const void *ADDR, ...);
+double __builtin_inf (void);
+float __builtin_inff (void);
+long double __builtin_infl (void);
+double __builtin_nans (const char *str);
+float __builtin_nansf (const char *str);
+long double __builtin_nansl (const char *str);
+double      __builtin_acos(double);
+float       __builtin_acosf(float);
+long double __builtin_acosl(long double);
+double      __builtin_asin(double);
+float       __builtin_asinf(float);
+long double __builtin_asinl(long double);
+double      __builtin_atan(double);
+double      __builtin_atan2(double, double);
+float       __builtin_atan2f(float, float);
+long double __builtin_atan2l(long double, long double);
+float       __builtin_atanf(float);
+long double __builtin_atanl(long double);
+double      __builtin_ceil(double);
+float       __builtin_ceilf(float);
+long double __builtin_ceill(long double);
+double      __builtin_cos(double);
+float       __builtin_cosf(float);
+double      __builtin_cosh(double);
+float       __builtin_coshf(float);
+long double __builtin_coshl(long double);
+long double __builtin_cosl(long double);
+double      __builtin_exp(double);
+float       __builtin_expf(float);
+long double __builtin_expl(long double);
+double      __builtin_fabs(double);
+float       __builtin_fabsf(float);
+long double __builtin_fabsl(long double);
+double      __builtin_floor(double);
+float       __builtin_floorf(float);
+long double __builtin_floorl(long double);
+float       __builtin_fmodf(float, float);
+long double __builtin_fmodl(long double, long double);
+double      __builtin_frexp(double, int*);
+float       __builtin_frexpf(float, int*);
+long double __builtin_frexpl(long double, int*);
+double      __builtin_ldexp(double, int);
+float       __builtin_ldexpf(float, int);
+long double __builtin_ldexpl(long double, int);
+double      __builtin_log(double);
+double      __builtin_log10(double);
+float       __builtin_log10f(float);
+long double __builtin_log10l(long double);
+float       __builtin_logf(float);
+long double __builtin_logl(long double);
+float       __builtin_modff(float, float*);
+long double __builtin_modfl(long double, long double*);
+float       __builtin_powf(float, float);
+long double __builtin_powl(long double, long double);
+double      __builtin_powi(double, int);
+float       __builtin_powif(float, int);
+long double __builtin_powil(long double, int);
+double      __builtin_sin(double);
+float       __builtin_sinf(float);
+double      __builtin_sinh(double);
+float       __builtin_sinhf(float);
+long double __builtin_sinhl(long double);
+long double __builtin_sinl(long double);
+double      __builtin_sqrt(double);
+float       __builtin_sqrtf(float);
+long double __builtin_sqrtl(long double);
+double      __builtin_tan(double);
+float       __builtin_tanf(float);
+double      __builtin_tanh(double);
+float       __builtin_tanhf(float);
+long double __builtin_tanhl(long double);
+long double __builtin_tanl(long double);
+float       __builtin_cabsf(float __complex__);
+double      __builtin_cabs(double __complex__);
+long double __builtin_cabsl(long double __complex__);
+float       __builtin_cargf(float __complex__);
+double      __builtin_carg(double __complex__);
+long double __builtin_cargl(long double __complex__);
+int         __builtin_ctz(int);
+int         __builtin_ctzl(long);
+int         __builtin_ctzll(long long);
+int         __builtin_popcount(int);
+int         __builtin_popcountl(long);
+int         __builtin_popcountll(long long);
+float       __complex__ __builtin_ccosf(float __complex__);
+double      __complex__ __builtin_ccos(double __complex__);
+long double __complex__ __builtin_ccosl(long double __complex__);
+float       __complex__ __builtin_ccoshf(float __complex__);
+double      __complex__ __builtin_ccosh(double __complex__);
+long double __complex__ __builtin_ccoshl(long double __complex__);
+float       __complex__ __builtin_cexpf(float __complex__);
+double      __complex__ __builtin_cexp(double __complex__);
+long double __complex__ __builtin_cexpl(long double __complex__);
+float       __complex__ __builtin_clogf(float __complex__);
+double      __complex__ __builtin_clog(double __complex__);
+long double __complex__ __builtin_clogl(long double __complex__);
+float       __complex__ __builtin_csinf(float __complex__);
+double      __complex__ __builtin_csin(double __complex__);
+long double __complex__ __builtin_csinl(long double __complex__);
+float       __complex__ __builtin_csinhf(float __complex__);
+double      __complex__ __builtin_csinh(double __complex__);
+long double __complex__ __builtin_csinhl(long double __complex__);
+float       __complex__ __builtin_csqrtf(float __complex__);
+double      __complex__ __builtin_csqrt(double __complex__);
+long double __complex__ __builtin_csqrtl(long double __complex__);
+float       __complex__ __builtin_ctanf(float __complex__);
+double      __complex__ __builtin_ctan(double __complex__);
+long double __complex__ __builtin_ctanl(long double __complex__);
+float       __complex__ __builtin_ctanhf(float __complex__);
+double      __complex__ __builtin_ctanh(double __complex__);
+long double __complex__ __builtin_ctanhl(long double __complex__);
+float       __complex__ __builtin_cpowf(float __complex__, float __complex__);
+double      __complex__ __builtin_cpow(double __complex__, double __complex__);
+long double __complex__ __builtin_cpowl(long double __complex__, long double __complex__);
+
+/* The GCC 4.5 parser hard-codes handling of these, so they do not
+   have real signatures.  */
+bool __builtin_fpclassify(...);
+bool __builtin_isfinite(...);
+bool __builtin_isgreater(...);
+bool __builtin_isgreaterequal(...);
+bool __builtin_isinf(...);
+bool __builtin_isinf_sign(...);
+bool __builtin_isless(...);
+bool __builtin_islessequal(...);
+bool __builtin_islessgreater(...);
+bool __builtin_isnan(...);
+bool __builtin_isnormal(...);
+bool __builtin_isunordered(...);
+bool __builtin_va_arg_pack(...);
+int  __builtin_va_arg_pack_len(...);
+
+/* We fake some constant expressions from GCC 4.5 parser.  */
+#define __is_pod(x) false
+#define __is_empty(x) false
+#define __has_trivial_destructor(x) false
+#define __has_trivial_constructor(x) false

data/share/gccxml-0.9/GCC/4.5/iomanip

@@ -0,0 +1,349 @@
+// Standard stream manipulators -*- C++ -*-
+
+// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+// 2006, 2007, 2008, 2009, 2010
+// 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 iomanip
+ *  This is a Standard C++ Library header.
+ */
+
+//
+// ISO C++ 14882: 27.6.3  Standard manipulators
+//
+
+#ifndef _GLIBCXX_IOMANIP
+#define _GLIBCXX_IOMANIP 1
+
+#pragma GCC system_header
+
+#include <bits/c++config.h>
+#include <iosfwd>
+#include <bits/ios_base.h>
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+#include <locale>
+#endif
+
+_GLIBCXX_BEGIN_NAMESPACE(std)
+
+  // [27.6.3] standard manipulators
+  // Also see DR 183.
+
+  struct _Resetiosflags { ios_base::fmtflags _M_mask; };
+
+  /**
+   *  @brief  Manipulator for @c setf.
+   *  @param  mask  A format flags mask.
+   *
+   *  Sent to a stream object, this manipulator resets the specified flags,
+   *  via @e stream.setf(0,mask).
+  */
+  inline _Resetiosflags
+  resetiosflags(ios_base::fmtflags __mask)
+    { _Resetiosflags r = { __mask }; return r; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f)
+    {
+      __is.setf(ios_base::fmtflags(0), __f._M_mask);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f)
+    {
+      __os.setf(ios_base::fmtflags(0), __f._M_mask);
+      return __os;
+    }
+
+
+  struct _Setiosflags { ios_base::fmtflags _M_mask; };
+
+  /**
+   *  @brief  Manipulator for @c setf.
+   *  @param  mask  A format flags mask.
+   *
+   *  Sent to a stream object, this manipulator sets the format flags
+   *  to @a mask.
+  */
+  inline _Setiosflags
+  setiosflags(ios_base::fmtflags __mask)
+    { _Setiosflags s = { __mask }; return s; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f)
+    {
+      __is.setf(__f._M_mask);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f)
+    {
+      __os.setf(__f._M_mask);
+      return __os;
+    }
+
+
+  struct _Setbase { int _M_base; };
+
+  /**
+   *  @brief  Manipulator for @c setf.
+   *  @param  base  A numeric base.
+   *
+   *  Sent to a stream object, this manipulator changes the
+   *  @c ios_base::basefield flags to @c oct, @c dec, or @c hex when @a base
+   *  is 8, 10, or 16, accordingly, and to 0 if @a base is any other value.
+  */
+  inline _Setbase
+  setbase(int __base)
+    { _Setbase s = { __base }; return s; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f)
+    {
+      __is.setf(__f._M_base ==  8 ? ios_base::oct :
+		__f._M_base == 10 ? ios_base::dec :
+		__f._M_base == 16 ? ios_base::hex :
+		ios_base::fmtflags(0), ios_base::basefield);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f)
+    {
+      __os.setf(__f._M_base ==  8 ? ios_base::oct :
+		__f._M_base == 10 ? ios_base::dec :
+		__f._M_base == 16 ? ios_base::hex :
+		ios_base::fmtflags(0), ios_base::basefield);
+      return __os;
+    }
+
+
+  template<typename _CharT>
+    struct _Setfill { _CharT _M_c; };
+
+  /**
+   *  @brief  Manipulator for @c fill.
+   *  @param  c  The new fill character.
+   *
+   *  Sent to a stream object, this manipulator calls @c fill(c) for that
+   *  object.
+  */
+  template<typename _CharT>
+    inline _Setfill<_CharT>
+    setfill(_CharT __c)
+    { _Setfill<_CharT> s = { __c }; return s; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f)
+    {
+      __is.fill(__f._M_c);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f)
+    {
+      __os.fill(__f._M_c);
+      return __os;
+    }
+
+
+  struct _Setprecision { int _M_n; };
+
+  /**
+   *  @brief  Manipulator for @c precision.
+   *  @param  n  The new precision.
+   *
+   *  Sent to a stream object, this manipulator calls @c precision(n) for
+   *  that object.
+  */
+  inline _Setprecision
+  setprecision(int __n)
+    { _Setprecision s = { __n }; return s;}
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f)
+    {
+      __is.precision(__f._M_n);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f)
+    {
+      __os.precision(__f._M_n);
+      return __os;
+    }
+
+
+  struct _Setw { int _M_n; };
+
+  /**
+   *  @brief  Manipulator for @c width.
+   *  @param  n  The new width.
+   *
+   *  Sent to a stream object, this manipulator calls @c width(n) for
+   *  that object.
+  */
+  inline _Setw
+  setw(int __n)
+    { _Setw s = {__n} ; return s; }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f)
+    {
+      __is.width(__f._M_n);
+      return __is;
+    }
+
+  template<typename _CharT, typename _Traits>
+    inline basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f)
+    {
+      __os.width(__f._M_n);
+      return __os;
+    }
+
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+
+  template<typename _MoneyT>
+    struct _Get_money { _MoneyT& _M_mon; bool _M_intl; };
+
+  /**
+   *  @brief  Extended manipulator for extracting money.
+   *  @param  mon  Either long double or a specialization of @c basic_string.
+   *  @param  intl A bool indicating whether international format
+   *               is to be used.
+   *
+   *  Sent to a stream object, this manipulator extracts @a mon.
+  */
+  template<typename _MoneyT>
+    inline _Get_money<_MoneyT>
+    get_money(_MoneyT& __mon, bool __intl = false)
+    { return { __mon, __intl }; }
+
+  template<typename _CharT, typename _Traits, typename _MoneyT>
+    basic_istream<_CharT, _Traits>&
+    operator>>(basic_istream<_CharT, _Traits>& __is, _Get_money<_MoneyT> __f)
+    {
+      typedef istreambuf_iterator<_CharT, _Traits> _Iter;
+      typedef money_get<_CharT, _Iter> _MoneyGet;
+
+      ios_base::iostate __err = ios_base::goodbit;
+      const _MoneyGet& __mg = use_facet<_MoneyGet>(__is.getloc());
+
+      __mg.get(_Iter(__is.rdbuf()), _Iter(), __f._M_intl,
+	       __is, __err, __f._M_mon);
+
+      if (ios_base::goodbit != __err)
+	__is.setstate(__err);
+
+      return __is;
+    }
+
+
+  template<typename _MoneyT>
+    struct _Put_money { const _MoneyT& _M_mon; bool _M_intl; };
+
+  /**
+   *  @brief  Extended manipulator for inserting money.
+   *  @param  mon  Either long double or a specialization of @c basic_string.
+   *  @param  intl A bool indicating whether international format
+   *               is to be used.
+   *
+   *  Sent to a stream object, this manipulator inserts @a mon.
+  */
+  template<typename _MoneyT>
+    inline _Put_money<_MoneyT>
+    put_money(const _MoneyT& __mon, bool __intl = false)
+    { return { __mon, __intl }; }
+
+  template<typename _CharT, typename _Traits, typename _MoneyT>
+    basic_ostream<_CharT, _Traits>&
+    operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f)
+    {
+      typedef ostreambuf_iterator<_CharT, _Traits> _Iter;
+      typedef money_put<_CharT, _Iter> _MoneyPut;
+
+      const _MoneyPut& __mp = use_facet<_MoneyPut>(__os.getloc());
+      const _Iter __end = __mp.put(_Iter(__os.rdbuf()), __f._M_intl,
+				   __os, __os.fill(), __f._M_mon);
+
+      if (__end.failed())
+	__os.setstate(ios_base::badbit);
+
+      return __os;
+    }
+
+#endif
+
+  // 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 ostream& operator<<(ostream&, _Setfill<char>);
+  extern template ostream& operator<<(ostream&, _Setiosflags);
+  extern template ostream& operator<<(ostream&, _Resetiosflags);
+  extern template ostream& operator<<(ostream&, _Setbase);
+  extern template ostream& operator<<(ostream&, _Setprecision);
+  extern template ostream& operator<<(ostream&, _Setw);
+  extern template istream& operator>>(istream&, _Setfill<char>);
+  extern template istream& operator>>(istream&, _Setiosflags);
+  extern template istream& operator>>(istream&, _Resetiosflags);
+  extern template istream& operator>>(istream&, _Setbase);
+  extern template istream& operator>>(istream&, _Setprecision);
+  extern template istream& operator>>(istream&, _Setw);
+
+#ifdef _GLIBCXX_USE_WCHAR_T
+  extern template wostream& operator<<(wostream&, _Setfill<wchar_t>);
+  extern template wostream& operator<<(wostream&, _Setiosflags);
+  extern template wostream& operator<<(wostream&, _Resetiosflags);
+  extern template wostream& operator<<(wostream&, _Setbase);
+  extern template wostream& operator<<(wostream&, _Setprecision);
+  extern template wostream& operator<<(wostream&, _Setw);
+  extern template wistream& operator>>(wistream&, _Setfill<wchar_t>);
+  extern template wistream& operator>>(wistream&, _Setiosflags);
+  extern template wistream& operator>>(wistream&, _Resetiosflags);
+  extern template wistream& operator>>(wistream&, _Setbase);
+  extern template wistream& operator>>(wistream&, _Setprecision);
+  extern template wistream& operator>>(wistream&, _Setw);
+#endif
+#endif
+
+_GLIBCXX_END_NAMESPACE
+
+#endif /* _GLIBCXX_IOMANIP */