--- /dev/null
+typedef int _Atomic_word;
+typedef long unsigned int size_t;
+namespace __gnu_cxx {
+ template < typename _Tp > class new_allocator {
+ public:typedef const _Tp *const_pointer;
+ typedef _Tp & reference;
+ };
+ static _Atomic_word __exchange_and_add_dispatch(_Atomic_word * __mem,
+ int __val) {
+ }
+}
+
+namespace std {
+ template < typename _CharT > struct char_traits;
+ class exception {
+ public:exception() throw() {
+ } virtual ~ exception() throw();
+ };
+ class bad_cast:public exception {
+ };
+ template < typename _Tp > class allocator:public __gnu_cxx::new_allocator < _Tp >
+ {
+ public:template < typename _Tp1 > struct rebind {
+ typedef allocator < _Tp1 > other;
+ };
+ };
+ template < typename _CharT, typename _Traits =
+ char_traits < _CharT >, typename _Alloc =
+ allocator < _CharT > >class basic_string;
+ typedef basic_string < char >string;
+ template < typename _CharT, typename _Traits,
+ typename _Alloc > class basic_string {
+ typedef typename _Alloc::template rebind <
+ _CharT >::other _CharT_alloc_type;
+ typedef _Alloc allocator_type;
+ typedef typename _CharT_alloc_type::reference reference;
+ private:struct _Rep_base {
+ _Atomic_word _M_refcount;
+ };
+ struct _Rep:_Rep_base {
+ _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 {
+ } 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 {
+ }};
+ 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 boost {
+ template < class T > class scoped_ptr {
+ private:T * px;
+ public:typedef T element_type;
+ explicit scoped_ptr(T * p = 0):px(p) {
+ }};
+ 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;
+ };
+ struct section_info;
+ 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;
+ };
+ 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 §ion);
+ };
+ 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) {
+ std::string id;
+ size_t src;
+ size_t dst;
+ 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 §ion) {
+ 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);
+ };
+}
git.wh0rd.org / ICEs.git / blobdiff