system-header-simulator-cxx.h revision be2e1b11e3350e3a6e632c71beaab83aae3824d2 
1// Like the compiler, the static analyzer treats some functions differently if
2// they come from a system header -- for example, it is assumed that system
3// functions do not arbitrarily free() their parameters, and that some bugs
4// found in system headers cannot be fixed by the user and should be
5// suppressed.
6#pragma clang system_header
7
8namespace std {
9  template <class T1, class T2>
10  struct pair {
11    T1 first;
12    T2 second;
13
14    pair() : first(), second() {}
15    pair(const T1 &a, const T2 &b) : first(a), second(b) {}
16
17    template<class U1, class U2>
18    pair(const pair<U1, U2> &other) : first(other.first), second(other.second) {}
19  };
20
21  typedef __typeof__(sizeof(int)) size_t;
22
23  template<typename T>
24  class vector {
25    T *_start;
26    T *_finish;
27    T *_end_of_storage;
28  public:
29    vector() : _start(0), _finish(0), _end_of_storage(0) {}
30    ~vector();
31
32    size_t size() const {
33      return size_t(_finish - _start);
34    }
35
36    void push_back();
37    T pop_back();
38
39    T &operator[](size_t n) {
40      return _start[n];
41    }
42
43    const T &operator[](size_t n) const {
44      return _start[n];
45    }
46
47    T *begin() { return _start; }
48    const T *begin() const { return _start; }
49
50    T *end() { return _finish; }
51    const T *end() const { return _finish; }
52  };
53
54  class exception {
55  public:
56    exception() throw();
57    virtual ~exception() throw();
58    virtual const char *what() const throw() {
59      return 0;
60    }
61  };
62
63  class bad_alloc : public exception {
64    public:
65    bad_alloc() throw();
66    bad_alloc(const bad_alloc&) throw();
67    bad_alloc& operator=(const bad_alloc&) throw();
68    virtual const char* what() const throw() {
69      return 0;
70    }
71  };
72
73  struct nothrow_t {};
74
75  extern const nothrow_t nothrow;
76
77  // libc++'s implementation
78  template <class _E>
79  class initializer_list
80  {
81    const _E* __begin_;
82    size_t    __size_;
83
84    initializer_list(const _E* __b, size_t __s)
85      : __begin_(__b),
86        __size_(__s)
87    {}
88
89  public:
90    typedef _E        value_type;
91    typedef const _E& reference;
92    typedef const _E& const_reference;
93    typedef size_t    size_type;
94
95    typedef const _E* iterator;
96    typedef const _E* const_iterator;
97
98    initializer_list() : __begin_(0), __size_(0) {}
99
100    size_t    size()  const {return __size_;}
101    const _E* begin() const {return __begin_;}
102    const _E* end()   const {return __begin_ + __size_;}
103  };
104
105  template<class InputIter, class OutputIter>
106  OutputIter copy(InputIter II, InputIter IE, OutputIter OI) {
107    while (II != IE)
108      *OI++ = *II++;
109    return OI;
110  }
111
112  struct input_iterator_tag { };
113  struct output_iterator_tag { };
114  struct forward_iterator_tag : public input_iterator_tag { };
115  struct bidirectional_iterator_tag : public forward_iterator_tag { };
116  struct random_access_iterator_tag : public bidirectional_iterator_tag { };
117
118  template <class _Tp>
119  class allocator {};
120
121  template <class _Tp, class _Alloc>
122  class __list_imp
123  {};
124
125  template <class _Tp, class _Alloc = allocator<_Tp> >
126  class list
127  : private __list_imp<_Tp, _Alloc>
128  {
129  public:
130    void pop_front() {
131      // Fake use-after-free.
132      // No warning is expected as we are suppressing warning comming
133      // out of std::list.
134      int z = 0;
135      z = 5/z;
136    }
137    bool empty() const;
138  };
139
140}
141
142void* operator new(std::size_t, const std::nothrow_t&) throw();
143void* operator new[](std::size_t, const std::nothrow_t&) throw();
144void operator delete(void*, const std::nothrow_t&) throw();
145void operator delete[](void*, const std::nothrow_t&) throw();
146
147void* operator new (std::size_t size, void* ptr) throw() { return ptr; };
148void* operator new[] (std::size_t size, void* ptr) throw() { return ptr; };
149void operator delete (void* ptr, void*) throw() {};
150void operator delete[] (void* ptr, void*) throw() {};
151