remove clutter from 'nogil' declarations in libcpp

Cython/Includes/libcpp/deque.pxd

 from pair cimport pair
 
-cdef extern from "<deque>" namespace "std":
+cdef extern from "<deque>" namespace "std" nogil:
     cdef cppclass deque[T]:
         cppclass iterator:
-            T& operator*() nogil
-            iterator operator++() nogil
-            iterator operator--() nogil
-            bint operator==(iterator) nogil
-            bint operator!=(iterator) nogil
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(iterator)
+            bint operator!=(iterator)
         cppclass reverse_iterator:
-            T& operator*() nogil
-            iterator operator++() nogil
-            iterator operator--() nogil
-            bint operator==(reverse_iterator) nogil
-            bint operator!=(reverse_iterator) nogil
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
         #cppclass const_iterator(iterator):
         #    pass
         #cppclass const_reverse_iterator(reverse_iterator):
         #    pass
-        deque() nogil except +
-        deque(deque&) nogil except +
-        deque(size_t) nogil except +
-        deque(size_t, T&) nogil except +
+        deque() except +
+        deque(deque&) except +
+        deque(size_t) except +
+        deque(size_t, T&) except +
         #deque[input_iterator](input_iterator, input_iterator)
-        T& operator[](size_t) nogil
+        T& operator[](size_t)
         #deque& operator=(deque&)
-        bint operator==(deque&, deque&) nogil
-        bint operator!=(deque&, deque&) nogil
-        bint operator<(deque&, deque&) nogil
-        bint operator>(deque&, deque&) nogil
-        bint operator<=(deque&, deque&) nogil
-        bint operator>=(deque&, deque&) nogil
-        void assign(size_t, T&) nogil
-        void assign(input_iterator, input_iterator) nogil
-        T& at(size_t) nogil
-        T& back() nogil
-        iterator begin() nogil
+        bint operator==(deque&, deque&)
+        bint operator!=(deque&, deque&)
+        bint operator<(deque&, deque&)
+        bint operator>(deque&, deque&)
+        bint operator<=(deque&, deque&)
+        bint operator>=(deque&, deque&)
+        void assign(size_t, T&)
+        void assign(input_iterator, input_iterator)
+        T& at(size_t)
+        T& back()
+        iterator begin()
         #const_iterator begin()
-        void clear() nogil
-        bint empty() nogil
-        iterator end() nogil
+        void clear()
+        bint empty()
+        iterator end()
         #const_iterator end()
-        iterator erase(iterator) nogil
-        iterator erase(iterator, iterator) nogil
-        T& front() nogil
-        iterator insert(iterator, T&) nogil
-        void insert(iterator, size_t, T&) nogil
-        void insert(iterator, input_iterator, input_iterator) nogil
-        size_t max_size() nogil
-        void pop_back() nogil
-        void pop_front() nogil
-        void push_back(T&) nogil
-        void push_front(T&) nogil
-        reverse_iterator rbegin() nogil
+        iterator erase(iterator)
+        iterator erase(iterator, iterator)
+        T& front()
+        iterator insert(iterator, T&)
+        void insert(iterator, size_t, T&)
+        void insert(iterator, input_iterator, input_iterator)
+        size_t max_size()
+        void pop_back()
+        void pop_front()
+        void push_back(T&)
+        void push_front(T&)
+        reverse_iterator rbegin()
         #const_reverse_iterator rbegin()
-        reverse_iterator rend() nogil
+        reverse_iterator rend()
         #const_reverse_iterator rend()
-        void resize(size_t) nogil
-        void resize(size_t, T&) nogil
-        size_t size() nogil
-        void swap(deque&) nogil
+        void resize(size_t)
+        void resize(size_t, T&)
+        size_t size()
+        void swap(deque&)

Cython/Includes/libcpp/list.pxd

-cdef extern from "<list>" namespace "std":
+cdef extern from "<list>" namespace "std" nogil:
     cdef cppclass list[T]:
         cppclass iterator:
-            T& operator*() nogil
-            iterator operator++() nogil
-            iterator operator--() nogil
-            bint operator==(iterator) nogil
-            bint operator!=(iterator) nogil
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(iterator)
+            bint operator!=(iterator)
         cppclass reverse_iterator:
-            T& operator*() nogil
-            iterator operator++() nogil
-            iterator operator--() nogil
-            bint operator==(reverse_iterator) nogil
-            bint operator!=(reverse_iterator) nogil
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
         #cppclass const_iterator(iterator):
         #    pass
         #cppclass const_reverse_iterator(reverse_iterator):
         #    pass
