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