X-Git-Url: https://git.wh0rd.org/?p=ICEs.git;a=blobdiff_plain;f=321197%2Fpyside.ii.6;fp=321197%2Fpyside.ii.6;h=783cc789aa0909feea8335b7135e048d48fd2a6e;hp=0000000000000000000000000000000000000000;hb=bd3239d2bbe0de3a200b266503e3330b1e391489;hpb=dbff64cb4b7530861c2309c794efdd4e0cf47a23

diff --git a/321197/pyside.ii.6 b/321197/pyside.ii.6
new file mode 100644
index 0000000..783cc78
--- /dev/null
+++ b/321197/pyside.ii.6
@@ -0,0 +1,179 @@
+class QString { public: inline QString(const char *ch); };
+class QGenericArgument {};
+class QWebPage {
+	public:
+	template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument);
+	class ExtensionOption {};
+};
+namespace boost {
+	namespace mpl {
+		template< bool C_ > struct bool_;
+		typedef bool_<false> false_;
+		template< bool C_ > struct bool_ {
+			static const bool value = C_;
+		};
+		template< typename T, T N > struct integral_c {
+			static const T value = N;
+		};
+	}
+	template <class T, T val> struct integral_constant
+ : public mpl::integral_c<T, val>
+ {};
+
+	namespace detail {
+		template <typename T> struct cv_traits_imp {};
+	}
+
+	template< typename T > struct is_reference : ::boost::integral_constant<bool,false> {};
+	template< typename T > struct remove_cv {
+		typedef typename boost::detail::cv_traits_imp<T*> type;
+	};
+	template< typename T > struct is_integral : ::boost::integral_constant<bool,false> {};
+	template< typename T > struct is_float : ::boost::integral_constant<bool,false> {};
+	namespace type_traits {
+		template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false> struct ice_or;
+		template <> struct ice_or<false, false, false, false, false, false, false> {
+			static const bool value = false;
+		};
+	}
+
+	namespace detail {
+		template< typename T > struct is_arithmetic_impl {
+			static const bool value = (::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_float<T>::value >::value);
+		};
+	}
+
+	template< typename T > struct is_arithmetic : ::boost::integral_constant<bool,::boost::detail::is_arithmetic_impl<T>::value> {};
+
+	namespace type_traits {
+		template <typename T> struct is_mem_fun_pointer_impl {
+			static const bool value = false;
+		};
+		template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true> struct ice_and;
+		template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7> struct ice_and {
+			static const bool value = false;
+		};
+		template <bool b> struct ice_not {
+			static const bool value = true;
+		};
+	}
+	template< typename T > struct is_member_function_pointer : ::boost::integral_constant<bool,::boost::type_traits::is_mem_fun_pointer_impl<typename remove_cv<T>::type>::value> {};
+	template< typename T > struct is_member_pointer : ::boost::integral_constant<bool,::boost::is_member_function_pointer<T>::value> {};
+
+	namespace detail {
+		template< typename T > struct is_pointer_helper {
+			static const bool value = false;
+		};
+		template< typename T > struct is_pointer_impl {
+			static const bool value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper<typename remove_cv<T>::type>::value , ::boost::type_traits::ice_not< ::boost::is_member_pointer<T>::value >::value >::value);
+		};
+	}
+	template< typename T > struct is_pointer : ::boost::integral_constant<bool,::boost::detail::is_pointer_impl<T>::value> {};
+
+	struct na {};
+
+	namespace mpl {
+		template< bool C , typename T1 , typename T2 > struct if_c { typedef T2 type; };
+
+		template< typename T1 = na , typename T2 = na , typename T3 = na > struct if_ {
+			private: typedef if_c< static_cast<bool>(T1::value) , T2 , T3 > almost_type_;
+			public: typedef typename almost_type_::type type;
+		};
+	}
+
+	namespace python {
+		template<typename T> class is_handle {
+			public: static const bool value = false;
+		};
+		namespace detail {
+			template<typename T> struct is_borrowed_ptr {
+				static const bool value = false;
+			};
+			template <class T> struct is_auto_ptr : mpl::false_ {};
+			template <class T> struct copy_ctor_mutates_rhs : is_auto_ptr<T> {};
+		}
+
+		namespace converter {
+			template <class T> struct rvalue_from_python_storage {};
+			template <class T> struct rvalue_from_python_data : rvalue_from_python_storage<T> { ~rvalue_from_python_data(); };
+
+			template <class> struct pyobject_traits;
+			template <class T> struct handle_object_manager_traits : pyobject_traits<typename T::element_type> {};
+			template <class T> struct default_object_manager_traits {
+				static const bool is_specialized = python::detail::is_borrowed_ptr<T>::value;
+			};
+
+			template <class T> struct object_manager_traits : mpl::if_c< is_handle<T>::value , handle_object_manager_traits<T> , default_object_manager_traits<T> >::type {};
+			template <class T> struct is_object_manager : mpl::bool_<object_manager_traits<T>::is_specialized> {};
+		}
+
+		class object;
+	}
+
+	namespace detail {
+		template <typename T, bool isp, bool b1> struct ct_imp { typedef const T& param_type; };
+	}
+
+	template <typename T> struct call_traits {
+		typedef typename boost::detail::ct_imp< T, ::boost::is_pointer<T>::value, ::boost::is_arithmetic<T>::value >::param_type param_type;
+	};
+
+	namespace python {
+		namespace converter {
+			template <class Ptr> struct extract_pointer {};
+			template <class Ref> struct extract_reference {};
+			template <class T> struct extract_rvalue {
+				typedef typename mpl::if_< python::detail::copy_ctor_mutates_rhs<T> , T& , typename call_traits<T>::param_type >::type result_type;
+				mutable rvalue_from_python_data<T> m_data;
+			};
+			template <class T> struct extract_object_manager {};
+			template <class T> struct select_extract {
+				static const bool obj_mgr = is_object_manager<T>::value;
+				static const bool ptr = is_pointer<T>::value;
+				static const bool ref = is_reference<T>::value;
+				typedef typename mpl::if_c< obj_mgr , extract_object_manager<T> , typename mpl::if_c< ptr , extract_pointer<T> , typename mpl::if_c< ref , extract_reference<T> , extract_rvalue<T> >::type >::type >::type type;
+			};
+		}
+		template <class T> struct extract : converter::select_extract<T>::type {
+			private: typedef typename converter::select_extract<T>::type base;
+			public: typedef typename base::result_type result_type;
+			operator result_type() const {}
+			extract(object const&);
+		};
+	}
+}
+struct QHashData {
+	static QHashData shared_null;
+};
+template <class Key, class T> class QHash {
+	public: inline QHash() { }
+	T &operator[](const Key &key);
+};
+	class type_details {
+		typedef QGenericArgument(*func_python_to_cpp_type)(const boost::python::object&, const char*);
+		public: template<typename T> static type_details* create_object_type_details(const char* type_name) {}
+
+		template<typename T> static type_details* create_value_type_details(const char* type_name) {
+			type_details* self = new type_details();
+			self->m_func_python_to_cpp = &python_to_value_type<T>;
+		}
+		func_python_to_cpp_type m_func_python_to_cpp;
+		template <class T> static QGenericArgument python_to_value_type(const boost::python::object& obj, const char *type_name) {
+			T* val = new T(boost::python::extract<T>(obj));
+		}
+	};
+
+	class type_manager {
+		public: static type_manager& instance();
+		template<typename T> void register_value_type(const char* type_name) {
+			m_type_map[type_name] = type_details::create_value_type_details<T>(type_name);
+		}
+		QHash<QString, type_details* > m_type_map;
+	};
+class qwebpage_extensionoption_wrapper
+{
+static void define_python_class();
+};
+void qwebpage_extensionoption_wrapper::define_python_class() {
+type_manager::instance().register_value_type<QWebPage::ExtensionOption >("QWebPage::ExtensionOption");
+}