-        list() nogil except +
-        list(list&) nogil except +
-        list(size_t, T&) nogil except +
+        list() except +
+        list(list&) except +
+        list(size_t, T&) except +
         #list operator=(list&)
-        bint operator==(list&, list&) nogil
-        bint operator!=(list&, list&) nogil
-        bint operator<(list&, list&) nogil
-        bint operator>(list&, list&) nogil
-        bint operator<=(list&, list&) nogil
-        bint operator>=(list&, list&) nogil
-        void assign(size_t, T&) nogil
-        T& back() nogil
-        iterator begin() nogil
+        bint operator==(list&, list&)
+        bint operator!=(list&, list&)
+        bint operator<(list&, list&)
+        bint operator>(list&, list&)
+        bint operator<=(list&, list&)
+        bint operator>=(list&, list&)
+        void assign(size_t, T&)
+        T& back()
+        iterator begin()
         #const_iterator begin()
-        void clear() nogil
-        bint empty() nogil
-        iterator end() nogil
+        void clear()
+        bint empty()
+        iterator end()
         #const_iterator end()
-        iterator erase(iterator) nogil
-        iterator erase(iterator, iterator) nogil
-        T& front() nogil
-        iterator insert(iterator, T&) nogil
-        void insert(iterator, size_t, T&) nogil
-        size_t max_size() nogil
-        void merge(list&) nogil
+        iterator erase(iterator)
+        iterator erase(iterator, iterator)
+        T& front()
+        iterator insert(iterator, T&)
+        void insert(iterator, size_t, T&)
+        size_t max_size()
+        void merge(list&)
         #void merge(list&, BinPred)
-        void pop_back() nogil
-        void pop_front() nogil
-        void push_back(T&) nogil
-        void push_front(T&) nogil
-        reverse_iterator rbegin() nogil
+        void pop_back()
+        void pop_front()
+        void push_back(T&)
+        void push_front(T&)
+        reverse_iterator rbegin()
         #const_reverse_iterator rbegin()
-        void remove(T&) nogil
+        void remove(T&)
         #void remove_if(UnPred)
-        reverse_iterator rend() nogil
+        reverse_iterator rend()
         #const_reverse_iterator rend()
-        void resize(size_t, T&) nogil
-        void reverse() nogil
-        size_t size() nogil
-        void sort() nogil
+        void resize(size_t, T&)
+        void reverse()
+        size_t size()
+        void sort()
         #void sort(BinPred)
-        void splice(iterator, list&) nogil
-        void splice(iterator, list&, iterator) nogil
-        void splice(iterator, list&, iterator, iterator) nogil
-        void swap(list&) nogil
-        void unique() nogil
+        void splice(iterator, list&)
+        void splice(iterator, list&, iterator)
+        void splice(iterator, list&, iterator, iterator)
+        void swap(list&)
+        void unique()
         #void unique(BinPred)

Cython/Includes/libcpp/map.pxd

 from utility cimport pair
 
-cdef extern from "<map>" namespace "std":
+cdef extern from "<map>" namespace "std" nogil:
     cdef cppclass map[T, U]:
         cppclass iterator:
-            pair[T, U]& operator*() nogil
-            iterator operator++() nogil
-            iterator operator--() nogil
-            bint operator==(iterator) nogil
-            bint operator!=(iterator) nogil
+            pair[T, U]& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(iterator)
+            bint operator!=(iterator)
         cppclass reverse_iterator:
-            pair[T, U]& operator*() nogil
-            iterator operator++() nogil
-            iterator operator--() nogil
-            bint operator==(reverse_iterator) nogil
-            bint operator!=(reverse_iterator) nogil
+            pair[T, U]& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
         #cppclass const_iterator(iterator):
         #    pass
         #cppclass const_reverse_iterator(reverse_iterator):
         #    pass
-        map() nogil except +
-        map(map&) nogil except +
+        map() except +
+        map(map&) except +
         #map(key_compare&)
-        U& operator[](T&) nogil
+        U& operator[](T&)
         #map& operator=(map&)
-        bint operator==(map&, map&) nogil
-        bint operator!=(map&, map&) nogil
-        bint operator<(map&, map&) nogil
-        bint operator>(map&, map&) nogil
-        bint operator<=(map&, map&) nogil
-        bint operator>=(map&, map&) nogil
-        U& at(T&) nogil
-        iterator begin() nogil
+        bint operator==(map&, map&)
+        bint operator!=(map&, map&)
+        bint operator<(map&, map&)
+        bint operator>(map&, map&)
+        bint operator<=(map&, map&)
+        bint operator>=(map&, map&)
+        U& at(T&)
+        iterator begin()
         #const_iterator begin()
