1// { dg-do compile }
2
3namespace std
4{
5  template < class _Elem > struct char_traits
6  {
7  };
8  struct _Container_base
9  {
10  };
11    template < class _Ty > struct _Allocator_base
12  {
13  };
14    template < class _Ty > class allocator:public _Allocator_base < _Ty >
15  {
16  };
17  class _String_base:public _Container_base
18  {
19  };
20template < class _Ty, class _Alloc > class _String_val:public _String_base
21  {
22  };
23template < class _Elem, class _Traits, class _Ax > class basic_string:public _String_val < _Elem,
24    _Ax
25    >
26  {
27  public:typedef basic_string < _Elem, _Traits, _Ax > _Myt;
28    typedef _String_val < _Elem, _Ax > _Mybase;
29    basic_string (const _Elem * _Ptr):_Mybase ()
30    {
31    }
32  };
33  typedef basic_string < char, char_traits < char >,
34    allocator < char > >string;
35}
36
37
38namespace google
39{
40  namespace protobuf
41  {
42    namespace internal
43    {
44      template < class C > class scoped_ptr
45      {
46      public:typedef C element_type;
47      explicit scoped_ptr (C * p = __null):ptr_ (p)
48	{
49	}
50	 ~scoped_ptr ()
51	{
52	  delete ptr_;
53	}
54	C *get () const
55	{
56	  return ptr_;
57	}
58      private:  C * ptr_;
59      };
60    }
61    using internal::scoped_ptr;
62    enum LogLevel
63    {
64      LOGLEVEL_INFO, LOGLEVEL_WARNING, LOGLEVEL_ERROR, LOGLEVEL_FATAL,
65	LOGLEVEL_DFATAL = LOGLEVEL_ERROR
66    };
67    namespace internal
68    {
69      class LogMessage
70      {
71      public:LogMessage (LogLevel level, const char *filename,
72		    int line);
73	 ~LogMessage ();
74	  LogMessage & operator<< (const std::string & value);
75      };
76      class LogFinisher
77      {
78      public:void operator= (LogMessage & other);
79      };
80    }
81    using namespace std;
82    class Descriptor
83    {
84    };
85    class FieldDescriptor
86    {
87    public:
88      const Descriptor *message_type () const;
89      string DebugString () const;
90    };
91    class MessageLite
92    {
93    };
94    class Message:public MessageLite
95    {
96    public:inline Message ()
97      {
98      }
99      virtual ~ Message ();
100      virtual Message *New () const = 0;
101    };
102    class MessageFactory
103    {
104    };
105    class UnknownFieldSet
106    {
107    };
108    class DynamicMessageFactory:public MessageFactory
109    {
110    public:DynamicMessageFactory ();
111      const Message *GetPrototype (const Descriptor * type);
112    };
113    namespace io
114    {
115      class ErrorCollector
116      {
117      public:inline ErrorCollector ()
118	{
119	}
120	virtual ~ ErrorCollector ();
121      };
122    }
123    class DescriptorBuilder
124    {
125      class OptionInterpreter
126      {
127	bool SetAggregateOption (const FieldDescriptor * option_field,
128				 UnknownFieldSet * unknown_fields);
129	DynamicMessageFactory dynamic_factory_;
130      };
131    };
132    namespace
133    {
134      class AggregateErrorCollector:public io::ErrorCollector
135      {
136      };
137    }
138    bool DescriptorBuilder::OptionInterpreter::
139      SetAggregateOption (const FieldDescriptor * option_field,
140			  UnknownFieldSet * unknown_fields)
141    {
142      const Descriptor *type = option_field->message_type ();
143      scoped_ptr < Message >
144	dynamic (dynamic_factory_.GetPrototype (type)->New ());
145      !(!(dynamic.get () !=
146	  __null)) ? (void) 0 : ::google::protobuf::internal::
147	LogFinisher () =::google::protobuf::internal::LogMessage (::google::
148								  protobuf::
149								  LOGLEVEL_FATAL,
150								  "descriptor.cc",
151								  4396) <<
152	option_field->DebugString ();
153      AggregateErrorCollector collector;
154    }
155  }
156}
157