add bfin ice

[ICEs.git] / 138653 / ice.ii.1

typedef unsigned int size_t;
	typedef struct _GObject {} GObject;
namespace std {
	struct input_iterator_tag {
	};
	struct forward_iterator_tag:public input_iterator_tag {
	};
	struct bidirectional_iterator_tag:public forward_iterator_tag {
	};
	struct random_access_iterator_tag:public bidirectional_iterator_tag {
	};
	 template < typename _Iterator > struct iterator_traits {
	};
	 template < typename _Tp > struct iterator_traits <_Tp * > {
		typedef random_access_iterator_tag iterator_category;
		typedef int difference_type;
	};
} 
namespace __gnu_cxx {
	using std::iterator_traits;
	 template < typename _Iterator,
	    typename _Container > class __normal_iterator {
	      protected:_Iterator _M_current;
	      public:typedef typename iterator_traits <
		    _Iterator >::
		    iterator_category iterator_category;
		typedef typename iterator_traits <
		    _Iterator >::difference_type difference_type;
		explicit __normal_iterator(const _Iterator &
					   __i):_M_current(__i) {
		} const _Iterator & base() const {
			return _M_current;
	}};
	template < typename _IteratorL, typename _IteratorR,
	    typename _Container > inline typename __normal_iterator <
	    _IteratorL,
	    _Container >::difference_type operator-(const __normal_iterator <
						    _IteratorL,
						    _Container > &__lhs,
						    const __normal_iterator <
						    _IteratorR,
						    _Container > &__rhs) {
		return __lhs.base() - __rhs.base();
	}
	namespace std {
		class exception {
		};
	} template < typename _Tp > class new_allocator {
	      public:typedef size_t size_type;
		typedef const _Tp *const_pointer;
		typedef const _Tp & const_reference;
		template < typename _Tp1 > struct rebind {
			typedef new_allocator < _Tp1 > other;
		};
	};
}

namespace std {
	template < typename _Tp >
	    class allocator:public __gnu_cxx::new_allocator < _Tp > {
	};
}

namespace NR {
	typedef double Coord;
	enum Dim2 {
		X = 0, Y
	};
} 
	extern double fabs(double __x) throw() __attribute__ ((__const__));
namespace NR {
	class Point {
	      public:inline Point() {
		} inline Coord operator[] (unsigned i)const {
	}};
}