-        void clear() nogil
-        size_t count(T&) nogil
-        bint empty() nogil
-        iterator end() nogil
+        void clear()
+        size_t count(T&)
+        bint empty()
+        iterator end()
         #const_iterator end()
-        pair[iterator, iterator] equal_range(T&) nogil
+        pair[iterator, iterator] equal_range(T&)
         #pair[const_iterator, const_iterator] equal_range(key_type&)
-        void erase(iterator) nogil
-        void erase(iterator, iterator) nogil
-        size_t erase(T&) nogil
-        iterator find(T&) nogil
+        void erase(iterator)
+        void erase(iterator, iterator)
+        size_t erase(T&)
+        iterator find(T&)
         #const_iterator find(key_type&)
-        pair[iterator, bint] insert(pair[T, U]) nogil # XXX pair[T,U]&
-        iterator insert(iterator, pair[T, U]) nogil # XXX pair[T,U]&
+        pair[iterator, bint] insert(pair[T, U]) # XXX pair[T,U]&
+        iterator insert(iterator, pair[T, U]) # XXX pair[T,U]&
         #void insert(input_iterator, input_iterator)
         #key_compare key_comp()
-        iterator lower_bound(T&) nogil
+        iterator lower_bound(T&)
         #const_iterator lower_bound(key_type&)
-        size_t max_size() nogil
-        reverse_iterator rbegin() nogil
+        size_t max_size()
+        reverse_iterator rbegin()
         #const_reverse_iterator rbegin()
-        reverse_iterator rend() nogil
+        reverse_iterator rend()
         #const_reverse_iterator rend()
-        size_t size() nogil
-        void swap(map&) nogil
-        iterator upper_bound(T&) nogil
+        size_t size()
+        void swap(map&)
+        iterator upper_bound(T&)
         #const_iterator upper_bound(key_type&)
         #value_compare value_comp()

Cython/Includes/libcpp/queue.pxd

-cdef extern from "<queue>" namespace "std":
+cdef extern from "<queue>" namespace "std" nogil:
     cdef cppclass queue[T]:
-        queue() nogil except +
-        queue(queue&) nogil except +
+        queue() except +
+        queue(queue&) except +
         #queue(Container&)
-        T& back() nogil
-        bint empty() nogil
-        T& front() nogil
-        void pop() nogil
-        void push(T&) nogil
-        size_t size() nogil
+        T& back()
+        bint empty()
+        T& front()
+        void pop()
+        void push(T&)
+        size_t size()
     cdef cppclass priority_queue[T]:
-        priority_queue() nogil except +
-        priority_queue(priority_queue&) nogil except +
+        priority_queue() except +
+        priority_queue(priority_queue&) except +
         #priority_queue(Container&)
-        bint empty() nogil
-        void pop() nogil
-        void push(T&) nogil
-        size_t size() nogil
-        T& top() nogil
+        bint empty()
+        void pop()
+        void push(T&)
+        size_t size()
+        T& top()

Cython/Includes/libcpp/set.pxd

 from pair cimport pair
 
-cdef extern from "<set>" namespace "std":
+cdef extern from "<set>" namespace "std" nogil:
     cdef cppclass set[T]:
         cppclass iterator:
             T& operator*()
-            iterator operator++() nogil
-            iterator operator--() nogil
-            bint operator==(iterator) nogil
-            bint operator!=(iterator) nogil
+            iterator operator++()
+            iterator operator--()
+            bint operator==(iterator)
+            bint operator!=(iterator)
         cppclass reverse_iterator:
-            T& operator*() nogil
-            iterator operator++() nogil
-            iterator operator--() nogil
-            bint operator==(reverse_iterator) nogil
-            bint operator!=(reverse_iterator) nogil
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
         #cppclass const_iterator(iterator):
         #    pass
         #cppclass const_reverse_iterator(reverse_iterator):
         #    pass
-        set() nogil except +
-        set(set&) nogil except +
+        set() except +
+        set(set&) except +
         #set(key_compare&)
         #set& operator=(set&)
-        bint operator==(set&, set&) nogil
-        bint operator!=(set&, set&) nogil
-        bint operator<(set&, set&) nogil
-        bint operator>(set&, set&) nogil
-        bint operator<=(set&, set&) nogil
-        bint operator>=(set&, set&) nogil
-        iterator begin() nogil
+        bint operator==(set&, set&)
+        bint operator!=(set&, set&)
+        bint operator<(set&, set&)
+        bint operator>(set&, set&)
+        bint operator<=(set&, set&)
+        bint operator>=(set&, set&)
+        iterator begin()
         #const_iterator begin()
-        void clear() nogil
-        size_t count(T&) nogil
-        bint empty() nogil
-        iterator end() nogil
+        void clear()
+        size_t count(T&)
+        bint empty()
+        iterator end()
         #const_iterator end()
