Fix PR57140

Index: gcc/testsuite/g++.dg/torture/pr57140.C
===================================================================
--- gcc/testsuite/g++.dg/torture/pr57140.C	(revision 0)
+++ gcc/testsuite/g++.dg/torture/pr57140.C	(working copy)
@@ -0,0 +1,186 @@ 
+// { dg-do compile }
+
+namespace std {
+    typedef long unsigned int size_t;
+    template<typename>     class allocator;
+    template<class _CharT>     struct char_traits;
+    template<typename _CharT, typename _Traits = char_traits<_CharT>,            typename _Alloc = allocator<_CharT> >     class basic_string;
+    typedef basic_string<char> string;
+}
+namespace std __attribute__ ((__visibility__ ("default"))) {
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+    template<typename _Tp>     class new_allocator     {
+    };
+}
+namespace std __attribute__ ((__visibility__ ("default"))) {
+    template<typename _Tp>     class allocator: public __gnu_cxx::new_allocator<_Tp>     {
+    public:
+	template<typename _Tp1>         struct rebind         {
+	    typedef allocator<_Tp1> other;
+	};
+    };
+}
+namespace std {
+}
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
+}
+namespace std __attribute__ ((__visibility__ ("default"))) {
+    template<typename _CharT, typename _Traits, typename _Alloc>     class basic_string     {
+	struct _Alloc_hider : _Alloc       {
+	    _Alloc_hider(_CharT* __dat, const _Alloc& __a)  : _Alloc(__a), _M_p(__dat) {
+	    }
+	    _CharT* _M_p;
+	};
+	mutable _Alloc_hider _M_dataplus;
+    public:
+	basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
+    };
+    template<typename _CharT, typename _Traits, typename _Alloc>     inline bool     operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,         const _CharT* __rhs)     {
+    }
+}
+extern "C" {
+}
+namespace std __attribute__ ((__visibility__ ("default"))) {
+    namespace __detail   {
+	struct _List_node_base     {
+	    _List_node_base* _M_next;
+	};
+    }
+    template<typename _Tp>     struct _List_node : public __detail::_List_node_base     {
+    };
+    template<typename _Tp>     struct _List_iterator     {
+	typedef _List_iterator<_Tp> _Self;
+	typedef _Tp& reference;
+	reference       operator*() const       {
+	}
+	bool       operator!=(const _Self& __x) const       {
+	}
+    };
+    template<typename _Tp, typename _Alloc>     class _List_base     {
+    protected:
+	typedef typename _Alloc::template rebind<_List_node<_Tp> >::other         _Node_alloc_type;
+	struct _List_impl       : public _Node_alloc_type       {
+	    __detail::_List_node_base _M_node;
+	    _List_impl()  : _Node_alloc_type(), _M_node()  {
+	    }
+	    _List_impl(const _Node_alloc_type& __a)  : _Node_alloc_type(__a), _M_node()  {
+	    }
+	};
+	_List_impl _M_impl;
+	~_List_base()       {
+	}
+	void       _M_clear();
+    };
+    template<typename _Tp, typename _Alloc = std::allocator<_Tp> >     class list : protected _List_base<_Tp, _Alloc>     {
+	typedef _List_iterator<_Tp> iterator;
+	typedef size_t size_type;
+    public:
+	iterator       begin()       {
+	}
+	iterator       end()       {
+	}
+	bool       empty() const       {
+	}
+	size_type       size() const       {
+	}
+	void       swap(list& __x)       {
+	}
+	template<typename _StrictWeakOrdering>         void         merge(list& __x, _StrictWeakOrdering __comp);
+	template<typename _StrictWeakOrdering>         void         sort(_StrictWeakOrdering);
+    };
+    template<typename _Tp, typename _Alloc>     template <typename _StrictWeakOrdering>       void       list<_Tp, _Alloc>::       merge(list& __x, _StrictWeakOrdering __comp)       {
+	if (this != &__x)    {
+	    iterator __first1 = begin();
+	    iterator __last1 = end();
+	    iterator __first2 = __x.begin();
+	    iterator __last2 = __x.end();
+	    while (__first1 != __last1 && __first2 != __last2)        if (__comp(*__first2, *__first1))   {
+		iterator __next = __first2;
+		__first2 = __next;
+	    }
+	}
+    }
+    template<typename _Tp, typename _Alloc>     template <typename _StrictWeakOrdering>       void       list<_Tp, _Alloc>::       sort(_StrictWeakOrdering __comp)       {
+	if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node      && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)    {
+	    list __carry;
+	    list __tmp[64];
+	    list * __fill = &__tmp[0];
+	    list * __counter;
+	    do        {
+		for(__counter = &__tmp[0];
+		    __counter != __fill && !__counter->empty();
+		    ++__counter)     {       __counter->merge(__carry, __comp);       __carry.swap(*__counter);     }
+	    }
+	    while ( !empty() );
+	    for (__counter = &__tmp[1];
+		 __counter != __fill;
+		 ++__counter)        __counter->merge(*(__counter - 1), __comp);
+	}
+    }
+}
+namespace gloox {
+    class Tag   {
+    };
+    class StanzaExtension   {
+    };
+}
+namespace gloox {
+}
+using namespace gloox;
+class AbstractPurpleRequest {
+};
+class AdhocCommandHandler : public AbstractPurpleRequest {
+};
+class AdhocTag : public Tag {
+};
+class AbstractConfigInterfaceHandler {
+};
+namespace gloox {
+    class DataFormField   {
+    public:
+	const std::string& value() const {
+	}
+    };
+    class DataFormFieldContainer   {
+    public:
+	bool hasField( const std::string& field ) const         {
+	}
+	DataFormField* field( const std::string& field ) const;
+    };
+    class DataForm : public StanzaExtension, public DataFormFieldContainer   {
+    };
+}
+enum {
+    SORT_BY_JID,  SORT_BY_UIN,  SORT_BY_BUDDIES, };
+struct SortData {
+};
+struct ListData {
+    std::list<SortData> output;
+    int sort_by;
+};
+class AdhocAdmin : public AdhocCommandHandler, public AbstractConfigInterfaceHandler {
+    AdhocTag *handleAdhocTag(Tag *stanzaTag);
+    AdhocTag *handleUnregisterUserForm(Tag *tag, const DataForm &form);
+    AdhocTag *handleListUsersForm(Tag *tag, const DataForm &form);
+    ListData m_listUsersData;
+};
+namespace gloox {
+}
+static bool compareIDataASC(SortData &a, SortData &b) {
+}
+AdhocTag *AdhocAdmin::handleListUsersForm(Tag *tag, const DataForm &form) {
+    ListData &data = m_listUsersData;
+    if (data.output.size() == 0) {
+	if (!form.hasField("users_vip") || !form.hasField("show_jid") || !form.hasField("show_uin")    || !form.hasField("show_buddies") || !form.hasField("show_sort_by") || !form.hasField("show_sort_order")    || !form.hasField("show_max_per_page")   ) {
+	}
+	bool sort_asc = form.field("show_sort_order")->value() == "asc";
+	if (data.sort_by == SORT_BY_BUDDIES) {
+	    if (sort_asc)     data.output.sort(compareIDataASC);
+	}
+	else {
+	}
+    }
+}