X-Git-Url: https://git.wh0rd.org/?p=ICEs.git;a=blobdiff_plain;f=411691%2Fid_manager.i.2;fp=411691%2Fid_manager.i.2;h=f1389b21ee07235ab5c206d4e2398ddd04678aaa;hp=0000000000000000000000000000000000000000;hb=bd3239d2bbe0de3a200b266503e3330b1e391489;hpb=dbff64cb4b7530861c2309c794efdd4e0cf47a23

diff --git a/411691/id_manager.i.2 b/411691/id_manager.i.2
new file mode 100644
index 0000000..f1389b2
--- /dev/null
+++ b/411691/id_manager.i.2
@@ -0,0 +1,314 @@
+typedef long unsigned int size_t;
+          namespace std  {
+        template<typename _Tp> _Tp* __addressof(_Tp& __r) {
+      }
+        template<class _Sp, class _Tp> struct __traitor {
+      };
+        template<typename _Tp> struct __is_integer {
+      };
+        template<typename _Tp> struct __is_floating {
+      };
+        template<typename _Tp> struct __is_pointer {
+      };
+        template<typename _Tp> struct __is_normal_iterator {
+      };
+        template<typename _Tp> struct __is_arithmetic : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > {
+      };
+        template<typename _Tp> struct __is_scalar : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > {
+      };
+        template<typename _Iterator, bool _HasBase> struct _Iter_base {      };
+
+        template<typename _Iterator> struct _Niter_base : _Iter_base<_Iterator, __is_normal_iterator<_Iterator>::__value> {      };
+        template<typename _Iterator> typename _Niter_base<_Iterator>::iterator_type __niter_base(_Iterator __it) {      }
+        template<typename _CharT> struct char_traits;
+      class exception {
+    public: exception() throw() {    }
+    virtual ~exception() throw();
+    };
+
+
+        }
+          namespace __gnu_cxx  {
+        template<bool, typename> struct __enable_if {      };
+        template<typename _Iterator, typename _Container> class __normal_iterator {
+      protected: _Iterator _M_current;
+      public: typedef _Iterator iterator_type;
+      __normal_iterator() : _M_current(_Iterator()) {
+    }
+      };
+        template<typename _Tp> class new_allocator {
+      public:
+      typedef const _Tp* const_pointer;
+      typedef _Tp& reference;
+      };
+        }
+          namespace std  {
+
+        template<typename _Tp> class allocator: public __gnu_cxx::new_allocator<_Tp> {
+      public:
+      template<typename _Tp1> struct rebind {
+    typedef allocator<_Tp1> other;
+    };
+      };
+        template<typename _InputIterator, typename _ForwardIterator, typename _Allocator> _ForwardIterator __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, _ForwardIterator __result, _Allocator& __alloc) {
+      try {
+    }
+      catch(...) {
+    }
+      }
+
+        }
+          namespace boost {
+        template<class T> class scoped_ptr {
+      private: T * px;
+      public: typedef T element_type;
+      explicit scoped_ptr( T * p = 0 ): px( p ) {
+    }
+      };
+        }
+          namespace std  {
+        template<typename _CharT, typename _Traits = char_traits<_CharT>, typename _Alloc = allocator<_CharT> > class basic_string;
+        typedef basic_string<char> string;
+        template<> struct char_traits<char> {
+      typedef char char_type;
+      static void assign(char_type& __c1, const char_type& __c2) {
+    }
+      }
+        __pthread_unwind_buf_t ;
+        }
+          typedef int _Atomic_word;
+          namespace __gnu_cxx  {
+        static _Atomic_word  __exchange_and_add_dispatch(_Atomic_word* __mem, int __val) {
+      }
+        }
+          namespace std  {
+        template<typename _CharT, typename _Traits, typename _Alloc> class basic_string {
+      typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type;
+      public: typedef _Traits traits_type;
+      typedef _Alloc allocator_type;
+      typedef typename _CharT_alloc_type::reference reference;
+      typedef typename _CharT_alloc_type::const_pointer const_pointer;
+      typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string> const_iterator;
+      private: struct _Rep_base {
+    _Atomic_word _M_refcount;
+    };
+      struct _Rep : _Rep_base {
+    void _M_set_length_and_sharable(size_t __n) {
+    }
+    _CharT* _M_refdata() throw() {
+    return reinterpret_cast<_CharT*>(this + 1);
+    }
+    void _M_dispose(const _Alloc& __a) {
+    if (__builtin_expect(this != &_S_empty_rep(), false)) {
+    if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, -1) <= 0) {
+  _M_destroy(__a);
+  }
+    }
+    }
+    void _M_destroy(const _Alloc&) throw();
+    };
+      struct _Alloc_hider : _Alloc {
+    _Alloc_hider(_CharT* __dat, const _Alloc& __a) : _Alloc(__a), _M_p(__dat) {
+    }
+    _CharT* _M_p;
+    };
+      public: static const size_t npos = static_cast<size_t>(-1);
+      private: mutable _Alloc_hider _M_dataplus;
+      _Rep* _M_rep() const {
+    }
+      size_t _M_limit(size_t __pos, size_t __off) const {
+    }
+      static _Rep& _S_empty_rep() {
+    }
+      public: basic_string() : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) {
+    }
+      ~basic_string() {
+    _M_rep()->_M_dispose(this->get_allocator());
+    }
+      size_t length() const {
+    }
+      reference operator[](size_t __pos) {
+    }
+      basic_string& erase(size_t __pos = 0, size_t __n = npos) {
+    }
+      allocator_type get_allocator() const {
+    }
+      };
+        }
+          namespace boost {
+        namespace detail {
+      template <typename T> class empty_base {
+    };
+      }
+        template <class T, class U, class B = ::boost::detail::empty_base<T> > struct less_than_comparable2 : B {
+      };
+        template <class T, class U, class B = ::boost::detail::empty_base<T> > struct equality_comparable2 : B {
+      };
+        namespace detail {
+      struct false_t {
+   };
+      }
+        template<class T> struct is_chained_base {
+      typedef ::boost::detail::false_t value;
+      };
+        template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct less_than_comparable : less_than_comparable2<T, U, B> {
+     };
+        template <class T ,class U = T ,class B = ::boost::detail::empty_base<T> ,class O = typename is_chained_base<U>::value > struct equality_comparable : equality_comparable2<T, U, B> {
+     };
+        namespace type_traits {
+      }
+        template<class T> class intrusive_ptr {
+      private: typedef intrusive_ptr this_type;
+      public: typedef T element_type;
+      intrusive_ptr(): px( 0 ) {
+    }
+      intrusive_ptr( T * p, bool add_ref = true ): px( p ) {
+    }
+      ~intrusive_ptr() {
+    if( px != 0 ) intrusive_ptr_release( px );
+    }
+      T * operator->() const {
+    return px;
+    }
+      typedef T * this_type::*unspecified_bool_type;
+      operator unspecified_bool_type() const {
+    }
+      private: T * px;
+      };
+        }
+          namespace quickbook {
+        struct section_info;
+        struct string_ref : boost::less_than_comparable<string_ref, boost::less_than_comparable<string_ref, std::string, boost::equality_comparable<string_ref, boost::equality_comparable<string_ref, std::string> > > > {
+      public: typedef std::string::const_iterator iterator;
+      private: iterator begin_, end_;
+      public: string_ref() : begin_(), end_() {
+    }
+      };
+        namespace exception_detail {
+      }
+        }
+        namespace std {
+      class bad_cast : public exception {    };
+        }
+          namespace quickbook {
+        template <typename T> struct intrusive_base {
+      intrusive_base() : ref_count_(0) {
+   }
+      ~intrusive_base() {
+    }
+      friend void intrusive_ptr_release(T* ptr) {
+    if(--ptr->ref_count_ == 0) delete ptr;
+    }
+      private: unsigned ref_count_;
+      };
+        struct id_category {
+      enum categories {
+    default_category = 0, numbered, generated, generated_heading, generated_section, generated_doc, explicit_id, explicit_section_id, explicit_anchor_id };
+      categories c;
+      };
+        struct id_state;
+        struct id_manager {
+      id_manager();
+      private: boost::scoped_ptr<id_state> state;
+      };
+        }
+          namespace boost{
+        namespace detail {
+      }
+        }
+          namespace std  {
+        template<typename _Tp, typename _Ref, typename _Ptr> struct _Deque_iterator {
+      };
+        template<typename _Tp, typename _Alloc> class _Deque_base {
+      public: typedef _Alloc allocator_type;
+      typedef _Deque_iterator<_Tp, _Tp&, _Tp*> iterator;
+      _Deque_base() : _M_impl() {
+    _M_initialize_map(0);
+    }
+      typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
+      struct _Deque_impl : public _Tp_alloc_type {
+    _Tp** _M_map;
+    size_t _M_map_size;
+    iterator _M_start;
+    iterator _M_finish;
+    _Deque_impl() : _Tp_alloc_type(), _M_map(0), _M_map_size(0), _M_start(), _M_finish() {
+    }
+    };
+      protected: void _M_initialize_map(size_t);
+      _Deque_impl _M_impl;
+      };
+        template<typename _Tp, typename _Alloc = std::allocator<_Tp> > class deque : protected _Deque_base<_Tp, _Alloc> {
+      };
+        namespace numeric {
+      enum range_check_result {
+    cInRange = 0 , cNegOverflow = 1 , cPosOverflow = 2 }
+      ;
+      class bad_numeric_cast : public std::bad_cast {
+    };
+      class negative_overflow : public bad_numeric_cast {
+    void operator() ( range_check_result r ) {
+    if ( r == cNegOverflow ) throw negative_overflow() ;
+    }
+    }
+      ;
+      }
+        }
+          namespace quickbook {
+        static const size_t max_size = 32;
+        struct id_placeholder {
+      };
+        struct file_info;
+        struct doc_info;
+        struct id_state {
+      boost::intrusive_ptr<file_info> current_file;
+      std::deque<id_placeholder> placeholders;
+      private: id_placeholder* add_id_to_section( std::string const& id, id_category category, boost::intrusive_ptr<section_info> const& section);
+      };
+        struct file_info : intrusive_base<file_info> {
+      boost::intrusive_ptr<file_info> parent;
+      boost::intrusive_ptr<doc_info> document;
+      bool document_root;
+      unsigned compatibility_version;
+      boost::intrusive_ptr<section_info> switched_section;
+      id_placeholder* original_placeholder;
+      std::string doc_id_1_1;
+      file_info(boost::intrusive_ptr<file_info> const& parent, unsigned compatibility_version) : parent(parent), document(parent->document), document_root(false), compatibility_version(compatibility_version), switched_section(), original_placeholder() {
+   }
+      };
+        struct doc_info : intrusive_base<doc_info> {
+      boost::intrusive_ptr<section_info> current_section;
+      std::string last_title_1_1;
+      std::string section_id_1_1;
+      };
+        struct section_info : intrusive_base<section_info> {
+      boost::intrusive_ptr<section_info> parent;
+      unsigned compatibility_version;
+      unsigned level;
+      std::string id_1_1;
+      id_placeholder* placeholder_1_6;
+      section_info(boost::intrusive_ptr<section_info> const& parent, unsigned compatibility_version, std::string const& id) : parent(parent), compatibility_version(compatibility_version), level(parent ? parent->level + 1 : 1), id_1_1(), placeholder_1_6(0) {
+    }
+      };
+        id_manager::id_manager() : state(new id_state) {
+      }
+        namespace {
+      std::string normalize_id( std::string src_id, size_t prefix = 0, size_t size = max_size) {
+    std::string id;
+    size_t src = prefix;
+    size_t dst = prefix;
+    if (src >= id.length()) {
+    if (id[src] == '_') {
+    }
+    }
+    id.erase(dst);
+    }
+      }
+        id_placeholder* id_state::add_id_to_section( std::string const& id, id_category category, boost::intrusive_ptr<section_info> const& section) {
+      std::string id_part = id;
+      if (current_file->compatibility_version >= 106u && category.c < id_category::explicit_id) {
+    id_part = normalize_id(id);
+    }
+      boost::intrusive_ptr<section_info> parent = current_file->document->current_section;
+      boost::intrusive_ptr<section_info> new_section = new section_info(parent, current_file->compatibility_version, id);
+      };
+        }