-        pair[iterator, iterator] equal_range(T&) nogil
+        pair[iterator, iterator] equal_range(T&)
         #pair[const_iterator, const_iterator] equal_range(T&)
-        void erase(iterator) nogil
-        void erase(iterator, iterator) nogil
-        size_t erase(T&) nogil
-        iterator find(T&) nogil
+        void erase(iterator)
+        void erase(iterator, iterator)
+        size_t erase(T&)
+        iterator find(T&)
         #const_iterator find(T&)
-        pair[iterator, bint] insert(T&) nogil
-        iterator insert(iterator, T&) nogil
+        pair[iterator, bint] insert(T&)
+        iterator insert(iterator, T&)
         #void insert(input_iterator, input_iterator)
         #key_compare key_comp()
-        iterator lower_bound(T&) nogil
+        iterator lower_bound(T&)
         #const_iterator lower_bound(T&)
-        size_t max_size() nogil
-        reverse_iterator rbegin() nogil
+        size_t max_size()
+        reverse_iterator rbegin()
         #const_reverse_iterator rbegin()
-        reverse_iterator rend() nogil
+        reverse_iterator rend()
         #const_reverse_iterator rend()
-        size_t size() nogil
-        void swap(set&) nogil
-        iterator upper_bound(T&) nogil
+        size_t size()
+        void swap(set&)
+        iterator upper_bound(T&)
         #const_iterator upper_bound(T&)
         #value_compare value_comp()

Cython/Includes/libcpp/stack.pxd

-cdef extern from "<stack>" namespace "std":
+cdef extern from "<stack>" namespace "std" nogil:
     cdef cppclass stack[T]:
-        stack() nogil except +
-        stack(stack&) nogil except +
+        stack() except +
+        stack(stack&) except +
         #stack(Container&)
-        bint empty() nogil
-        void pop() nogil
-        void push(T&) nogil
-        size_t size() nogil
-        T& top() nogil
+        bint empty()
+        void pop()
+        void push(T&)
+        size_t size()
+        T& top()

Cython/Includes/libcpp/string.pxd

@@ -3,120 +3,120 @@
 from libc.string cimport const_char
 
 
-cdef extern from "<string>" namespace "std":
+cdef extern from "<string>" namespace "std" nogil:
 
     size_t npos = -1
 
     cdef cppclass string:
-        string() nogil except +
-        string(char *) nogil except +
-        string(char *, size_t) nogil except +
-        string(string&) nogil except +
+        string() except +
+        string(char *) except +
+        string(char *, size_t) except +
+        string(string&) except +
         # as a string formed by a repetition of character c, n times.