namespace Inkscape {
	enum MessageType {
		NORMAL_MESSAGE, WARNING_MESSAGE, ERROR_MESSAGE,
		    INFORMATION_MESSAGE
	};
	namespace GC {
		enum ScanPolicy {
			SCANNED, ATOMIC
		};
		enum CollectionPolicy {
			AUTO, MANUAL
		};
		 template < ScanPolicy default_scan =
		    SCANNED, CollectionPolicy default_collect =
		    AUTO > class Managed {
		};
		class Finalized {
		      public:Finalized() {
		}};
		class Anchored {
		      protected:Anchored():_anchor(__null)
			{
		      } private:struct Anchor:public Managed < SCANNED,
			    MANUAL > {
			};
			mutable Anchor *_anchor;
		};
	}
	namespace UI {
		namespace View {
			class View:public GC::Managed <>, public GC::Finalized,
			    public GC::Anchored {
			};
}}} struct SPDesktop:public Inkscape::UI::View::View {
	double current_zoom() const {
}};
enum SPMarkerLoc {
	SP_CSS_UNIT_NONE, SP_CSS_UNIT_PX, SP_CSS_UNIT_PT, SP_CSS_UNIT_PC,
	    SP_CSS_UNIT_MM, SP_CSS_UNIT_CM, SP_CSS_UNIT_IN, SP_CSS_UNIT_EM,
	    SP_CSS_UNIT_EX, SP_CSS_UNIT_PERCENT
};
struct SPILengthOrNormal {
	unsigned unit:4;
	float value;
	float computed;
};
struct SPStyle {
	SPILengthOrNormal line_height;
};
namespace std {
	template < typename _Tp, typename _Alloc > struct _Vector_base {
		typedef typename _Alloc::template rebind <
		    _Tp >::other _Tp_alloc_type;
		struct _Vector_impl:public _Tp_alloc_type {
			_Tp *_M_start;
			_Tp *_M_finish;
		};
	      public:_Vector_impl _M_impl;
	};
      template < typename _Tp, typename _Alloc = std::allocator < _Tp > >class vector:protected _Vector_base < _Tp,
	    _Alloc >
	{
		typedef _Vector_base < _Tp, _Alloc > _Base;
		typedef vector < _Tp, _Alloc > vector_type;
		typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;
	      public:typedef _Tp value_type;
		typedef typename _Tp_alloc_type::const_pointer const_pointer;
		typedef typename _Tp_alloc_type::
		    const_reference const_reference;
		typedef __gnu_cxx::__normal_iterator < const_pointer,
		    vector_type > const_iterator;
		typedef size_t size_type;
		const_iterator begin() const {
			return const_iterator(this->_M_impl._M_start);
		} const_iterator end() const {
			return const_iterator(this->_M_impl._M_finish);
		} size_type size() const {
			return size_type(end() - begin());
		} const_reference operator[] (size_type __n) const {
	}};
}
struct SPObject:public GObject {
	SPStyle *style;
};
struct SPItem:public SPObject {
};
namespace Inkscape {
	namespace Text {
		class Layout {
		      public:class iterator;
			inline iterator begin() const;
			inline iterator end() const;
			inline unsigned lineIndex(iterator const &it) const;
			NR::Point characterAnchorPoint(iterator const &it)
			    const;
			struct CursorShape {
			} _empty_cursor_shape;
			struct Chunk;
			struct Glyph {
			};
			struct Character {
				inline Chunk const &chunk(Layout const *l) const {
			}};
			struct Chunk {
				unsigned in_line;
			};
			struct Line {
			};
			std::vector < Line > _lines;
			std::vector < Character > _characters;
			std::vector < Glyph > _glyphs;
			class PredicateLineToCharacter {
				Layout const *const _flow;
			      public:inline PredicateLineToCharacter(Layout const
								*flow):_flow
				    (flow) {
			}};
		};
		class Layout::iterator {
		      public:friend class Layout;
		      private:Layout const
			    *_parent_layout;
			int _glyph_index;
			unsigned _char_index;
			bool _cursor_moving_vertically;
			double _x_coordinate;
			inline iterator(Layout const *p, unsigned c,
					int g):_parent_layout(p),
			    _glyph_index(g), _char_index(c),
			    _cursor_moving_vertically(false),
			    _x_coordinate(0.0) {
		}};
		inline Layout::iterator Layout::end() const {
			return iterator(this, _characters.size(),
					_glyphs.size());
		} inline unsigned Layout::lineIndex(iterator const &it) const {
			return it._char_index ==
			    _characters.size()? _lines.size() -
			    1 : _characters[it._char_index].chunk(this).in_line;
}}};
Inkscape::Text::Layout const *te_get_layout(SPItem const *item)
{
}
void sp_te_adjust_linespacing_screen(SPItem * text,
				     Inkscape::Text::Layout::
				     iterator const &start,
				     Inkscape::Text::Layout::
				     iterator const &end, SPDesktop * desktop,
				     double by)
{
	Inkscape::Text::Layout const *layout = te_get_layout(text);
	SPStyle *style = (((SPObject *) (text))->style);
	unsigned line_count = layout->lineIndex(layout->end());
	double all_lines_height =
	    layout->characterAnchorPoint(layout->end())[NR::Y] -
	    layout->characterAnchorPoint(layout->begin())[NR::Y];
	double average_line_height =
	    all_lines_height / (line_count == 0 ? 1 : line_count);
	double zby =
	    by / (desktop->current_zoom() * (line_count == 0 ? 1 : line_count));
	switch (style->line_height.unit) {
	case SP_CSS_UNIT_NONE:
	default:
		if (fabs(style->line_height.computed) < 0.001)
			style->line_height.computed = by < 0.0 ? -0.001 : 0.001;
		else
			style->line_height.computed *=
			    (average_line_height + zby) / average_line_height;
	case SP_CSS_UNIT_EM:
	case SP_CSS_UNIT_EX:
	case SP_CSS_UNIT_PERCENT:
		if (fabs(style->line_height.value) < 0.001)
			style->line_height.value = by < 0.0 ? -0.001 : 0.001;
		else
			style->line_height.value *=
			    (average_line_height + zby) / average_line_height;
	}
}