1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
// Proxy file in order to define generic data types, to avoid binding with system headers
typedef __SIZE_TYPE__ size_t;
namespace std {
typedef size_t size_t;
template <class T>
class vector {
public:
typedef T* iterator;
typedef const T* const_iterator;
typedef T& reference;
typedef const T& const_reference;
typedef size_t size_type;
explicit vector();
explicit vector(size_type n);
void swap(vector &other);
void push_back(const T& val);
template <class... Args> void emplace_back(Args &&... args);
void reserve(size_t n);
void resize(size_t n);
size_t size();
const_reference operator[] (size_type) const;
reference operator[] (size_type);
const_iterator begin() const;
const_iterator end() const;
};
template <typename T>
class basic_string {
public:
typedef basic_string<T> _Type;
basic_string() {}
basic_string(const T *p);
basic_string(const T *p, size_t count);
basic_string(size_t count, char ch);
~basic_string() {}
size_t size() const;
bool empty() const;
size_t find (const char* s, size_t pos = 0) const;
const T *c_str() const;
_Type& assign(const T *s);
basic_string<T> &operator=(T ch);
basic_string<T> *operator+=(const basic_string<T> &) {}
friend basic_string<T> operator+(const basic_string<T> &, const basic_string<T> &) {}
};
typedef basic_string<char> string;
typedef basic_string<wchar_t> wstring;
string to_string(int value);
template <typename T>
struct default_delete {};
template <typename T, typename D = default_delete<T>>
class unique_ptr {
public:
unique_ptr();
~unique_ptr();
explicit unique_ptr(T*);
template <typename U, typename E>
unique_ptr(unique_ptr<U, E>&&);
T* release();
};
template <class Fp, class... Arguments>
class bind_rt {};
template <class Fp, class... Arguments>
bind_rt<Fp, Arguments...> bind(Fp &&, Arguments &&...);
}
typedef unsigned int uid_t;
typedef unsigned int pid_t;
int bcmp(void *, void *, size_t);
void bcopy(void *, void *, size_t);
void bzero(void *, size_t);
int getpw(uid_t uid, char *buf);
int setuid(uid_t uid);
int mkstemp(char *tmpl);
char *mktemp(char *tmpl);
pid_t vfork(void);
int abort() { return 0; }
#define assert(x) \
if (!(x)) \
(void)abort()
size_t strlen(const char *s);
char *strncat(char *s1, const char *s2, size_t);
void free(void *ptr);
void *malloc(size_t size);
void *memset(void *b, int c, size_t len);
|