-        string(size_t, char) nogil except +
-
-        const char* c_str() nogil
-        const char* data() nogil
-        size_t size() nogil
-        size_t max_size() nogil
-        size_t length() nogil
-        void resize(size_t) nogil
-        void resize(size_t, char c) nogil
-        size_t capacity() nogil
-        void reserve(size_t) nogil
-        void clear() nogil
-        bint empty() nogil
-
-        char& at(size_t) nogil
-        char& operator[](size_t) nogil
-        int compare(string&) nogil
-
-        string& append(string&) nogil
-        string& append(string&, size_t, size_t) nogil
-        string& append(char *) nogil
-        string& append(char *, size_t) nogil
-        string& append(size_t, char) nogil
-
-        void push_back(char c) nogil
-
-        string& assign (string&) nogil
-        string& assign (string&, size_t, size_t) nogil
-        string& assign (char *, size_t) nogil
-        string& assign (char *) nogil
-        string& assign (size_t n, char c) nogil
-
-        string& insert(size_t, string&) nogil
-        string& insert(size_t, string&, size_t, size_t) nogil
-        string& insert(size_t, char* s, size_t) nogil
-
-
-        string& insert(size_t, char* s) nogil
-        string& insert(size_t, size_t, char c) nogil
-
-        size_t copy(char *, size_t, size_t) nogil
-
-        size_t find(string&) nogil
-        size_t find(string&, size_t) nogil
-        size_t find(char*, size_t pos, size_t) nogil
-        size_t find(char*, size_t pos) nogil
-        size_t find(char, size_t pos) nogil
-
-        size_t rfind(string&, size_t) nogil
-        size_t rfind(char* s, size_t, size_t) nogil
-        size_t rfind(char*, size_t pos) nogil
-        size_t rfind(char c, size_t) nogil
-        size_t rfind(char c) nogil
-
-        size_t find_first_of(string&, size_t) nogil
-        size_t find_first_of(char* s, size_t, size_t) nogil
-        size_t find_first_of(char*, size_t pos) nogil
-        size_t find_first_of(char c, size_t) nogil
-        size_t find_first_of(char c) nogil
-
-        size_t find_first_not_of(string&, size_t) nogil
-        size_t find_first_not_of(char* s, size_t, size_t) nogil
-        size_t find_first_not_of(char*, size_t pos) nogil
-        size_t find_first_not_of(char c, size_t) nogil
-        size_t find_first_not_of(char c) nogil
-
-        size_t find_last_of(string&, size_t) nogil
-        size_t find_last_of(char* s, size_t, size_t) nogil
-        size_t find_last_of(char*, size_t pos) nogil
-        size_t find_last_of(char c, size_t) nogil
-        size_t find_last_of(char c) nogil
-
-        size_t find_last_not_of(string&, size_t) nogil
-        size_t find_last_not_of(char* s, size_t, size_t) nogil
-        size_t find_last_not_of(char*, size_t pos) nogil
-
-        string substr(size_t, size_t) nogil
-        string substr() nogil
-        string substr(size_t) nogil
-
-        size_t find_last_not_of(char c, size_t) nogil
-        size_t find_last_not_of(char c) nogil
+        string(size_t, char) except +
+
+        const char* c_str()
+        const char* data()
+        size_t size()
+        size_t max_size()
+        size_t length()
+        void resize(size_t)
+        void resize(size_t, char c)
+        size_t capacity()
+        void reserve(size_t)
+        void clear()
+        bint empty()
+
+        char& at(size_t)
+        char& operator[](size_t)
+        int compare(string&)
+
+        string& append(string&)
+        string& append(string&, size_t, size_t)
+        string& append(char *)
+        string& append(char *, size_t)
+        string& append(size_t, char)
+
+        void push_back(char c)
+
+        string& assign (string&)
+        string& assign (string&, size_t, size_t)
+        string& assign (char *, size_t)
+        string& assign (char *)
+        string& assign (size_t n, char c)
+
+        string& insert(size_t, string&)
+        string& insert(size_t, string&, size_t, size_t)
+        string& insert(size_t, char* s, size_t)
+
+
+        string& insert(size_t, char* s)
+        string& insert(size_t, size_t, char c)
+
+        size_t copy(char *, size_t, size_t)
+
+        size_t find(string&)
+        size_t find(string&, size_t)
+        size_t find(char*, size_t pos, size_t)
+        size_t find(char*, size_t pos)
+        size_t find(char, size_t pos)
+
+        size_t rfind(string&, size_t)
+        size_t rfind(char* s, size_t, size_t)
+        size_t rfind(char*, size_t pos)
+        size_t rfind(char c, size_t)
+        size_t rfind(char c)
+
+        size_t find_first_of(string&, size_t)
+        size_t find_first_of(char* s, size_t, size_t)
+        size_t find_first_of(char*, size_t pos)
+        size_t find_first_of(char c, size_t)
+        size_t find_first_of(char c)
+
+        size_t find_first_not_of(string&, size_t)
+        size_t find_first_not_of(char* s, size_t, size_t)
+        size_t find_first_not_of(char*, size_t pos)
+        size_t find_first_not_of(char c, size_t)
+        size_t find_first_not_of(char c)
+
+        size_t find_last_of(string&, size_t)
+        size_t find_last_of(char* s, size_t, size_t)
+        size_t find_last_of(char*, size_t pos)
+        size_t find_last_of(char c, size_t)
+        size_t find_last_of(char c)
+
+        size_t find_last_not_of(string&, size_t)
+        size_t find_last_not_of(char* s, size_t, size_t)
+        size_t find_last_not_of(char*, size_t pos)
+
+        string substr(size_t, size_t)
+        string substr()
+        string substr(size_t)
+
+        size_t find_last_not_of(char c, size_t)
+        size_t find_last_not_of(char c)
 
         #string& operator= (string&)
         #string& operator= (char*)
         #string& operator= (char)
 
-        string operator+ (string& rhs) nogil
-        string operator+ (char* rhs) nogil
+        string operator+ (string& rhs)
+        string operator+ (char* rhs)
 
-        bint operator==(string&) nogil
-        bint operator==(char*) nogil
+        bint operator==(string&)
+        bint operator==(char*)
 
-        bint operator!= (string& rhs ) nogil
-        bint operator!= (char* ) nogil
+        bint operator!= (string& rhs )
+        bint operator!= (char* )
 
-        bint operator< (string&) nogil
-        bint operator< (char*) nogil
+        bint operator< (string&)
+        bint operator< (char*)
 
-        bint operator> (string&) nogil
-        bint operator> (char*) nogil
+        bint operator> (string&)
+        bint operator> (char*)
 
