bfin-boost-sync-fetch/A

   1           namespace std {
   2         extern "C" {
   3       typedef struct {
   4     }
   5       pthread_mutexattr_t;
   6       }
   7         template<class _CharT> struct char_traits;
   8         template<typename _StateT> class fpos {
   9       };
  10         template<typename _Iterator, typename _Container> class __normal_iterator {
  11       };
  12         template<typename _Tp> inline const _Tp& min(const _Tp& __a, const _Tp& __b) {
  13       }
  14         }
  15           extern "C++" {
  16         namespace std {
  17       class exception {
  18     };
  19       }
  20         }
  21           namespace __gnu_cxx {
  22         template<typename _Tp> class new_allocator {
  23       public:
  24       typedef _Tp& reference;
  25       template<typename _Tp1> struct rebind {
  26     typedef new_allocator<_Tp1> other;
  27     };
  28       };
  29         }
  30           namespace std {
  31         template<typename _Tp> class allocator: public __gnu_cxx::new_allocator<_Tp> {
  32       };
  33         template<typename _Tp, typename _Alloc> struct _Vector_base {
  34       typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
  35       };
  36         template<typename _Tp, typename _Alloc = std::allocator<_Tp> > class vector : protected _Vector_base<_Tp, _Alloc> {
  37         typedef _Vector_base<_Tp, _Alloc> _Base;
  38       typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
  39       public: typedef _Tp value_type;
  40       typedef typename _Tp_alloc_type::reference reference;
  41       long unsigned int size() const {
  42     }
  43       reference operator[](long unsigned int __n) {
  44     }
  45       };
  46         }
  47           namespace std {
  48         template<typename _CharT, typename _Traits, typename _Alloc> class basic_string {
  49       };
  50         }
  51             namespace std {
  52         class locale {
  53       };
  54         enum _Ios_Fmtflags {
  55       _S_boolalpha = 1L << 0, _S_dec = 1L << 1, _S_fixed = 1L << 2, _S_hex = 1L << 3, _S_internal = 1L << 4, _S_left = 1L << 5, _S_oct = 1L << 6, _S_right = 1L << 7, _S_scientific = 1L << 8, _S_showbase = 1L << 9, _S_showpoint = 1L << 10, _S_showpos = 1L << 11, _S_skipws = 1L << 12, _S_unitbuf = 1L << 13, _S_uppercase = 1L << 14, _S_adjustfield = _S_left | _S_right | _S_internal, _S_basefield = _S_dec | _S_oct | _S_hex, _S_floatfield = _S_scientific | _S_fixed, _S_ios_fmtflags_end = 1L << 16 };
  56         enum _Ios_Openmode {
  57       _S_beg = 0, _S_cur = 1, _S_end = 2, _S_ios_seekdir_end = 1L << 16 };
  58         class ios_base {
  59       public: class failure : public exception {
  60     };
  61       typedef _Ios_Fmtflags fmtflags;
  62       static const fmtflags internal = _S_internal;
  63       inline fmtflags flags() const {
  64     }
  65       inline long int width() const {
  66     }
  67       };
  68         template<typename _CharT, typename _Traits> class basic_streambuf {
  69       };
  70         }
  71            extern "C++" {
  72         namespace __cxxabiv1 {
  73       class type_info {
  74     bool operator==(const type_info& __arg) const {
  75     }
  76     };
  77       }
  78         }
  79           namespace boost {
  80         namespace io {
  81       namespace detail {
  82     typedef ::std:: locale locale_t;
  83     }
  84       }
  85         }
  86              namespace std {
  87         template<typename _CharT, typename _Traits> class basic_ios : public ios_base {
  88       };
  89         template<typename _CharT, typename _Traits> class basic_ostream : virtual public basic_ios<_CharT, _Traits> {
  90       public: typedef _CharT char_type;
  91       typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
  92       explicit basic_ostream(__streambuf_type* __sb) {
  93     }
  94       };
  95         }
  96           namespace boost {
  97         namespace io {
  98       }
  99         template <class Ch, class Tr = ::std:: char_traits<Ch>, class Alloc = std::allocator<Ch> > class basic_format;
 100         typedef basic_format<char > format;
 101         namespace io {
 102       enum format_error_bits {
 103     bad_format_string_bit = 1, too_few_args_bit = 2, too_many_args_bit = 4, out_of_range_bit = 8, all_error_bits = 255, no_error_bits=0 };
 104       namespace detail {
 105     template<class Ch, class Tr, class Alloc, class T> basic_format<Ch, Tr, Alloc>& feed (basic_format<Ch,Tr, Alloc>& self, T x);
 106     }
 107       }
 108         }
 109           namespace mpl_ {
 110         }
 111           namespace boost {
 112         namespace mpl {
 113       using namespace mpl_;
 114       }
 115        }
 116           namespace mpl_ {
 117         template< typename T, T N > struct integral_c {
 118       static const T value = N;
 119       };
 120         }
 121           namespace boost{
 122         template <class T, T val> struct integral_constant : public mpl::integral_c<T, val> {
 123       typedef integral_constant<bool,false> type;
 124       };
 125         namespace detail {
 126       }
 127         }
 128           namespace mpl_ {
 129         struct na {
 130       };
 131         }
 132           namespace boost {
 133         namespace mpl {
 134       template< bool C , typename T1 , typename T2 > struct if_c {
 135     typedef T2 type;
 136     };
 137       template< typename T1 = na , typename T2 = na , typename T3 = na > struct if_ {
 138     private: typedef if_c< static_cast<bool>(T1::value) , T2 , T3 > almost_type_;
 139     public: typedef typename almost_type_::type type;
 140      };
 141       }
 142         template< typename T > struct is_reference : ::boost::integral_constant<bool,false> {
 143       };
 144         namespace detail {
 145       template <bool found, long unsigned int target, class TestType> struct lower_alignment_helper {
 146    };
 147       }
 148         namespace optional_detail {
 149       template <class T> class aligned_storage {
 150     }
 151       ;
 152       template<class T> struct types_when_isnt_ref {
 153     typedef T * pointer_type ;
 154     }
 155       ;
 156       template<class T> struct types_when_is_ref {
 157     }
 158       ;
 159       struct optional_tag {
 160    }
 161       ;
 162       template<class T> class optional_base : public optional_tag {
 163     typedef types_when_isnt_ref<T> types_when_not_ref ;
 164     typedef types_when_is_ref<T> types_when_ref ;
 165     typedef typename is_reference<T>::type is_reference_predicate ;
 166     typedef typename mpl::if_<is_reference_predicate,types_when_ref,types_when_not_ref>::type types ;
 167     typedef typename types::pointer_type pointer_type ;
 168     }
 169       ;
 170       }
 171         template<class T> class optional : public optional_detail::optional_base<T> {
 172       typedef optional_detail::optional_base<T> base ;
 173       public : typedef optional<T> this_type ;
 174       typedef typename base::pointer_type pointer_type ;
 175       }
 176         ;
 177         template<class T> inline typename optional<T>::pointer_type get_pointer ( optional<T>& opt ) {
 178       }
 179         template < typename MemberType, int UniqueID = 0 > class base_from_member {
 180       protected: MemberType member;
 181       template < typename T0 , typename T1 > explicit base_from_member( T0 x0 , T1 x1 ) : member( x0 , x1 ) {
 182    }
 183       };
 184         namespace detail {
 185       typedef int sp_int32_t;
 186       inline sp_int32_t atomic_decrement( sp_int32_t * pw ) {
 187     return __sync_fetch_and_add( pw, -1 );
 188     for( ;
 189    ;
 190     ) {
 191     }
 192     }
 193       class sp_counted_base {
 194     sp_int32_t use_count_;
 195     sp_int32_t weak_count_;
 196     public: sp_counted_base(): use_count_( 1 ), weak_count_( 1 ) {
 197     }
 198     void release() {
 199     if( atomic_decrement( &use_count_ ) == 1 ) {
 200     }
 201     }
 202     };
 203       class shared_count {
 204     private: sp_counted_base * pi_;
 205     public: shared_count(): pi_(0) {
 206     }
 207     template<class P, class D> shared_count(P p, D d): pi_(0) {
 208     if( pi_ != 0 ) pi_->release();
 209     }
 210     shared_count & operator= (shared_count const & r) {
 211     }
 212     };
 213       }
 214         template<class T> class shared_ptr {
 215       public: typedef T element_type;
 216       template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d) {
 217     }
 218       T * px;
 219       boost::detail::shared_count pn;
 220       };
 221         namespace io {
 222       template<class Ch, class Tr, class Alloc> class basic_altstringbuf : public ::std::basic_streambuf<Ch, Tr> {
 223     };
 224       template <class Ch, class Tr, class Alloc> class basic_oaltstringstream : private base_from_member< shared_ptr< basic_altstringbuf< Ch, Tr, Alloc> > >, public ::std::basic_ostream<Ch, Tr> {
 225     class No_Op {
 226     };
 227     typedef ::std::basic_ostream<Ch, Tr> stream_t;
 228     typedef boost::base_from_member<boost::shared_ptr< basic_altstringbuf<Ch,Tr, Alloc> > > pbase_type;
 229     typedef basic_altstringbuf<Ch, Tr, Alloc> stringbuf_t;
 230     public: typedef Alloc allocator_type;
 231     basic_oaltstringstream() : pbase_type(new stringbuf_t), stream_t(rdbuf()) {
 232     }
 233     basic_oaltstringstream(stringbuf_t * buf) : pbase_type(buf, No_Op() ), stream_t(rdbuf()) {
 234     }
 235     stringbuf_t * rdbuf() const {
 236     }
 237     };
 238       namespace detail {
 239     template<class Ch, class Tr> struct stream_format_state {
 240     };
 241     template<class Ch, class Tr, class Alloc> struct format_item {
 242     typedef ::std::basic_string<Ch, Tr, Alloc> string_type;
 243     static long int max_streamsize() {
 244     }
 245     int argN_;
 246     string_type res_;
 247     };
 248     }
 249       }
 250         template<class Ch, class Tr, class Alloc> class basic_format {
 251       public: typedef Ch CharT;
 252       typedef std::basic_string<Ch, Tr, Alloc> string_type;
 253       typedef io::detail::format_item<Ch, Tr, Alloc> format_item_t;
 254       typedef io::basic_altstringbuf<Ch, Tr, Alloc> internal_streambuf_t;
 255       explicit basic_format(const Ch* str=__null);
 256       template<class T> basic_format& operator%(const T& x) {
 257     return io::detail::feed<CharT, Tr, Alloc, const T&>(*this,x);
 258     }
 259       std::vector<format_item_t> items_;
 260       int cur_arg_;
 261       internal_streambuf_t buf_;
 262       boost::optional<io::detail::locale_t> loc_;
 263       };
 264         namespace io {
 265       class format_error : public std::exception {
 266     };
 267       namespace detail {
 268     template< class Ch, class Tr, class Alloc, class T> void put( T x, const format_item<Ch, Tr, Alloc>& specs, typename basic_format<Ch, Tr, Alloc>::string_type& res, typename basic_format<Ch, Tr, Alloc>::internal_streambuf_t & buf, io::detail::locale_t *loc_p = __null) {
 269     basic_oaltstringstream<Ch, Tr, Alloc> oss( &buf);
 270     const std::ios_base::fmtflags fl=oss.flags();
 271     const bool internal = (fl & std::ios_base::internal) != 0;
 272     const long int w = oss.width();
 273     const bool two_stepped_padding= internal && (w!=0);
 274     if(! two_stepped_padding) {
 275     }
 276     }
 277     template< class Ch, class Tr, class Alloc, class T> void distribute (basic_format<Ch,Tr, Alloc>& self, T x) {
 278     for(unsigned long i=0;
 279     i < self.items_.size();
 280     ++i) {
 281     if(self.items_[i].argN_ == self.cur_arg_) {
 282   put<Ch, Tr, Alloc, T> (x, self.items_[i], self.items_[i].res_, self.buf_, boost::get_pointer(self.loc_) );
 283   }
 284     }
 285     }
 286     template<class Ch, class Tr, class Alloc, class T> basic_format<Ch, Tr, Alloc>& feed (basic_format<Ch,Tr, Alloc>& self, T x) {
 287     distribute<Ch, Tr, Alloc, T> (self, x);
 288     }
 289     }
 290       }
 291         }
 292           int main() {
 293         boost::format f("%d\n");
 294         f %-123;
 295         }