stabilize build system: depends, installer, boost/bdb fixes, cross targets groundwork

depends/x86_64-pc-linux-gnu/include/boost/pending/detail/disjoint_sets.hpp

@@ -0,0 +1,88 @@
+//  (C) Copyright Jeremy Siek 2004 
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_DETAIL_DISJOINT_SETS_HPP
+#define BOOST_DETAIL_DISJOINT_SETS_HPP
+
+namespace boost {
+
+namespace detail {
+
+template <class ParentPA, class Vertex>
+Vertex
+find_representative_with_path_halving(ParentPA p, Vertex v)
+{ 
+  Vertex parent = get(p, v);
+  Vertex grandparent = get(p, parent);
+  while (parent != grandparent) {
+    put(p, v, grandparent);
+    v =  grandparent;
+    parent = get(p, v);
+    grandparent = get(p, parent); 
+  }
+  return parent;
+}
+
+template <class ParentPA, class Vertex>
+Vertex
+find_representative_with_full_compression(ParentPA parent, Vertex v)
+{
+  Vertex old = v;
+  Vertex ancestor = get(parent, v);
+  while (ancestor != v) {
+    v = ancestor;
+    ancestor = get(parent, v);
+  }
+  v = get(parent, old);
+  while (ancestor != v) {
+    put(parent, old, ancestor);
+    old = v;
+    v = get(parent, old);
+  }
+  return ancestor;
+}
+
+/* the postcondition of link sets is:
+ component_representative(i) == component_representative(j)
+ */
+template <class ParentPA, class RankPA, class Vertex, 
+          class ComponentRepresentative>
+inline void
+link_sets(ParentPA p, RankPA rank, Vertex i, Vertex j,
+          ComponentRepresentative comp_rep)
+{
+  i = comp_rep(p, i);
+  j = comp_rep(p, j);
+  if (i == j) return;
+  if (get(rank, i) > get(rank, j)) 
+    put(p, j, i);
+  else {
+    put(p, i, j);
+    if (get(rank, i) == get(rank, j)) 
+      put(rank, j, get(rank, j) + 1);
+  }
+}  
+
+// normalize components has the following postcondidition:
+// i >= p[i]
+// that is, the representative is the node with the smallest index in its class
+// as its precondition it it assumes that the node container is compressed
+
+template <class ParentPA, class Vertex>
+inline void
+normalize_node(ParentPA p, Vertex i)
+{
+  if (i > get(p,i) || get(p, get(p,i)) != get(p,i))   
+    put(p,i, get(p, get(p,i)));
+  else {
+    put(p, get(p,i), i);
+    put(p, i, i);
+  } 
+}
+
+  } // namespace detail
+} // namespace boost
+
+#endif // BOOST_DETAIL_DISJOINT_SETS_HPP

depends/x86_64-pc-linux-gnu/include/boost/pending/detail/int_iterator.hpp

@@ -0,0 +1,81 @@
+//  (C) Copyright Jeremy Siek 1999.
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_INT_ITERATOR_H
+#define BOOST_INT_ITERATOR_H
+
+#include <boost/iterator.hpp>
+#if !defined BOOST_MSVC
+#include <boost/operators.hpp>
+#endif
+#include <iostream>
+//using namespace std;
+
+#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+namespace boost {
+namespace iterators {
+#endif
+
+// this should use random_access_iterator_helper but I've had
+// VC++ portablility problems with that. -JGS
+template <class IntT>
+class int_iterator
+{
+  typedef int_iterator self;
+public:
+  typedef std::random_access_iterator_tag iterator_category;
+  typedef IntT value_type;
+  typedef IntT& reference;
+  typedef IntT* pointer;
+  typedef std::ptrdiff_t difference_type;
+
+  inline int_iterator() : _i(0) { }
+  inline int_iterator(IntT i) : _i(i) { }
+  inline int_iterator(const self& x) : _i(x._i) { }
+  inline self& operator=(const self& x) { _i = x._i; return *this; }
+  inline IntT operator*() { return _i; }
+  inline IntT operator[](IntT n) { return _i + n; }
+  inline self& operator++() { ++_i; return *this; }
+  inline self operator++(int) { self t = *this; ++_i; return t; }
+  inline self& operator+=(IntT n) { _i += n; return *this; }
+  inline self operator+(IntT n) { self t = *this; t += n; return t; }
+  inline self& operator--() { --_i; return *this; }
+  inline self operator--(int) { self t = *this; --_i; return t; }
+  inline self& operator-=(IntT n) { _i -= n; return *this; }
+  inline IntT operator-(const self& x) const { return _i - x._i; }
+  inline bool operator==(const self& x) const { return _i == x._i; }
+  // vc++ had a problem finding != in random_access_iterator_helper
+  // need to look into this... for now implementing everything here -JGS
+  inline bool operator!=(const self& x) const { return _i != x._i; }
+  inline bool operator<(const self& x) const { return _i < x._i; }
+  inline bool operator<=(const self& x) const { return _i <= x._i; }
+  inline bool operator>(const self& x) const { return _i > x._i; }
+  inline bool operator>=(const self& x) const { return _i >= x._i; }
+protected:
+  IntT _i;
+};
+
+template <class IntT>
+inline int_iterator<IntT>
+operator+(IntT n, int_iterator<IntT> t) { t += n; return t; }
+
+#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+} /* namespace iterators */
+
+using iterators::int_iterator;
+
+} /* namespace boost */
+#endif
+
+#ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
+namespace boost {
+using ::int_iterator;
+namespace iterators {
+using ::int_iterator;
+}}
+#endif
+
+
+#endif /* BOOST_INT_ITERATOR_H */

depends/x86_64-pc-linux-gnu/include/boost/pending/detail/property.hpp

@@ -0,0 +1,21 @@
+//  (C) Copyright Jeremy Siek 2004 
+//  Distributed under the Boost Software License, Version 1.0. (See
+//  accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_DETAIL_PROPERTY_HPP
+#define BOOST_DETAIL_PROPERTY_HPP
+
+#include <utility> // for std::pair
+#include <boost/type_traits/same_traits.hpp> // for is_same
+
+namespace boost {
+
+  namespace detail {
+
+    struct error_property_not_found { };
+
+  } // namespace detail 
+} // namespace boost
+
+#endif // BOOST_DETAIL_PROPERTY_HPP