-        bint operator<= (string&) nogil
-        bint operator<= (char*) nogil
+        bint operator<= (string&)
+        bint operator<= (char*)
 
-        bint operator>= (string&) nogil
-        bint operator>= (char*) nogil
+        bint operator>= (string&)
+        bint operator>= (char*)

Cython/Includes/libcpp/unordered_map.pxd

 from utility cimport pair
 
-cdef extern from "<unordered_map>" namespace "std":
+cdef extern from "<unordered_map>" namespace "std" nogil:
     cdef cppclass unordered_map[T, U]:
         cppclass iterator:
-            pair[T, U]& operator*() nogil
-            iterator operator++() nogil
-            iterator operator--() nogil
-            bint operator==(iterator) nogil
-            bint operator!=(iterator) nogil
+            pair[T, U]& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(iterator)
+            bint operator!=(iterator)
         cppclass reverse_iterator:
-            pair[T, U]& operator*() nogil
-            iterator operator++() nogil
-            iterator operator--() nogil
-            bint operator==(reverse_iterator) nogil
-            bint operator!=(reverse_iterator) nogil
+            pair[T, U]& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
         #cppclass const_iterator(iterator):
         #    pass
         #cppclass const_reverse_iterator(reverse_iterator):
         #    pass
-        unordered_map() nogil except +
-        unordered_map(unordered_map&) nogil except +
+        unordered_map() except +
+        unordered_map(unordered_map&) except +
         #unordered_map(key_compare&)
-        U& operator[](T&) nogil
+        U& operator[](T&)
         #unordered_map& operator=(unordered_map&)
-        bint operator==(unordered_map&, unordered_map&) nogil
-        bint operator!=(unordered_map&, unordered_map&) nogil
-        bint operator<(unordered_map&, unordered_map&) nogil
-        bint operator>(unordered_map&, unordered_map&) nogil
-        bint operator<=(unordered_map&, unordered_map&) nogil
-        bint operator>=(unordered_map&, unordered_map&) nogil
-        U& at(T&) nogil
-        iterator begin() nogil
+        bint operator==(unordered_map&, unordered_map&)
+        bint operator!=(unordered_map&, unordered_map&)
+        bint operator<(unordered_map&, unordered_map&)
+        bint operator>(unordered_map&, unordered_map&)
+        bint operator<=(unordered_map&, unordered_map&)
+        bint operator>=(unordered_map&, unordered_map&)
+        U& at(T&)
+        iterator begin()
         #const_iterator begin()
-        void clear() nogil
-        size_t count(T&) nogil
-        bint empty() nogil
-        iterator end() nogil
+        void clear()
+        size_t count(T&)
+        bint empty()
+        iterator end()
         #const_iterator end()
-        pair[iterator, iterator] equal_range(T&) nogil
+        pair[iterator, iterator] equal_range(T&)
         #pair[const_iterator, const_iterator] equal_range(key_type&)
-        void erase(iterator) nogil
-        void erase(iterator, iterator) nogil
-        size_t erase(T&) nogil
-        iterator find(T&) nogil
+        void erase(iterator)
+        void erase(iterator, iterator)
+        size_t erase(T&)
+        iterator find(T&)
         #const_iterator find(key_type&)
-        pair[iterator, bint] insert(pair[T, U]) nogil # XXX pair[T,U]&
-        iterator insert(iterator, pair[T, U]) nogil # XXX pair[T,U]&
+        pair[iterator, bint] insert(pair[T, U]) # XXX pair[T,U]&
+        iterator insert(iterator, pair[T, U]) # XXX pair[T,U]&
         #void insert(input_iterator, input_iterator)
         #key_compare key_comp()
-        iterator lower_bound(T&) nogil
+        iterator lower_bound(T&)
         #const_iterator lower_bound(key_type&)
-        size_t max_size() nogil
-        reverse_iterator rbegin() nogil
+        size_t max_size()
+        reverse_iterator rbegin()
         #const_reverse_iterator rbegin()
-        reverse_iterator rend() nogil
+        reverse_iterator rend()
         #const_reverse_iterator rend()
-        size_t size() nogil
-        void swap(unordered_map&) nogil
-        iterator upper_bound(T&) nogil
+        size_t size()
+        void swap(unordered_map&)
+        iterator upper_bound(T&)
         #const_iterator upper_bound(key_type&)
         #value_compare value_comp()

Cython/Includes/libcpp/unordered_set.pxd

 from pair cimport pair
 
-cdef extern from "<unordered_set>" namespace "std":
+cdef extern from "<unordered_set>" namespace "std" nogil:
     cdef cppclass unordered_set[T]:
         cppclass iterator:
             T& operator*()
