|
111
|
1 // { dg-do compile }
|
|
131
|
2 // { dg-additional-options "-Wno-return-type" }
|
|
111
|
3
|
|
|
4 namespace std __attribute__ ((__visibility__ ("default"))) {
|
|
|
5 template<typename _Iterator> struct iterator_traits {
|
|
|
6 };
|
|
|
7 template<typename _Tp> struct iterator_traits<_Tp*> {
|
|
|
8 typedef _Tp& reference;
|
|
|
9 };
|
|
|
10 }
|
|
|
11 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
|
|
|
12 using std::iterator_traits;
|
|
|
13 template<typename _Iterator, typename _Container> class __normal_iterator {
|
|
|
14 _Iterator _M_current;
|
|
|
15 typedef iterator_traits<_Iterator> __traits_type;
|
|
|
16 public:
|
|
|
17 typedef typename __traits_type::reference reference;
|
|
|
18 explicit __normal_iterator(const _Iterator& __i) : _M_current(__i) {
|
|
|
19 }
|
|
|
20 reference operator*() const {
|
|
|
21 return *_M_current;
|
|
|
22 }
|
|
|
23 __normal_iterator operator++(int) {
|
|
|
24 return __normal_iterator(_M_current++);
|
|
|
25 }
|
|
|
26 };
|
|
|
27 template<typename _Tp> class new_allocator {
|
|
|
28 public:
|
|
|
29 typedef _Tp* pointer;
|
|
|
30 template<typename _Tp1> struct rebind {
|
|
|
31 typedef new_allocator<_Tp1> other;
|
|
|
32 };
|
|
|
33 };
|
|
|
34 }
|
|
|
35 namespace std __attribute__ ((__visibility__ ("default"))) {
|
|
|
36 template<typename _Tp> class allocator: public __gnu_cxx::new_allocator<_Tp> {
|
|
|
37 };
|
|
|
38 }
|
|
|
39 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
|
|
|
40 template<typename _Alloc> struct __alloc_traits {
|
|
|
41 typedef typename _Alloc::pointer pointer;
|
|
|
42 template<typename _Tp> struct rebind {
|
|
|
43 typedef typename _Alloc::template rebind<_Tp>::other other;
|
|
|
44 };
|
|
|
45 };
|
|
|
46 }
|
|
|
47 namespace std __attribute__ ((__visibility__ ("default"))) {
|
|
|
48 template<typename _Tp, typename _Alloc> struct _Vector_base {
|
|
|
49 typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Tp>::other _Tp_alloc_type;
|
|
|
50 typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer pointer;
|
|
|
51 struct _Vector_impl : public _Tp_alloc_type {
|
|
|
52 pointer _M_start;
|
|
|
53 };
|
|
|
54 _Vector_impl _M_impl;
|
|
|
55 };
|
|
|
56 template<typename _Tp, typename _Alloc = std::allocator<_Tp> > class vector : protected _Vector_base<_Tp, _Alloc> {
|
|
|
57 typedef _Vector_base<_Tp, _Alloc> _Base;
|
|
|
58 public:
|
|
|
59 typedef typename _Base::pointer pointer;
|
|
|
60 typedef __gnu_cxx::__normal_iterator<pointer, vector> iterator;
|
|
|
61 iterator begin() {
|
|
|
62 return iterator(this->_M_impl._M_start);
|
|
|
63 }
|
|
|
64 };
|
|
|
65 }
|
|
|
66 class myServer {
|
|
|
67 static std::vector<myServer *> server_list;
|
|
|
68 class Callback;
|
|
|
69 class myFolder *currentFolder;
|
|
|
70 static bool eventloop(Callback *);
|
|
|
71 };
|
|
|
72 extern "C" {
|
|
|
73 typedef unsigned int uint32_t;
|
|
|
74 typedef uint32_t unicode_char;
|
|
|
75 extern int strcmp (__const char *__s1, __const char *__s2) throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2)));
|
|
|
76 };
|
|
|
77 class CursesObj {
|
|
|
78 };
|
|
|
79 class Curses : public CursesObj {
|
|
|
80 public:
|
|
|
81 class Key {
|
|
|
82 public:
|
|
|
83 unicode_char ukey;
|
|
|
84 const char *keycode;
|
|
|
85 Key(unicode_char ch) : ukey(ch), keycode(0) {
|
|
|
86 }
|
|
|
87 bool plain() const {
|
|
|
88 }
|
|
|
89 bool nokey() const {
|
|
|
90 }
|
|
|
91 bool operator==(const Key &k) const {
|
|
|
92 return strcmp(keycode ? keycode:
|
|
|
93 "", k.keycode ? k.keycode:
|
|
|
94 "") == 0 && ukey == k.ukey;
|
|
|
95 }
|
|
|
96 };
|
|
|
97 static bool processKey(const Key &k);
|
|
|
98 };
|
|
|
99 class CursesContainer : public Curses {
|
|
|
100 };
|
|
|
101 class myFolder {
|
|
|
102 public:
|
|
|
103 void checkExpunged();
|
|
|
104 };
|
|
|
105 class Typeahead {
|
|
|
106 public:
|
|
|
107 static Typeahead *typeahead;
|
|
|
108 bool empty() {
|
|
|
109 }
|
|
|
110 Curses::Key pop() {
|
|
|
111 }
|
|
|
112 };
|
|
|
113 class CursesScreen : public CursesContainer {
|
|
|
114 public:
|
|
|
115 Key getKey();
|
|
|
116 };
|
|
|
117 using namespace std;
|
|
|
118 extern CursesScreen *cursesScreen;
|
|
|
119 bool myServer::eventloop(myServer::Callback *callback) {
|
|
|
120 Curses::Key k1= (callback == __null && !Typeahead::typeahead->empty() ? Typeahead::typeahead->pop() : cursesScreen->getKey());
|
|
|
121 if (callback == __null || (k1.plain() && k1.ukey == '\x03')) {
|
|
|
122 if (!k1.nokey()) {
|
|
|
123 bool rc=Curses::processKey(k1);
|
|
|
124 if (rc) { while (k1.plain() && k1 == '\x03' && !Typeahead::typeahead->empty()) Typeahead::typeahead->pop(); }
|
|
|
125 }
|
|
|
126 }
|
|
|
127 vector<myServer *>::iterator b=server_list.begin();
|
|
|
128 while (1) {
|
|
|
129 myServer *p= *b++;
|
|
|
130 if (p->currentFolder) p->currentFolder->checkExpunged();
|
|
|
131 }
|
|
|
132 }
|