-            iterator operator++() nogil
-            iterator operator--() nogil
-            bint operator==(iterator) nogil
-            bint operator!=(iterator) nogil
+            iterator operator++()
+            iterator operator--()
+            bint operator==(iterator)
+            bint operator!=(iterator)
         cppclass reverse_iterator:
-            T& operator*() nogil
-            iterator operator++() nogil
-            iterator operator--() nogil
-            bint operator==(reverse_iterator) nogil
-            bint operator!=(reverse_iterator) nogil
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
         #cppclass const_iterator(iterator):
         #    pass
         #cppclass const_reverse_iterator(reverse_iterator):
         #    pass
-        unordered_set() nogil except +
-        unordered_set(unordered_set&) nogil except +
+        unordered_set() except +
+        unordered_set(unordered_set&) except +
         #unordered_set(key_compare&)
         #unordered_set& operator=(unordered_set&)
-        bint operator==(unordered_set&, unordered_set&) nogil
-        bint operator!=(unordered_set&, unordered_set&) nogil
-        bint operator<(unordered_set&, unordered_set&) nogil
-        bint operator>(unordered_set&, unordered_set&) nogil
-        bint operator<=(unordered_set&, unordered_set&) nogil
-        bint operator>=(unordered_set&, unordered_set&) nogil
-        iterator begin() nogil
+        bint operator==(unordered_set&, unordered_set&)
+        bint operator!=(unordered_set&, unordered_set&)
+        bint operator<(unordered_set&, unordered_set&)
+        bint operator>(unordered_set&, unordered_set&)
+        bint operator<=(unordered_set&, unordered_set&)
+        bint operator>=(unordered_set&, unordered_set&)
+        iterator begin()
         #const_iterator begin()
-        void clear() nogil
-        size_t count(T&) nogil
-        bint empty() nogil
-        iterator end() nogil
+        void clear()
+        size_t count(T&)
+        bint empty()
+        iterator end()
         #const_iterator end()
-        pair[iterator, iterator] equal_range(T&) nogil
+        pair[iterator, iterator] equal_range(T&)
         #pair[const_iterator, const_iterator] equal_range(T&)
-        void erase(iterator) nogil
-        void erase(iterator, iterator) nogil
-        size_t erase(T&) nogil
-        iterator find(T&) nogil
+        void erase(iterator)
+        void erase(iterator, iterator)
+        size_t erase(T&)
+        iterator find(T&)
         #const_iterator find(T&)
-        pair[iterator, bint] insert(T&) nogil
-        iterator insert(iterator, T&) nogil
+        pair[iterator, bint] insert(T&)
+        iterator insert(iterator, T&)
         #void insert(input_iterator, input_iterator)
         #key_compare key_comp()
-        iterator lower_bound(T&) nogil
+        iterator lower_bound(T&)
         #const_iterator lower_bound(T&)
-        size_t max_size() nogil
-        reverse_iterator rbegin() nogil
+        size_t max_size()
+        reverse_iterator rbegin()
         #const_reverse_iterator rbegin()
-        reverse_iterator rend() nogil
+        reverse_iterator rend()
         #const_reverse_iterator rend()
-        size_t size() nogil
-        void swap(unordered_set&) nogil
-        iterator upper_bound(T&) nogil
+        size_t size()
+        void swap(unordered_set&)
+        iterator upper_bound(T&)
         #const_iterator upper_bound(T&)
         #value_compare value_comp()

Cython/Includes/libcpp/utility.pxd

-cdef extern from "<utility>" namespace "std":
+cdef extern from "<utility>" namespace "std" nogil:
     cdef cppclass pair[T, U]:
         T first
         U second
-        pair() nogil except +
-        pair(pair&) nogil except +
-        pair(T&, U&) nogil except +
-        bint operator==(pair&, pair&) nogil
-        bint operator!=(pair&, pair&) nogil
-        bint operator<(pair&, pair&) nogil
-        bint operator>(pair&, pair&) nogil
-        bint operator<=(pair&, pair&) nogil
-        bint operator>=(pair&, pair&) nogil
+        pair() except +
+        pair(pair&) except +
+        pair(T&, U&) except +
+        bint operator==(pair&, pair&)
+        bint operator!=(pair&, pair&)
+        bint operator<(pair&, pair&)
+        bint operator>(pair&, pair&)
+        bint operator<=(pair&, pair&)
+        bint operator>=(pair&, pair&)

Cython/Includes/libcpp/vector.pxd

-cdef extern from "<vector>" namespace "std":
+cdef extern from "<vector>" namespace "std" nogil:
     cdef cppclass vector[T]:
         cppclass iterator:
-            T& operator*() nogil
-            iterator operator++() nogil
-            iterator operator--() nogil
-            iterator operator+(size_t) nogil
-            iterator operator-(size_t) nogil
-            bint operator==(iterator) nogil
-            bint operator!=(iterator) nogil
-            bint operator<(iterator) nogil
-            bint operator>(iterator) nogil
-            bint operator<=(iterator) nogil
-            bint operator>=(iterator) nogil
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
+            iterator operator+(size_t)
+            iterator operator-(size_t)
+            bint operator==(iterator)
+            bint operator!=(iterator)
+            bint operator<(iterator)
+            bint operator>(iterator)
+            bint operator<=(iterator)
+            bint operator>=(iterator)
         cppclass reverse_iterator:
-            T& operator*() nogil
-            iterator operator++() nogil
-            iterator operator--() nogil
-            iterator operator+(size_t) nogil
-            iterator operator-(size_t) nogil
-            bint operator==(reverse_iterator) nogil
-            bint operator!=(reverse_iterator) nogil
-            bint operator<(reverse_iterator) nogil
-            bint operator>(reverse_iterator) nogil
-            bint operator<=(reverse_iterator) nogil
-            bint operator>=(reverse_iterator) nogil
+            T& operator*()
+            iterator operator++()
+            iterator operator--()
+            iterator operator+(size_t)
+            iterator operator-(size_t)
+            bint operator==(reverse_iterator)
+            bint operator!=(reverse_iterator)
+            bint operator<(reverse_iterator)
+            bint operator>(reverse_iterator)
+            bint operator<=(reverse_iterator)
+            bint operator>=(reverse_iterator)
         #cppclass const_iterator(iterator):
         #    pass
         #cppclass const_reverse_iterator(reverse_iterator):
         #    pass
-        vector() nogil except +
-        vector(vector&) nogil except +
-        vector(size_t) nogil except +
-        vector(size_t, T&) nogil except +
+        vector() except +
+        vector(vector&) except +
+        vector(size_t) except +
+        vector(size_t, T&) except +
         #vector[input_iterator](input_iterator, input_iterator)
-        T& operator[](size_t) nogil
+        T& operator[](size_t)
         #vector& operator=(vector&)
-        bint operator==(vector&, vector&) nogil
-        bint operator!=(vector&, vector&) nogil
-        bint operator<(vector&, vector&) nogil
-        bint operator>(vector&, vector&) nogil
-        bint operator<=(vector&, vector&) nogil
-        bint operator>=(vector&, vector&) nogil
-        void assign(size_t, T&) nogil
+        bint operator==(vector&, vector&)
+        bint operator!=(vector&, vector&)
+        bint operator<(vector&, vector&)
+        bint operator>(vector&, vector&)
+        bint operator<=(vector&, vector&)
+        bint operator>=(vector&, vector&)
+        void assign(size_t, T&)
         void assign[input_iterator](input_iterator, input_iterator)
-        T& at(size_t) nogil
-        T& back() nogil
-        iterator begin() nogil
+        T& at(size_t)
+        T& back()
+        iterator begin()
         #const_iterator begin()
-        size_t capacity() nogil
-        void clear() nogil
-        bint empty() nogil
-        iterator end() nogil
+        size_t capacity()
+        void clear()
+        bint empty()
+        iterator end()
         #const_iterator end()
-        iterator erase(iterator) nogil
-        iterator erase(iterator, iterator) nogil
-        T& front() nogil
-        iterator insert(iterator, T&) nogil
-        void insert(iterator, size_t, T&) nogil
-        void insert(iterator, iterator, iterator) nogil
-        size_t max_size() nogil
-        void pop_back() nogil
-        void push_back(T&) nogil
-        reverse_iterator rbegin() nogil
+        iterator erase(iterator)
+        iterator erase(iterator, iterator)
+        T& front()
+        iterator insert(iterator, T&)
+        void insert(iterator, size_t, T&)
+        void insert(iterator, iterator, iterator)
+        size_t max_size()
+        void pop_back()
+        void push_back(T&)
+        reverse_iterator rbegin()
         #const_reverse_iterator rbegin()
-        reverse_iterator rend() nogil
+        reverse_iterator rend()
         #const_reverse_iterator rend()
-        void reserve(size_t) nogil
-        void resize(size_t) nogil
-        void resize(size_t, T&) nogil
-        size_t size() nogil
-        void swap(vector&) nogil
+        void reserve(size_t)
+        void resize(size_t)
+        void resize(size_t, T&)
+        size_t size()
+        void swap(vector&)
         
         #C++0x methods
-        T* data() nogil
+        T* data()
         void shrink_to_fit()