diff --git a/autowiring/AutoPacket.h b/autowiring/AutoPacket.h
index 5b689b279..3ee4e218b 100644
--- a/autowiring/AutoPacket.h
+++ b/autowiring/AutoPacket.h
@@ -22,6 +22,7 @@
 #include EXCEPTION_PTR_HEADER
 
 class AutoPacket;
+class AutoPacketInternal;
 class AutoPacketFactory;
 class AutoPacketProfiler;
 struct AutoFilterDescriptor;
@@ -47,6 +48,7 @@ class AutoPacket:
   AutoPacket(AutoPacket&&) = delete;
 
 public:
+  // Must hold the lock to 'factory' when calling this constructor
   AutoPacket(AutoPacketFactory& factory, std::shared_ptr<void>&& outstanding);
   ~AutoPacket();
 
@@ -58,9 +60,12 @@ class AutoPacket:
 protected:
   // A pointer back to the factory that created us. Used for recording lifetime statistics.
   const std::shared_ptr<AutoPacketFactory> m_parentFactory;
+  
+  // The successor to this packet
+  std::shared_ptr<AutoPacketInternal> m_successor;
 
   // Hold the time point at which this packet was last initalized.
-  const std::chrono::high_resolution_clock::time_point m_initTime;
+  std::chrono::high_resolution_clock::time_point m_initTime;
 
   // Outstanding count local and remote holds:
   const std::shared_ptr<void> m_outstanding;
@@ -507,6 +512,12 @@ class AutoPacket:
     return GetSubscribers(typeid(auto_id<T>));
   }
 
+  /// <returns>All decoration dispositions</returns>
+  /// <remarks>
+  /// This method is useful for getting a picture of the entire disposition graph
+  /// </remarks>
+  std::list<DecorationDisposition> GetDispositions() const;
+
   /// <returns>All decoration dispositions associated with the data type</returns>
   /// <remarks>
   /// This method is useful for determining whether flow conditions (broadcast, pipes
@@ -517,6 +528,12 @@ class AutoPacket:
     return GetDispositions(typeid(auto_id<T>));
   }
 
+  /// <summary>
+  /// Returns the next packet that will be issued by the packet factory in this context relative to this context
+  /// </summary>
+  std::shared_ptr<AutoPacketInternal> SuccessorInternal(void);
+  std::shared_ptr<AutoPacket> Successor(void);
+  
   /// <returns>True if the indicated type has been requested for use by some consumer</returns>
   template<class T>
   bool HasSubscribers(void) const {
diff --git a/autowiring/AutoPacketFactory.h b/autowiring/AutoPacketFactory.h
index 85b95af78..a29b7b66f 100644
--- a/autowiring/AutoPacketFactory.h
+++ b/autowiring/AutoPacketFactory.h
@@ -16,6 +16,7 @@ struct AdjacencyEntry;
 class AutoPacketFactory;
 class Deferred;
 class DispatchQueue;
+class AutoPacketInternal;
 
 /// <summary>
 /// A configurable factory class for pipeline packets with a built-in object pool
@@ -40,15 +41,12 @@ class AutoPacketFactory:
   
   // State change notification
   std::condition_variable m_stateCondition;
-  
-  // Have we been signaled to stop
-  bool m_wasStopped;
-
-  // Outstanding reference if this factory is currently running:
-  std::shared_ptr<Object> m_outstanding;
 
   // Internal outstanding reference for issued packet:
   std::weak_ptr<void> m_outstandingInternal;
+  
+  // The last packet issued from this factory
+  std::shared_ptr<AutoPacketInternal> m_nextPacket;
 
   // Collection of known subscribers
   typedef std::unordered_set<AutoFilterDescriptor, std::hash<AutoFilterDescriptor>> t_autoFilterSet;
@@ -79,11 +77,9 @@ class AutoPacketFactory:
   }
 
   // CoreRunnable overrides:
-  bool Start(std::shared_ptr<Object> outstanding) override;
-  void Stop(bool graceful = false) override;
-  void Wait(void) override;
-  bool IsRunning(void) const override { return m_outstanding && !m_wasStopped; };
-  bool ShouldStop(void) const override { return m_wasStopped; };
+  bool OnStart(void) override;
+  void OnStop(bool graceful) override;
+  void DoAdditionalWait(void) override;
 
   /// <summary>
   /// Causes this AutoPacketFactory to release all of its packet subscribers
@@ -134,8 +130,10 @@ class AutoPacketFactory:
   /// </summary>
   std::shared_ptr<AutoPacket> NewPacket(void);
 
+  std::shared_ptr<AutoPacketInternal> ConstructPacket(void);
+
   /// <returns>the number of outstanding AutoPackets</returns>
-  size_t GetOutstanding(void) const;
+  size_t GetOutstandingPacketCount(void) const;
 
   /// <summary>
   /// Called by each AutoPacket's Finalize method to allow the factory
diff --git a/autowiring/AutoPacketGraph.h b/autowiring/AutoPacketGraph.h
new file mode 100644
index 000000000..cc29f67ce
--- /dev/null
+++ b/autowiring/AutoPacketGraph.h
@@ -0,0 +1,122 @@
+// Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
+#pragma once
+#include "AutoFilterDescriptor.h"
+#include "AutoPacket.h"
+#include "AutoPacketFactory.h"
+#include "Autowired.h"
+#include "AutowiringEvents.h"
+#include "CoreRunnable.h"
+#include STL_UNORDERED_MAP
+
+
+/// <summary>
+/// Represents an edge in the graph from a type to an AutoFilter
+/// </summary>
+struct DeliveryEdge
+{
+  // The type info
+  const std::type_info* type_info;
+  
+  // The AutoFilterDescriptor
+  AutoFilterDescriptor descriptor;
+  
+  // Specifies if the argument is an input (type -> descriptor) or output (descriptor -> type)
+  bool input;
+  
+  // For the unordered map/hash comparison
+  bool operator==(const DeliveryEdge& rhs) const {
+    return
+      type_info == rhs.type_info &&
+      descriptor == rhs.descriptor &&
+      input == rhs.input;
+  }
+};
+
+/// <summary>
+/// Using the same hash function as the AutoFilterDescriptor
+/// </summary>
+namespace std {
+  template<>
+  struct hash<DeliveryEdge>
+  {
+    size_t operator()(const DeliveryEdge& edge) const {
+      return (size_t) edge.descriptor.GetAutoFilter()->ptr();
+    }
+  };
+}
+
+/// <summary>
+/// Graphical visualization of AutoPackets
+/// </summary>
+class AutoPacketGraph:
+  public AutowiringEvents,
+  public CoreRunnable
+{
+public:
+  AutoPacketGraph();
+  
+  typedef std::unordered_map<DeliveryEdge, size_t, std::hash<DeliveryEdge>> t_deliveryEdges;
+  
+protected:
+  // A mapping of an edge to the number of times it was delivered
+  t_deliveryEdges m_deliveryGraph;
+  
+  // A lock for this type
+  mutable std::mutex m_lock;
+  
+  // Reference to the AutoPacketFactory
+  AutoRequired<AutoPacketFactory> m_factory;
+  
+  /// <summary>
+  /// Demangle a type name as well as stripping "auto_in< >"
+  /// </summary>
+  /// <remarks>
+  /// The ">" that encloses the templates will have extra spaces between them, for instance
+  ///
+  ///    auto_in<Class>
+  ///    auto_in<Class<T> >
+  ///    auto_in<Class1<Class2, Class3<Class4> > >
+  ///
+  /// All we care about is matching "^auto_in<(.*)>$"
+  /// </remarks>
+  std::string DemangleTypeName(const std::type_info* type_info) const;
+  
+  /// <summary>
+  /// Scan all of the objects and add any AutoFilter's from all of the objects in a system.
+  /// </summary>
+  /// <remarks>
+  /// This function will scan all of the objects (and rescan) and only add new edges to our graph.
+  /// </remarks>
+  void LoadEdges();
+  
+  /// <summary>
+  /// Record the delivery of a packet and increment the number of times the packet has been delivered
+  /// </summary>
+  void RecordDelivery(const std::type_info* ti, const AutoFilterDescriptor& descriptor, bool input);
+  
+  /// AutowiringEvents overrides
+  virtual void NewContext(CoreContext&) override {}
+  virtual void ExpiredContext(CoreContext&) override {}
+  virtual void EventFired(CoreContext&, const std::type_info&) override {}
+  virtual void NewObject(CoreContext&, const ObjectTraits&) override;
+  
+  /// CoreRunnable overrides
+  virtual bool OnStart(void) override;
+  
+public:
+  /// <summary>
+  /// Get a copy of the packet via AutoFilter
+  /// </summary>
+  void AutoFilter(AutoPacket& packet);
+  
+  /// <summary>
+  /// Write the graph to a file in graphviz format
+  /// </summary>
+  /// <param name="filename">
+  /// The name of the file to write the graph to
+  /// </param>
+  /// <param name="numPackets">
+  /// Include the number of times the packet was delivered
+  /// </param>
+  bool WriteGV(const std::string& filename, bool numPackets = false) const;
+};
diff --git a/autowiring/AutoRestarter.h b/autowiring/AutoRestarter.h
index 61cfd26a8..32cd41a34 100644
--- a/autowiring/AutoRestarter.h
+++ b/autowiring/AutoRestarter.h
@@ -52,7 +52,7 @@ class AutoRestarter:
   const AutoRestarterConfig config;
 
   // CoreRunnable overrides:
-  bool Start(std::shared_ptr<Object> outstanding) override {
+  bool OnStart() override {
     // Start the enclosed context, do nothing else
     auto ctxt = GetContext();
     if(ctxt && config.startWhenCreated)
@@ -60,13 +60,10 @@ class AutoRestarter:
     return true;
   }
 
-  void Stop(bool graceful) override {
+  void OnStop(bool graceful) override {
     std::lock_guard<std::mutex> lk(m_lock);
     m_context.reset();
   }
-  bool IsRunning(void) const override { return false; }
-  bool ShouldStop(void) const override { return true; }
-  void Wait(void) override {}
 
 private:
   mutable std::mutex m_lock;
@@ -84,21 +81,13 @@ class AutoRestarter:
     // Parent restarter, we hand control here when we're stopped
     AutoRestarter<Sigil>& ar;
 
-    bool Start(std::shared_ptr<Object> outstanding) override {
-      m_outstanding = outstanding;
+    bool OnStart(void) override {
       return true;
     }
 
-    void Stop(bool graceful) override {
+    void OnStop(bool graceful) override {
       ar.OnContextStopped(*this);
-      m_outstanding.reset();
     }
-
-    std::shared_ptr<Object> m_outstanding;
-
-    bool IsRunning(void) const override { return false; }
-    bool ShouldStop(void) const override { return false; }
-    void Wait(void) {}
   };
 
 protected:
diff --git a/autowiring/Autowired.h b/autowiring/Autowired.h
index e80e7da05..f5c8f0887 100644
--- a/autowiring/Autowired.h
+++ b/autowiring/Autowired.h
@@ -261,10 +261,14 @@ class AutowiredFast:
 
   // !!!!! Read comment in AutoRequired if you get a compiler error here !!!!!
   AutowiredFast(const std::shared_ptr<CoreContext>& ctxt = CoreContext::CurrentContext()) {
-    if(ctxt)
+    if (ctxt)
       ctxt->FindByTypeRecursive(*this);
   }
 
+  AutowiredFast(const CoreContext* pCtxt) {
+    pCtxt->FindByTypeRecursive(*this);
+  }
+
   operator bool(void) const {
     return IsAutowired();
   }
diff --git a/autowiring/BasicThread.h b/autowiring/BasicThread.h
index dca27dcdc..2a2eb6cfb 100644
--- a/autowiring/BasicThread.h
+++ b/autowiring/BasicThread.h
@@ -167,11 +167,6 @@ class BasicThread:
   /// </remarks>
   bool ThreadSleep(std::chrono::nanoseconds timeout);
 
-public:
-  // Accessor methods:
-  bool ShouldStop(void) const override;
-  bool IsRunning(void) const override;
-
   /// <summary>
   /// Causes a new thread to be created in which the Run method will be invoked
   /// </summary>
@@ -181,8 +176,13 @@ class BasicThread:
   /// Start will not be called from more than one place on the same object.  The thread
   /// will be invoked from the context which was active at the time the thread was created.
   /// </remarks>
-  virtual bool Start(std::shared_ptr<Object> outstanding);
+  bool OnStart() override;
+
+  void OnStop(bool graceful) override;
 
+  void DoAdditionalWait() override;
+
+public:
   /// <summary>
   /// Begins the core thread
   /// </summary>
@@ -194,45 +194,15 @@ class BasicThread:
   virtual void Run() = 0;
 
   /// <summary>
-  /// Waits until the core thread is launched and then terminates
-  /// </summary>
-  /// <remarks>
-  /// Unlike Join, this method may be invoked even if the CoreThread isn't running
-  /// </remarks>
-  void Wait(void) override;
-
-  /// <summary>
-  /// Timed version of Wait
+  /// Provides derived members with a way of obtaining notification that this thread is being stopped
   /// </summary>
-  /// <returns>False if the timeout elapsed, true otherwise</returns>
-  bool WaitFor(std::chrono::nanoseconds duration);
-
-  /// <summary>
-  /// Timed version of Wait
-  /// </summary>
-  /// <returns>False if the timeout elapsed, true otherwise</returns>
-  template<class TimeType>
-  bool WaitUntil(TimeType timepoint);
-
-  /// <summary>
-  /// Event which may be used to perform custom handling when the thread is told to stop
-  /// </summary>
-  /// <param name="graceful">Set to true to rundown the dispatch queue before quitting</param>
   /// <remarks>
-  /// This method is called when the thread should stop.  When invoked, the value of
-  /// CoreThread::ShouldStop is guaranteed to be true.
-  ///
-  /// Callers are not required to call CoreThread::OnStop.  This method is guaranteed to do
-  /// nothing by default.
+  /// Callers must not perform any time-consuming operations in this callback; the method may be called
+  /// from a time-sensitive context and unacceptable system performance could result if long-duration
+  /// operations are undertaken here.
   /// </remarks>
   virtual void OnStop(void) {}
 
-  /// <summary>
-  /// This is an override method that will cause ShouldStop to return true,
-  /// regardless of what the global stop setting is.
-  /// </summary>
-  virtual void Stop(bool graceful = false);
-
   /// <summary>
   /// Forces all Autowiring threads to reidentify themselves
   /// </summary>
diff --git a/autowiring/C++11/boost_future.h b/autowiring/C++11/boost_future.h
index 4d655f877..e235a759c 100644
--- a/autowiring/C++11/boost_future.h
+++ b/autowiring/C++11/boost_future.h
@@ -9,10 +9,10 @@
 #include <boost/thread/future.hpp>
 
 namespace std {
-  using boost::future;
-  using boost::future_status;
-  using boost::promise;
-  using boost::future_error;
-  using boost::async;
-  using boost::launch;
+  using AUTOWIRING_BOOST_NAME::future;
+  using AUTOWIRING_BOOST_NAME::future_status;
+  using AUTOWIRING_BOOST_NAME::promise;
+  using AUTOWIRING_BOOST_NAME::future_error;
+  using AUTOWIRING_BOOST_NAME::async;
+  using AUTOWIRING_BOOST_NAME::launch;
 }
diff --git a/autowiring/C++11/cpp11.h b/autowiring/C++11/cpp11.h
index fd79f29c4..0c7e4ea4d 100644
--- a/autowiring/C++11/cpp11.h
+++ b/autowiring/C++11/cpp11.h
@@ -15,6 +15,14 @@
   #define STL11_ALLOWED 1
 #endif
 
+// If Autowiring is currently being built, we want to use the "autoboost" namespace in order to
+// avoid requiring a dependency on Boost.
+#ifdef AUTOWIRING_IS_BEING_BUILT
+  #define AUTOWIRING_BOOST_NAME autoboost
+#else
+  #define AUTOWIRING_BOOST_NAME boost
+#endif
+
 #define IS_CLANG defined(__clang_major__)
 #define CLANG_CHECK(maj, min) (__clang_major__ == maj && __clang_minor__ >= min || __clang_major__ > maj)
 #define GCC_CHECK(maj, min) (__GNUC__ == maj && __GNUC_MINOR__  >= min || __GNUC__ > maj)
diff --git a/autowiring/CoreContext.h b/autowiring/CoreContext.h
index 0797f3167..2c5ab10d2 100644
--- a/autowiring/CoreContext.h
+++ b/autowiring/CoreContext.h
@@ -106,6 +106,25 @@ class CoreContext:
   /// </summary>
   static std::shared_ptr<CoreContext> GetGlobal(void);
 
+  /// <summary>
+  /// Represents a single entry, together with any deferred elements waiting on the satisfaction of this entry
+  /// </summary>
+  struct MemoEntry {
+    MemoEntry(void) :
+      pFirst(nullptr)
+    {}
+
+    // The first deferrable autowiring which requires this type, if one exists:
+    DeferrableAutowiring* pFirst;
+
+    // A back reference to the concrete type from which this memo was generated:
+    const ObjectTraits* pObjTraits;
+
+    // Once this memo entry is satisfied, this will contain the AnySharedPointer instance that performs
+    // the satisfaction
+    AnySharedPointer m_value;
+  };
+
 protected:
   // A pointer to the parent context
   const std::shared_ptr<CoreContext> m_pParent;
@@ -115,6 +134,9 @@ class CoreContext:
 
   // State block for this context:
   std::unique_ptr<CoreContextStateBlock> m_stateBlock;
+  
+  // Set if a thread is added and needs to be run
+  bool m_beforeRunning;
 
   // Set if threads in this context should be started when they are added
   bool m_initiated;
@@ -130,22 +152,6 @@ class CoreContext:
   typedef std::unordered_map<std::type_index, std::list<BoltBase*>> t_contextNameListeners;
   t_contextNameListeners m_nameListeners;
 
-  /// <summary>
-  /// Represents a single entry, together with any deferred elements waiting on the satisfaction of this entry
-  /// </summary>
-  struct MemoEntry {
-    MemoEntry(void) :
-      pFirst(nullptr)
-    {}
-
-    // The first deferrable autowiring which requires this type, if one exists:
-    DeferrableAutowiring* pFirst;
-
-    // Once this memo entry is satisfied, this will contain the AnySharedPointer instance that performs
-    // the satisfaction
-    AnySharedPointer m_value;
-  };
-
   /// <summary>
   /// A proxy context member that knows how to create a factory for a particular type
   /// </summary>
@@ -254,7 +260,7 @@ class CoreContext:
   /// <summary>
   /// Invokes all deferred autowiring fields, generally called after a new member has been added
   /// </summary>
-  void UpdateDeferredElements(std::unique_lock<std::mutex>&& lk, const std::shared_ptr<Object>& entry);
+  void UpdateDeferredElements(std::unique_lock<std::mutex>&& lk, const ObjectTraits& entry);
 
   /// <summary>
   /// Adds the named event receiver to the collection of known receivers
@@ -387,6 +393,18 @@ class CoreContext:
   template<class Factory>
   void RegisterFactory(const Factory&, autowiring::member_new_type<Factory, autowiring::factorytype::none>) {}
 
+  // Internal resolvers, used to determine which teardown style the user would like to use
+  template<class Fx>
+  void AddTeardownListener2(Fx&& fx, void (Fx::*)(void)) { TeardownNotifier::AddTeardownListener(fx); }
+
+  template<class Fx>
+  void AddTeardownListener2(Fx&& fx, void (Fx::*)(const CoreContext&)) { TeardownNotifier::AddTeardownListener([fx, this] () mutable { fx(*this); }); }
+  template<class Fx>
+  void AddTeardownListener2(Fx&& fx, void (Fx::*)(void) const) { TeardownNotifier::AddTeardownListener(fx); }
+
+  template<class Fx>
+  void AddTeardownListener2(Fx&& fx, void (Fx::*)(const CoreContext&) const) { TeardownNotifier::AddTeardownListener([fx, this] () mutable { fx(*this); }); }
+
 public:
   // Accessor methods:
   bool IsGlobalContext(void) const { return !m_pParent; }
@@ -412,6 +430,19 @@ class CoreContext:
   /// </returns>
   std::shared_ptr<CoreContext> NextSibling(void) const;
 
+  /// <returns>
+  /// The type identifier of the specified type identifier
+  /// </returns>
+  /// <remarks>
+  /// The returned type structure will be the actual type of the specified object as defined at the time of
+  /// injection.  In the case of a static factory new or AutoFactory new, this type will be the type of the
+  /// interface.  All other members are the concrete type actually injected, as opposed to the type unifier
+  /// for that type.
+  ///
+  /// This method will throw an exception if the passed shared pointer is not strictly a member of this context
+  /// </remarks>
+  const std::type_info& GetAutoTypeId(const AnySharedPointer& ptr) const;
+
   /// <summary>
   /// Creation helper routine
   /// </summary>
@@ -490,15 +521,21 @@ class CoreContext:
     // Add this type to the TypeRegistry
     (void) RegType<T>::r;
 
-    // First see if the object has already been injected:
-    std::shared_ptr<typename CreationRules::TActual> retVal;
-    FindByType(retVal);
-    if(retVal)
-      return std::static_pointer_cast<T>(retVal);
+    // First see if the base object type has already been injected.  This is also necessary to
+    // ensure that a memo slot is created for the type by itself, in cases where the injected
+    // member does not inherit Object and this member is eventually satisfied by one that does.
+    {
+      std::shared_ptr<T> pure;
+      FindByType(pure);
+      if (pure)
+        return pure;
+    }
 
     // We must make ourselves current for the remainder of this call:
     CurrentContextPusher pshr(shared_from_this());
-    retVal.reset(CreationRules::New(*this, std::forward<Args>(args)...));
+    std::shared_ptr<typename CreationRules::TActual> retVal(
+      CreationRules::New(*this, std::forward<Args>(args)...)
+    );
 
     // AutoInit if sensible to do so:
     CallAutoInit(*retVal, has_autoinit<T>());
@@ -911,6 +948,14 @@ class CoreContext:
     return searchFn.resultSlot;
   }
 
+  /// <summary>
+  /// Adds a teardown notifier which receives a pointer to this context on destruction
+  /// </summary>
+  template<class Fx>
+  void AddTeardownListener(Fx&& fx) {
+    AddTeardownListener2<Fx>(std::forward<Fx&&>(fx), &Fx::operator());
+  }
+
   /// <summary>
   /// Unregisters a slot as a recipient of potential autowiring
   /// </summary>
diff --git a/autowiring/CoreJob.h b/autowiring/CoreJob.h
index 774ef6b34..12147485f 100644
--- a/autowiring/CoreJob.h
+++ b/autowiring/CoreJob.h
@@ -3,7 +3,6 @@
 #include "ContextMember.h"
 #include "DispatchQueue.h"
 #include "CoreRunnable.h"
-#include FUTURE_HEADER
 
 class Object;
 
@@ -14,20 +13,14 @@ class CoreJob:
 {
 public:
   CoreJob(const char* name = nullptr);
-  virtual ~CoreJob(){};
+  virtual ~CoreJob(void);
 
 private:
-  // Hold on to this so CoreContext knows we still exist
-  std::shared_ptr<Object> m_outstanding;
-
   // Flag, set to true when it's time to start dispatching
   bool m_running;
 
-  // Flag, set to stop when we should stop running
-  bool m_shouldStop;
-
   // The current outstanding async in the thread pool, if one exists:
-  std::future<void> m_curEvent;
+  void* m_curEvent;
 
   // Flag, indicating whether curEvent is in a teardown pathway.  This
   // flag is highly stateful.
@@ -46,13 +39,8 @@ class CoreJob:
   void Abort(void);
 
 public:
-  // Accessor methods:
-  bool ShouldStop(void) const override { return m_shouldStop; }
-
   // "CoreRunnable" overrides
-  bool Start(std::shared_ptr<Object> outstanding) override;
-  void Stop(bool graceful) override;
-  bool IsRunning(void) const override { return m_running; }
-  void Wait(void) override;
-  bool WaitFor(std::chrono::nanoseconds duration);
+  bool OnStart(void) override;
+  void OnStop(bool graceful) override;
+  void DoAdditionalWait(void) override;
 };
diff --git a/autowiring/CoreRunnable.h b/autowiring/CoreRunnable.h
index 53cc712b3..2ca0f5761 100644
--- a/autowiring/CoreRunnable.h
+++ b/autowiring/CoreRunnable.h
@@ -1,6 +1,7 @@
 // Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
 #pragma once
 #include MEMORY_HEADER
+#include MUTEX_HEADER
 
 class Object;
 
@@ -9,15 +10,70 @@ class CoreRunnable {
   CoreRunnable(void);
   virtual ~CoreRunnable(void);
   
+private:
+  // Set to true if this runnable was ever signaled to start
+  bool m_wasStarted;
+
+  // Set to true if this runnable should terminate processing
+  bool m_shouldStop;
+
+  // The outstanding count, held for as long as processing is underway
+  std::shared_ptr<Object> m_outstanding;
+
+protected:
+  std::mutex m_lock;
+  std::condition_variable m_cv;
+
+  /// <returns>
+  /// A reference to the current outstanding counter
+  /// </returns>
+  const std::shared_ptr<Object>& GetOutstanding(void) const;
+
+  /// <summary>
+  /// Method invoked from Start when this class is being asked to begin processing
+  /// </summary>
+  /// <returns>True if processing has started, false otherwise</returns>
+  /// <remarks>
+  /// This method will be called at most once.  Returning false from this method will result in an immediate invocation
+  /// of the OnStop(false).
+  /// </remarks>
+  virtual bool OnStart(void) { return false; };
+
+  /// <summary>
+  /// Invoked by the base class when a Stop call has been made
+  /// </summary>
+  /// <remarks>
+  /// This method will be called at most once. 
+  /// </remarks>
+  virtual void OnStop(bool graceful) {};
+
+  /// <summary>
+  /// Invoked by the base class when a Wait call has been made, to ensure all cleanups have happened after the Stop call
+  /// </summary>
+  /// <remarks>
+  /// This call should not block for extended periods of time.
+  /// </remarks>
+  virtual void DoAdditionalWait() {};
+
+public:
+  // Accessor methods:
+  bool IsRunning(void) const { return (bool)m_outstanding; }
+  bool WasStarted(void) const { return m_wasStarted; }
+  bool ShouldStop(void) const { return m_shouldStop; }
+
   /// <summary>
   /// Causes this runnable to begin processing
   /// </summary>
+  /// <returns>This method always returns true</returns>
   /// <remarks>
   /// It is an error to call this routine more than once.  The passed outstanding shared pointer
   /// is used to keep tracking of number of simultaneous runnables outstanding.  This routine may
   /// be called even after Stop has been called; the caller MUST return false in this case.
+  ///
+  /// Callers should strongly prefer not to override Start if possible.  Instead, override OnStart and
+  /// obtain an instance of the outstanding pointer via GetOutstanding
   /// </remarks>
-  virtual bool Start(std::shared_ptr<Object> outstanding) = 0;
+  virtual bool Start(std::shared_ptr<Object> outstanding);
 
   /// <summary>
   /// Stops this runnable, optionally performing graceful cleanup if requested
@@ -26,20 +82,21 @@ class CoreRunnable {
   /// On return of this method, regardless of the return value, a subsequent call to Wait is
   /// guaranteed to either return immediately, or once the thread implementation completes.
   /// </remarks>
-  virtual void Stop(bool graceful) = 0;
+  void Stop(bool graceful = true);
 
-  /// <returns>
-  /// True if this runnable is currently running
-  /// </returns>
-  virtual bool IsRunning(void) const = 0;
+  /// <summary>
+  /// Waits for this object to start running, and then stop running
+  /// </summary>
+  void Wait(void);
 
-  /// <returns>
-  /// True if this runnable has been told to stop
-  /// </returns>
-  virtual bool ShouldStop(void) const = 0;
+  /// <summary>
+  /// Waits for this object to start running, and then stop running
+  /// </summary>
+  bool WaitFor(std::chrono::nanoseconds timeout);
 
   /// <summary>
   /// Waits for this object to start running, and then stop running
   /// </summary>
-  virtual void Wait(void) = 0;
+  template<typename TimeType>
+  bool WaitUntil(TimeType timepoint);
 };
diff --git a/autowiring/CoreThread.h b/autowiring/CoreThread.h
index c98969505..366f3796b 100644
--- a/autowiring/CoreThread.h
+++ b/autowiring/CoreThread.h
@@ -64,7 +64,20 @@ class CoreThread:
   /// The default implementation of Run will simply call WaitForEvent in a loop until it's
   /// told to quit.
   /// </remarks>
-  virtual void Run() override;
+  void Run(void) override;
+
+  /// <summary>
+  /// Provides derived members with a way of obtaining notification that this thread is being stopped
+  /// </summary>
+  /// <remarks>
+  /// This method is called before the dispatch queue is aborted or run down.  Users wishing to perform
+  /// operations gracefully during termination should pend these operations as lambdas to the thread's
+  /// dispatch queue; these lambdas will be invoked if graceful termination is requested, and destroyed
+  /// without invocation otherwise.
+  ///
+  /// The base implementation of this method is guaranteed to do nothing.
+  /// </remarks>
+  virtual void OnStop(void) {}
 
   /// <summary>
   /// Event which may be used to perform custom handling when the thread is told to stop
@@ -74,8 +87,8 @@ class CoreThread:
   /// This method is called when the thread should stop.  When invoked, the value of
   /// CoreThread::ShouldStop is guaranteed to be true.
   ///
-  /// Callers are not required to call CoreThread::OnStop.  This method is guaranteed to do
+  /// Derived classes are not required to call CoreThread::OnStop.  This method is guaranteed to do
   /// nothing by default.
   /// </remarks>
-  virtual void Stop(bool graceful = false) override;
+  void OnStop(bool graceful) override final;
 };
diff --git a/autowiring/DecorationDisposition.h b/autowiring/DecorationDisposition.h
index 0eb2c3c37..7c10d45a3 100644
--- a/autowiring/DecorationDisposition.h
+++ b/autowiring/DecorationDisposition.h
@@ -46,6 +46,7 @@ struct DecorationDisposition
     m_type(source.m_type),
     m_pImmediate(source.m_pImmediate),
     m_publisher(source.m_publisher),
+    m_subscribers(source.m_subscribers),
     isCheckedOut(source.isCheckedOut),
     satisfied(source.satisfied)
   {}
@@ -54,6 +55,7 @@ struct DecorationDisposition
     m_type = source.m_type;
     m_pImmediate = source.m_pImmediate;
     m_publisher = source.m_publisher;
+    m_subscribers = source.m_subscribers;
     isCheckedOut = source.isCheckedOut;
     satisfied = source.satisfied;
     return *this;
diff --git a/contrib/autoboost/boost/archive/basic_archive.hpp b/contrib/autoboost/boost/archive/basic_archive.hpp
index a1779fbf9..2d6d45616 100644
--- a/contrib/autoboost/boost/archive/basic_archive.hpp
+++ b/contrib/autoboost/boost/archive/basic_archive.hpp
@@ -22,7 +22,6 @@
 #include <boost/noncopyable.hpp>
 #include <boost/integer_traits.hpp>
 
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
 namespace autoboost {
diff --git a/contrib/autoboost/boost/archive/basic_binary_iprimitive.hpp b/contrib/autoboost/boost/archive/basic_binary_iprimitive.hpp
index 62300fa8e..d3060bc7d 100644
--- a/contrib/autoboost/boost/archive/basic_binary_iprimitive.hpp
+++ b/contrib/autoboost/boost/archive/basic_binary_iprimitive.hpp
@@ -54,7 +54,6 @@ namespace std{
 #include <boost/mpl/placeholders.hpp>
 #include <boost/serialization/is_bitwise_serializable.hpp>
 #include <boost/serialization/array.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
 namespace autoboost { 
diff --git a/contrib/autoboost/boost/archive/basic_binary_oprimitive.hpp b/contrib/autoboost/boost/archive/basic_binary_oprimitive.hpp
index 7ec2d389f..bc782ea26 100644
--- a/contrib/autoboost/boost/archive/basic_binary_oprimitive.hpp
+++ b/contrib/autoboost/boost/archive/basic_binary_oprimitive.hpp
@@ -48,7 +48,6 @@ namespace std{
 #include <boost/serialization/is_bitwise_serializable.hpp>
 #include <boost/mpl/placeholders.hpp>
 #include <boost/serialization/array.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
 namespace autoboost {
diff --git a/contrib/autoboost/boost/archive/basic_xml_archive.hpp b/contrib/autoboost/boost/archive/basic_xml_archive.hpp
index d5ddbd68d..20dff5b17 100644
--- a/contrib/autoboost/boost/archive/basic_xml_archive.hpp
+++ b/contrib/autoboost/boost/archive/basic_xml_archive.hpp
@@ -18,7 +18,6 @@
 
 #include <boost/archive/archive_exception.hpp>
 
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
 namespace autoboost { 
diff --git a/contrib/autoboost/boost/archive/codecvt_null.hpp b/contrib/autoboost/boost/archive/codecvt_null.hpp
index 022e1031f..ca6e90a8f 100644
--- a/contrib/autoboost/boost/archive/codecvt_null.hpp
+++ b/contrib/autoboost/boost/archive/codecvt_null.hpp
@@ -20,7 +20,6 @@
 #include <cstddef> // NULL, size_t
 #include <cwchar>   // for mbstate_t
 #include <boost/config.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
 #if defined(BOOST_NO_STDC_NAMESPACE)
diff --git a/contrib/autoboost/boost/archive/detail/archive_serializer_map.hpp b/contrib/autoboost/boost/archive/detail/archive_serializer_map.hpp
index 0b25cf88c..338be8b9c 100644
--- a/contrib/autoboost/boost/archive/detail/archive_serializer_map.hpp
+++ b/contrib/autoboost/boost/archive/detail/archive_serializer_map.hpp
@@ -21,7 +21,6 @@
 // basic_serializer_map so we can have a one map / archive type. 
 
 #include <boost/config.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
 namespace autoboost {
diff --git a/contrib/autoboost/boost/archive/detail/auto_link_archive.hpp b/contrib/autoboost/boost/archive/detail/auto_link_archive.hpp
deleted file mode 100644
index 35e1acf45..000000000
--- a/contrib/autoboost/boost/archive/detail/auto_link_archive.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-//  auto_link_archive.hpp
-//
-//  (c) Copyright Robert Ramey 2004
-//  Use, modification, and distribution is subject to 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)
-
-//  See library home page at http://www.boost.org/libs/serialization
-
-//----------------------------------------------------------------------------// 
-
-// This header implements separate compilation features as described in
-// http://www.boost.org/more/separate_compilation.html
-
-//  enable automatic library variant selection  ------------------------------// 
-
-#include <boost/archive/detail/decl.hpp>
-
-#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \
-&&  !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE)  \
-&&  !defined(BOOST_SERIALIZATION_SOURCE)
-
-    // Set the name of our library, this will get undef'ed by auto_link.hpp
-    // once it's done with it:
-    //
-    #define BOOST_LIB_NAME autoboost_serialization
-    //
-    // If we're importing code from a dll, then tell auto_link.hpp about it:
-    //
-    #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
-    #  define BOOST_DYN_LINK
-    #endif
-    //
-    // And include the header that does the work:
-    //
-    #include <boost/config/auto_link.hpp>
-#endif  // auto-linking disabled
-
-#endif // BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
diff --git a/contrib/autoboost/boost/archive/detail/auto_link_warchive.hpp b/contrib/autoboost/boost/archive/detail/auto_link_warchive.hpp
deleted file mode 100644
index 4bcaa3142..000000000
--- a/contrib/autoboost/boost/archive/detail/auto_link_warchive.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP
-#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP
-
-// MS compatible compilers support #pragma once
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
-//  auto_link_warchive.hpp
-//
-//  (c) Copyright Robert Ramey 2004
-//  Use, modification, and distribution is subject to 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)
-
-//  See library home page at http://www.boost.org/libs/serialization
-
-//----------------------------------------------------------------------------// 
-
-// This header implements separate compilation features as described in
-// http://www.boost.org/more/separate_compilation.html
-
-//  enable automatic library variant selection  ------------------------------// 
-
-#include <boost/archive/detail/decl.hpp>
-
-#if !defined(BOOST_WARCHIVE_SOURCE) \
-&& !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB)
-
-// Set the name of our library, this will get undef'ed by auto_link.hpp
-// once it's done with it:
-//
-#define BOOST_LIB_NAME autoboost_wserialization
-//
-// If we're importing code from a dll, then tell auto_link.hpp about it:
-//
-#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
-#  define BOOST_DYN_LINK
-#endif
-//
-// And include the header that does the work:
-//
-#include <boost/config/auto_link.hpp>
-#endif  // auto-linking disabled
-
-#endif // ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
diff --git a/contrib/autoboost/boost/archive/detail/basic_iserializer.hpp b/contrib/autoboost/boost/archive/detail/basic_iserializer.hpp
index 380a22680..758f0e800 100644
--- a/contrib/autoboost/boost/archive/detail/basic_iserializer.hpp
+++ b/contrib/autoboost/boost/archive/detail/basic_iserializer.hpp
@@ -22,7 +22,6 @@
 #include <boost/archive/basic_archive.hpp>
 #include <boost/archive/detail/decl.hpp>
 #include <boost/archive/detail/basic_serializer.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
 #ifdef BOOST_MSVC
diff --git a/contrib/autoboost/boost/archive/detail/basic_oserializer.hpp b/contrib/autoboost/boost/archive/detail/basic_oserializer.hpp
index 4eacf5d0d..4b344dfaa 100644
--- a/contrib/autoboost/boost/archive/detail/basic_oserializer.hpp
+++ b/contrib/autoboost/boost/archive/detail/basic_oserializer.hpp
@@ -21,7 +21,6 @@
 #include <boost/noncopyable.hpp>
 
 #include <boost/archive/basic_archive.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/basic_serializer.hpp>
 
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
diff --git a/contrib/autoboost/boost/archive/detail/basic_pointer_iserializer.hpp b/contrib/autoboost/boost/archive/detail/basic_pointer_iserializer.hpp
index 1cb313db4..d532758d9 100644
--- a/contrib/autoboost/boost/archive/detail/basic_pointer_iserializer.hpp
+++ b/contrib/autoboost/boost/archive/detail/basic_pointer_iserializer.hpp
@@ -18,7 +18,6 @@
 //  See http://www.boost.org for updates, documentation, and revision history.
 #include <boost/config.hpp>
 #include <boost/noncopyable.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/basic_serializer.hpp>
 
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
diff --git a/contrib/autoboost/boost/archive/detail/basic_pointer_oserializer.hpp b/contrib/autoboost/boost/archive/detail/basic_pointer_oserializer.hpp
index 4f1089b63..dcb6a0319 100644
--- a/contrib/autoboost/boost/archive/detail/basic_pointer_oserializer.hpp
+++ b/contrib/autoboost/boost/archive/detail/basic_pointer_oserializer.hpp
@@ -18,7 +18,6 @@
 //  See http://www.boost.org for updates, documentation, and revision history.
 #include <boost/config.hpp>
 #include <boost/noncopyable.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/basic_serializer.hpp>
 
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
diff --git a/contrib/autoboost/boost/archive/detail/basic_serializer_map.hpp b/contrib/autoboost/boost/archive/detail/basic_serializer_map.hpp
index 025633146..3c3eff54f 100644
--- a/contrib/autoboost/boost/archive/detail/basic_serializer_map.hpp
+++ b/contrib/autoboost/boost/archive/detail/basic_serializer_map.hpp
@@ -20,7 +20,6 @@
 
 #include <boost/config.hpp>
 #include <boost/noncopyable.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
 
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
diff --git a/contrib/autoboost/boost/archive/detail/interface_iarchive.hpp b/contrib/autoboost/boost/archive/detail/interface_iarchive.hpp
index e3a3007c7..b7d41163c 100644
--- a/contrib/autoboost/boost/archive/detail/interface_iarchive.hpp
+++ b/contrib/autoboost/boost/archive/detail/interface_iarchive.hpp
@@ -18,7 +18,6 @@
 #include <cstddef> // NULL
 #include <boost/cstdint.hpp>
 #include <boost/mpl/bool.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/iserializer.hpp>
 #include <boost/serialization/singleton.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
diff --git a/contrib/autoboost/boost/archive/detail/interface_oarchive.hpp b/contrib/autoboost/boost/archive/detail/interface_oarchive.hpp
index 9689b4a34..50d180eea 100644
--- a/contrib/autoboost/boost/archive/detail/interface_oarchive.hpp
+++ b/contrib/autoboost/boost/archive/detail/interface_oarchive.hpp
@@ -19,7 +19,6 @@
 #include <boost/cstdint.hpp>
 #include <boost/mpl/bool.hpp>
 
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/detail/oserializer.hpp>
 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header
 
diff --git a/contrib/autoboost/boost/archive/text_iarchive.hpp b/contrib/autoboost/boost/archive/text_iarchive.hpp
index e9afce651..bc04625bc 100644
--- a/contrib/autoboost/boost/archive/text_iarchive.hpp
+++ b/contrib/autoboost/boost/archive/text_iarchive.hpp
@@ -19,7 +19,6 @@
 #include <istream>
 
 #include <boost/config.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/basic_text_iprimitive.hpp>
 #include <boost/archive/basic_text_iarchive.hpp>
 #include <boost/archive/detail/register_archive.hpp>
diff --git a/contrib/autoboost/boost/archive/text_oarchive.hpp b/contrib/autoboost/boost/archive/text_oarchive.hpp
index 3d862ab08..8c331dda9 100644
--- a/contrib/autoboost/boost/archive/text_oarchive.hpp
+++ b/contrib/autoboost/boost/archive/text_oarchive.hpp
@@ -26,7 +26,6 @@ namespace std{
 } // namespace std
 #endif
 
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/basic_text_oprimitive.hpp>
 #include <boost/archive/basic_text_oarchive.hpp>
 #include <boost/archive/detail/register_archive.hpp>
diff --git a/contrib/autoboost/boost/archive/text_wiarchive.hpp b/contrib/autoboost/boost/archive/text_wiarchive.hpp
index ad7bd3f92..fb6bde0c0 100644
--- a/contrib/autoboost/boost/archive/text_wiarchive.hpp
+++ b/contrib/autoboost/boost/archive/text_wiarchive.hpp
@@ -23,7 +23,6 @@
 
 #include <istream>
 
-#include <boost/archive/detail/auto_link_warchive.hpp>
 #include <boost/archive/basic_text_iprimitive.hpp>
 #include <boost/archive/basic_text_iarchive.hpp>
 #include <boost/archive/detail/register_archive.hpp>
diff --git a/contrib/autoboost/boost/archive/text_woarchive.hpp b/contrib/autoboost/boost/archive/text_woarchive.hpp
index 1dd58c9ea..cab13ec7f 100644
--- a/contrib/autoboost/boost/archive/text_woarchive.hpp
+++ b/contrib/autoboost/boost/archive/text_woarchive.hpp
@@ -31,7 +31,6 @@ namespace std{
 } // namespace std
 #endif
 
-#include <boost/archive/detail/auto_link_warchive.hpp>
 #include <boost/archive/basic_text_oprimitive.hpp>
 #include <boost/archive/basic_text_oarchive.hpp>
 #include <boost/archive/detail/register_archive.hpp>
diff --git a/contrib/autoboost/boost/archive/xml_iarchive.hpp b/contrib/autoboost/boost/archive/xml_iarchive.hpp
index 725de403a..bb084ca79 100644
--- a/contrib/autoboost/boost/archive/xml_iarchive.hpp
+++ b/contrib/autoboost/boost/archive/xml_iarchive.hpp
@@ -19,7 +19,6 @@
 #include <istream>
 
 //#include <boost/scoped_ptr.hpp>
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/basic_text_iprimitive.hpp>
 #include <boost/archive/basic_xml_iarchive.hpp>
 #include <boost/archive/detail/register_archive.hpp>
diff --git a/contrib/autoboost/boost/archive/xml_oarchive.hpp b/contrib/autoboost/boost/archive/xml_oarchive.hpp
index 073ed2a22..693efa54e 100644
--- a/contrib/autoboost/boost/archive/xml_oarchive.hpp
+++ b/contrib/autoboost/boost/archive/xml_oarchive.hpp
@@ -26,7 +26,6 @@ namespace std{
 } // namespace std
 #endif
 
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/basic_text_oprimitive.hpp>
 #include <boost/archive/basic_xml_oarchive.hpp>
 #include <boost/archive/detail/register_archive.hpp>
diff --git a/contrib/autoboost/boost/archive/xml_wiarchive.hpp b/contrib/autoboost/boost/archive/xml_wiarchive.hpp
index d8ff50ed0..7bc0239ff 100644
--- a/contrib/autoboost/boost/archive/xml_wiarchive.hpp
+++ b/contrib/autoboost/boost/archive/xml_wiarchive.hpp
@@ -24,7 +24,6 @@
 #include <istream>
 
 //#include <boost/scoped_ptr.hpp>
-#include <boost/archive/detail/auto_link_warchive.hpp>
 #include <boost/archive/basic_text_iprimitive.hpp>
 #include <boost/archive/basic_xml_iarchive.hpp>
 #include <boost/archive/detail/register_archive.hpp>
diff --git a/contrib/autoboost/boost/archive/xml_woarchive.hpp b/contrib/autoboost/boost/archive/xml_woarchive.hpp
index f62540450..d8406ef53 100644
--- a/contrib/autoboost/boost/archive/xml_woarchive.hpp
+++ b/contrib/autoboost/boost/archive/xml_woarchive.hpp
@@ -30,7 +30,6 @@ namespace std{
 
 #include <ostream>
 
-#include <boost/archive/detail/auto_link_warchive.hpp>
 #include <boost/archive/basic_text_oprimitive.hpp>
 #include <boost/archive/basic_xml_oarchive.hpp>
 #include <boost/archive/detail/register_archive.hpp>
diff --git a/contrib/autoboost/boost/atomic/detail/caps_gcc_alpha.hpp b/contrib/autoboost/boost/atomic/detail/caps_gcc_alpha.hpp
new file mode 100644
index 000000000..861432f58
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/caps_gcc_alpha.hpp
@@ -0,0 +1,34 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2013 Tim Blechmann
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/caps_gcc_alpha.hpp
+ *
+ * This header defines feature capabilities macros
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_ALPHA_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_CAPS_GCC_ALPHA_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#define BOOST_ATOMIC_INT8_LOCK_FREE 2
+#define BOOST_ATOMIC_INT16_LOCK_FREE 2
+#define BOOST_ATOMIC_INT32_LOCK_FREE 2
+#define BOOST_ATOMIC_INT64_LOCK_FREE 2
+#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
+
+#define BOOST_ATOMIC_THREAD_FENCE 2
+#define BOOST_ATOMIC_SIGNAL_FENCE 2
+
+#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_ALPHA_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/caps_gcc_arm.hpp b/contrib/autoboost/boost/atomic/detail/caps_gcc_arm.hpp
new file mode 100644
index 000000000..b827c648d
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/caps_gcc_arm.hpp
@@ -0,0 +1,56 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2009 Phil Endecott
+ * Copyright (c) 2013 Tim Blechmann
+ * ARM Code by Phil Endecott, based on other architectures.
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/caps_gcc_arm.hpp
+ *
+ * This header defines feature capabilities macros
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_ARM_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_CAPS_GCC_ARM_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if !(defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6ZK__))
+// ARMv7 and later have dmb instruction
+#define BOOST_ATOMIC_DETAIL_ARM_HAS_DMB 1
+#endif
+
+#if !(defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6Z__))
+// ARMv6k and ARMv7 have 8 and 16 ldrex/strex variants
+#define BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXB_STREXB 1
+#define BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXH_STREXH 1
+#if !(((defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6ZK__)) && defined(__thumb__)) || defined(__ARM_ARCH_7M__))
+// ARMv6k and ARMv7 except ARMv7-M have 64-bit ldrex/strex variants.
+// Unfortunately, GCC (at least 4.7.3 on Ubuntu) does not allocate register pairs properly when targeting ARMv6k Thumb,
+// which is required for ldrexd/strexd instructions, so we disable 64-bit support. When targeting ARMv6k ARM
+// or ARMv7 (both ARM and Thumb 2) it works as expected.
+#define BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXD_STREXD 1
+#endif
+#endif
+
+#define BOOST_ATOMIC_INT8_LOCK_FREE 2
+#define BOOST_ATOMIC_INT16_LOCK_FREE 2
+#define BOOST_ATOMIC_INT32_LOCK_FREE 2
+#if defined(BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXD_STREXD)
+#define BOOST_ATOMIC_INT64_LOCK_FREE 2
+#endif
+#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
+
+#define BOOST_ATOMIC_THREAD_FENCE 2
+#define BOOST_ATOMIC_SIGNAL_FENCE 2
+
+#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_ARM_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/caps_gcc_atomic.hpp b/contrib/autoboost/boost/atomic/detail/caps_gcc_atomic.hpp
new file mode 100644
index 000000000..f4e7a7023
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/caps_gcc_atomic.hpp
@@ -0,0 +1,134 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/caps_gcc_atomic.hpp
+ *
+ * This header defines feature capabilities macros
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_ATOMIC_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_CAPS_GCC_ATOMIC_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/int_sizes.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if defined(__i386__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)
+#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B 1
+#endif
+
+#if defined(__x86_64__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
+#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B 1
+#endif
+
+#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) && (defined(BOOST_HAS_INT128) || !defined(BOOST_NO_ALIGNMENT))
+#define BOOST_ATOMIC_INT128_LOCK_FREE 2
+#else
+#define BOOST_ATOMIC_INT128_LOCK_FREE 0
+#endif
+
+#if __GCC_ATOMIC_LLONG_LOCK_FREE == 2
+#define BOOST_ATOMIC_LLONG_LOCK_FREE 2
+#else
+#define BOOST_ATOMIC_LLONG_LOCK_FREE BOOST_ATOMIC_INT128_LOCK_FREE
+#endif
+
+#if __GCC_ATOMIC_LONG_LOCK_FREE == 2
+#define BOOST_ATOMIC_LONG_LOCK_FREE 2
+#else
+#define BOOST_ATOMIC_LONG_LOCK_FREE BOOST_ATOMIC_LLONG_LOCK_FREE
+#endif
+
+#if __GCC_ATOMIC_INT_LOCK_FREE == 2
+#define BOOST_ATOMIC_INT_LOCK_FREE 2
+#else
+#define BOOST_ATOMIC_INT_LOCK_FREE BOOST_ATOMIC_LONG_LOCK_FREE
+#endif
+
+#if __GCC_ATOMIC_SHORT_LOCK_FREE == 2
+#define BOOST_ATOMIC_SHORT_LOCK_FREE 2
+#else
+#define BOOST_ATOMIC_SHORT_LOCK_FREE BOOST_ATOMIC_INT_LOCK_FREE
+#endif
+
+#if __GCC_ATOMIC_CHAR_LOCK_FREE == 2
+#define BOOST_ATOMIC_CHAR_LOCK_FREE 2
+#else
+#define BOOST_ATOMIC_CHAR_LOCK_FREE BOOST_ATOMIC_SHORT_LOCK_FREE
+#endif
+
+#if __GCC_ATOMIC_POINTER_LOCK_FREE == 2
+#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
+#else
+#define BOOST_ATOMIC_POINTER_LOCK_FREE 0
+#endif
+
+
+#define BOOST_ATOMIC_INT8_LOCK_FREE BOOST_ATOMIC_CHAR_LOCK_FREE
+
+#if BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 2
+#define BOOST_ATOMIC_INT16_LOCK_FREE BOOST_ATOMIC_SHORT_LOCK_FREE
+#elif BOOST_ATOMIC_DETAIL_SIZEOF_INT == 2
+#define BOOST_ATOMIC_INT16_LOCK_FREE BOOST_ATOMIC_INT_LOCK_FREE
+#elif BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 2
+#define BOOST_ATOMIC_INT16_LOCK_FREE BOOST_ATOMIC_LONG_LOCK_FREE
+#elif BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 2
+#define BOOST_ATOMIC_INT16_LOCK_FREE BOOST_ATOMIC_LLONG_LOCK_FREE
+#else
+#define BOOST_ATOMIC_INT16_LOCK_FREE 0
+#endif
+
+#if BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 4
+#define BOOST_ATOMIC_INT32_LOCK_FREE BOOST_ATOMIC_SHORT_LOCK_FREE
+#elif BOOST_ATOMIC_DETAIL_SIZEOF_INT == 4
+#define BOOST_ATOMIC_INT32_LOCK_FREE BOOST_ATOMIC_INT_LOCK_FREE
+#elif BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 4
+#define BOOST_ATOMIC_INT32_LOCK_FREE BOOST_ATOMIC_LONG_LOCK_FREE
+#elif BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 4
+#define BOOST_ATOMIC_INT32_LOCK_FREE BOOST_ATOMIC_LLONG_LOCK_FREE
+#else
+#define BOOST_ATOMIC_INT32_LOCK_FREE 0
+#endif
+
+#if BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 8
+#define BOOST_ATOMIC_INT64_LOCK_FREE BOOST_ATOMIC_SHORT_LOCK_FREE
+#elif BOOST_ATOMIC_DETAIL_SIZEOF_INT == 8
+#define BOOST_ATOMIC_INT64_LOCK_FREE BOOST_ATOMIC_INT_LOCK_FREE
+#elif BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 8
+#define BOOST_ATOMIC_INT64_LOCK_FREE BOOST_ATOMIC_LONG_LOCK_FREE
+#elif BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 8
+#define BOOST_ATOMIC_INT64_LOCK_FREE BOOST_ATOMIC_LLONG_LOCK_FREE
+#else
+#define BOOST_ATOMIC_INT64_LOCK_FREE 0
+#endif
+
+
+#if __GCC_ATOMIC_WCHAR_T_LOCK_FREE == 2
+#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 2
+#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 8
+#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT64_LOCK_FREE
+#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 4
+#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE
+#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 2
+#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE
+#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 1
+#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE
+#else
+#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 0
+#endif
+
+#define BOOST_ATOMIC_CHAR32_T_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE
+#define BOOST_ATOMIC_CHAR16_T_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE
+
+#define BOOST_ATOMIC_THREAD_FENCE 2
+#define BOOST_ATOMIC_SIGNAL_FENCE 2
+
+#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_ATOMIC_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/caps_gcc_ppc.hpp b/contrib/autoboost/boost/atomic/detail/caps_gcc_ppc.hpp
new file mode 100644
index 000000000..6dbdde826
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/caps_gcc_ppc.hpp
@@ -0,0 +1,36 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2013 Tim Blechmann
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/caps_gcc_ppc.hpp
+ *
+ * This header defines feature capabilities macros
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_PPC_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_CAPS_GCC_PPC_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#define BOOST_ATOMIC_INT8_LOCK_FREE 2
+#define BOOST_ATOMIC_INT16_LOCK_FREE 2
+#define BOOST_ATOMIC_INT32_LOCK_FREE 2
+#if defined(__powerpc64__)
+#define BOOST_ATOMIC_INT64_LOCK_FREE 2
+#endif
+#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
+
+#define BOOST_ATOMIC_THREAD_FENCE 2
+#define BOOST_ATOMIC_SIGNAL_FENCE 2
+
+#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_PPC_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/caps_gcc_sparc.hpp b/contrib/autoboost/boost/atomic/detail/caps_gcc_sparc.hpp
new file mode 100644
index 000000000..580668492
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/caps_gcc_sparc.hpp
@@ -0,0 +1,34 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2010 Helge Bahmann
+ * Copyright (c) 2013 Tim Blechmann
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/caps_gcc_sparc.hpp
+ *
+ * This header defines feature capabilities macros
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_SPARC_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_CAPS_GCC_SPARC_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#define BOOST_ATOMIC_INT8_LOCK_FREE 2
+#define BOOST_ATOMIC_INT16_LOCK_FREE 2
+#define BOOST_ATOMIC_INT32_LOCK_FREE 2
+#define BOOST_ATOMIC_INT64_LOCK_FREE 2
+#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
+
+#define BOOST_ATOMIC_THREAD_FENCE 2
+#define BOOST_ATOMIC_SIGNAL_FENCE 2
+
+#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_SPARC_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/caps_gcc_sync.hpp b/contrib/autoboost/boost/atomic/detail/caps_gcc_sync.hpp
new file mode 100644
index 000000000..7fac07a13
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/caps_gcc_sync.hpp
@@ -0,0 +1,62 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2011 Helge Bahmann
+ * Copyright (c) 2013 Tim Blechmann
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/caps_gcc_sync.hpp
+ *
+ * This header defines feature capabilities macros
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_SYNC_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_CAPS_GCC_SYNC_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if defined(__i386__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)
+#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B 1
+#endif
+
+#if defined(__x86_64__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
+#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B 1
+#endif
+
+#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1)\
+    || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2)\
+    || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)\
+    || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)\
+    || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
+#define BOOST_ATOMIC_INT8_LOCK_FREE 2
+#endif
+#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2)\
+    || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)\
+    || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)\
+    || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
+#define BOOST_ATOMIC_INT16_LOCK_FREE 2
+#endif
+#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)\
+    || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)\
+    || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
+#define BOOST_ATOMIC_INT32_LOCK_FREE 2
+#endif
+#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)\
+    || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
+#define BOOST_ATOMIC_INT64_LOCK_FREE 2
+#endif
+#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
+#define BOOST_ATOMIC_INT128_LOCK_FREE 2
+#endif
+
+#define BOOST_ATOMIC_THREAD_FENCE 2
+#define BOOST_ATOMIC_SIGNAL_FENCE 2
+
+#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_SYNC_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/caps_gcc_x86.hpp b/contrib/autoboost/boost/atomic/detail/caps_gcc_x86.hpp
new file mode 100644
index 000000000..0696bf1d2
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/caps_gcc_x86.hpp
@@ -0,0 +1,52 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2012 Tim Blechmann
+ * Copyright (c) 2013 - 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/caps_gcc_x86.hpp
+ *
+ * This header defines feature capabilities macros
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_X86_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_CAPS_GCC_X86_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if defined(__i386__) &&\
+    (\
+        defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) ||\
+        defined(__i586__) || defined(__i686__) || defined(__pentium4__) || defined(__nocona__) || defined(__core2__) || defined(__corei7__) ||\
+        defined(__k6__) || defined(__athlon__) || defined(__k8__) || defined(__amdfam10__) || defined(__bdver1__) || defined(__bdver2__) || defined(__bdver3__) || defined(__btver1__) || defined(__btver2__)\
+    )
+#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B 1
+#endif
+
+#if defined(__x86_64__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)
+#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B 1
+#endif
+
+#define BOOST_ATOMIC_INT8_LOCK_FREE 2
+#define BOOST_ATOMIC_INT16_LOCK_FREE 2
+#define BOOST_ATOMIC_INT32_LOCK_FREE 2
+#if defined(__x86_64__) || defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B)
+#define BOOST_ATOMIC_INT64_LOCK_FREE 2
+#endif
+#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) && (defined(BOOST_HAS_INT128) || !defined(BOOST_NO_ALIGNMENT))
+#define BOOST_ATOMIC_INT128_LOCK_FREE 2
+#endif
+#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
+
+#define BOOST_ATOMIC_THREAD_FENCE 2
+#define BOOST_ATOMIC_SIGNAL_FENCE 2
+
+#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_X86_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/caps_linux_arm.hpp b/contrib/autoboost/boost/atomic/detail/caps_linux_arm.hpp
new file mode 100644
index 000000000..abe6fb81a
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/caps_linux_arm.hpp
@@ -0,0 +1,35 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009, 2011 Helge Bahmann
+ * Copyright (c) 2009 Phil Endecott
+ * Copyright (c) 2013 Tim Blechmann
+ * Linux-specific code by Phil Endecott
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/caps_linux_arm.hpp
+ *
+ * This header defines feature capabilities macros
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_CAPS_LINUX_ARM_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_CAPS_LINUX_ARM_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#define BOOST_ATOMIC_INT8_LOCK_FREE 2
+#define BOOST_ATOMIC_INT16_LOCK_FREE 2
+#define BOOST_ATOMIC_INT32_LOCK_FREE 2
+#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
+
+#define BOOST_ATOMIC_THREAD_FENCE 2
+#define BOOST_ATOMIC_SIGNAL_FENCE 2
+
+#endif // BOOST_ATOMIC_DETAIL_CAPS_LINUX_ARM_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/caps_msvc_arm.hpp b/contrib/autoboost/boost/atomic/detail/caps_msvc_arm.hpp
new file mode 100644
index 000000000..6b3c61fb3
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/caps_msvc_arm.hpp
@@ -0,0 +1,34 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2013 Tim Blechmann
+ * Copyright (c) 2012 - 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/caps_msvc_arm.hpp
+ *
+ * This header defines feature capabilities macros
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_CAPS_MSVC_ARM_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_CAPS_MSVC_ARM_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#define BOOST_ATOMIC_INT8_LOCK_FREE 2
+#define BOOST_ATOMIC_INT16_LOCK_FREE 2
+#define BOOST_ATOMIC_INT32_LOCK_FREE 2
+#define BOOST_ATOMIC_INT64_LOCK_FREE 2
+#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
+
+#define BOOST_ATOMIC_THREAD_FENCE 2
+#define BOOST_ATOMIC_SIGNAL_FENCE 2
+
+#endif // BOOST_ATOMIC_DETAIL_CAPS_MSVC_ARM_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/caps_msvc_x86.hpp b/contrib/autoboost/boost/atomic/detail/caps_msvc_x86.hpp
new file mode 100644
index 000000000..5661a5b7a
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/caps_msvc_x86.hpp
@@ -0,0 +1,50 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2013 Tim Blechmann
+ * Copyright (c) 2012 - 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/caps_msvc_x86.hpp
+ *
+ * This header defines feature capabilities macros
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_CAPS_MSVC_X86_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_CAPS_MSVC_X86_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if defined(_M_IX86) && _M_IX86 >= 500
+#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B 1
+#endif
+
+#if _MSC_VER >= 1500 && defined(_M_AMD64) && !defined(BOOST_ATOMIC_NO_CMPXCHG16B)
+#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B 1
+#endif
+
+#define BOOST_ATOMIC_INT8_LOCK_FREE 2
+#define BOOST_ATOMIC_INT16_LOCK_FREE 2
+#define BOOST_ATOMIC_INT32_LOCK_FREE 2
+
+#if defined(_M_AMD64) || defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B)
+#define BOOST_ATOMIC_INT64_LOCK_FREE 2
+#endif
+
+#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) && (defined(BOOST_HAS_INT128) || !defined(BOOST_NO_ALIGNMENT))
+#define BOOST_ATOMIC_INT128_LOCK_FREE 2
+#endif
+
+#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
+
+#define BOOST_ATOMIC_THREAD_FENCE 2
+#define BOOST_ATOMIC_SIGNAL_FENCE 2
+
+#endif // BOOST_ATOMIC_DETAIL_CAPS_MSVC_X86_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/caps_windows.hpp b/contrib/autoboost/boost/atomic/detail/caps_windows.hpp
new file mode 100644
index 000000000..1cc0ded83
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/caps_windows.hpp
@@ -0,0 +1,33 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2013 Tim Blechmann
+ * Copyright (c) 2012 - 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/caps_windows.hpp
+ *
+ * This header defines feature capabilities macros
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_CAPS_WINDOWS_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_CAPS_WINDOWS_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#define BOOST_ATOMIC_INT8_LOCK_FREE 2
+#define BOOST_ATOMIC_INT16_LOCK_FREE 2
+#define BOOST_ATOMIC_INT32_LOCK_FREE 2
+#define BOOST_ATOMIC_POINTER_LOCK_FREE 2
+
+#define BOOST_ATOMIC_THREAD_FENCE 2
+#define BOOST_ATOMIC_SIGNAL_FENCE 2
+
+#endif // BOOST_ATOMIC_DETAIL_CAPS_WINDOWS_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/link.hpp b/contrib/autoboost/boost/atomic/detail/link.hpp
index 29c9e7f6e..747972df9 100644
--- a/contrib/autoboost/boost/atomic/detail/link.hpp
+++ b/contrib/autoboost/boost/atomic/detail/link.hpp
@@ -39,20 +39,4 @@
 #define BOOST_ATOMIC_DECL
 #endif
 
-///////////////////////////////////////////////////////////////////////////////
-//  Auto library naming
-#if !defined(BOOST_ATOMIC_SOURCE) && !defined(BOOST_ALL_NO_LIB) && \
-    !defined(BOOST_ATOMIC_NO_LIB)
-
-#define BOOST_LIB_NAME autoboost_atomic
-
-// tell the auto-link code to select a dll when required:
-#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_ATOMIC_DYN_LINK)
-#define BOOST_DYN_LINK
-#endif
-
-#include <boost/config/auto_link.hpp>
-
-#endif  // auto-linking disabled
-
 #endif
diff --git a/contrib/autoboost/boost/atomic/detail/ops_cas_based.hpp b/contrib/autoboost/boost/atomic/detail/ops_cas_based.hpp
new file mode 100644
index 000000000..ee2ac3633
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/ops_cas_based.hpp
@@ -0,0 +1,91 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_cas_based.hpp
+ *
+ * This header contains CAS-based implementation of the \c operations template.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_CAS_BASED_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_CAS_BASED_HPP_INCLUDED_
+
+#include <boost/memory_order.hpp>
+#include <boost/atomic/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace autoboost {
+namespace atomics {
+namespace detail {
+
+template< typename Base >
+struct cas_based_operations :
+    public Base
+{
+    typedef typename Base::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type old_val = Base::load(storage, memory_order_relaxed);
+        while (!Base::compare_exchange_weak(storage, old_val, old_val + v, order, memory_order_relaxed)) {}
+        return old_val;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type old_val = Base::load(storage, memory_order_relaxed);
+        while (!Base::compare_exchange_weak(storage, old_val, old_val - v, order, memory_order_relaxed)) {}
+        return old_val;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type old_val = Base::load(storage, memory_order_relaxed);
+        while (!Base::compare_exchange_weak(storage, old_val, v, order, memory_order_relaxed)) {}
+        return old_val;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type old_val = Base::load(storage, memory_order_relaxed);
+        while (!Base::compare_exchange_weak(storage, old_val, old_val & v, order, memory_order_relaxed)) {}
+        return old_val;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type old_val = Base::load(storage, memory_order_relaxed);
+        while (!Base::compare_exchange_weak(storage, old_val, old_val | v, order, memory_order_relaxed)) {}
+        return old_val;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type old_val = Base::load(storage, memory_order_relaxed);
+        while (!Base::compare_exchange_weak(storage, old_val, old_val ^ v, order, memory_order_relaxed)) {}
+        return old_val;
+    }
+
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        return !!exchange(storage, (storage_type)1, order);
+    }
+
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        Base::store(storage, (storage_type)0, order);
+    }
+};
+
+} // namespace detail
+} // namespace atomics
+} // namespace autoboost
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_CAS_BASED_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/ops_extending_cas_based.hpp b/contrib/autoboost/boost/atomic/detail/ops_extending_cas_based.hpp
new file mode 100644
index 000000000..0477d2014
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/ops_extending_cas_based.hpp
@@ -0,0 +1,65 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_extending_cas_based.hpp
+ *
+ * This header contains a boilerplate of the \c operations template implementation that requires sign/zero extension in arithmetic operations.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_EXTENDING_CAS_BASED_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_EXTENDING_CAS_BASED_HPP_INCLUDED_
+
+#include <boost/memory_order.hpp>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/storage_type.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace autoboost {
+namespace atomics {
+namespace detail {
+
+template< typename Base, unsigned int Size, bool Signed >
+struct extending_cas_based_operations :
+    public Base
+{
+    typedef typename Base::storage_type storage_type;
+    typedef typename make_storage_type< Size, Signed >::type emulated_storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type old_val = Base::load(storage, memory_order_relaxed);
+        emulated_storage_type new_val;
+        do
+        {
+            new_val = static_cast< emulated_storage_type >(old_val) + static_cast< emulated_storage_type >(v);
+        }
+        while (!Base::compare_exchange_weak(storage, old_val, static_cast< storage_type >(new_val), order, memory_order_relaxed));
+        return old_val;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type old_val = Base::load(storage, memory_order_relaxed);
+        emulated_storage_type new_val;
+        do
+        {
+            new_val = static_cast< emulated_storage_type >(old_val) - static_cast< emulated_storage_type >(v);
+        }
+        while (!Base::compare_exchange_weak(storage, old_val, static_cast< storage_type >(new_val), order, memory_order_relaxed));
+        return old_val;
+    }
+};
+
+} // namespace detail
+} // namespace atomics
+} // namespace autoboost
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_EXTENDING_CAS_BASED_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/ops_gcc_alpha.hpp b/contrib/autoboost/boost/atomic/detail/ops_gcc_alpha.hpp
new file mode 100644
index 000000000..f9a352213
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/ops_gcc_alpha.hpp
@@ -0,0 +1,874 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2013 Tim Blechmann
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_gcc_alpha.hpp
+ *
+ * This header contains implementation of the \c operations template.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_ALPHA_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_GCC_ALPHA_HPP_INCLUDED_
+
+#include <boost/memory_order.hpp>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/operations_fwd.hpp>
+#include <boost/atomic/capabilities.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace autoboost {
+namespace atomics {
+namespace detail {
+
+/*
+  Refer to http://h71000.www7.hp.com/doc/82final/5601/5601pro_004.html
+  (HP OpenVMS systems documentation) and the Alpha Architecture Reference Manual.
+ */
+
+/*
+    NB: The most natural thing would be to write the increment/decrement
+    operators along the following lines:
+
+    __asm__ __volatile__
+    (
+        "1: ldl_l %0,%1 \n"
+        "addl %0,1,%0 \n"
+        "stl_c %0,%1 \n"
+        "beq %0,1b\n"
+        : "=&b" (tmp)
+        : "m" (value)
+        : "cc"
+    );
+
+    However according to the comments on the HP website and matching
+    comments in the Linux kernel sources this defies branch prediction,
+    as the cpu assumes that backward branches are always taken; so
+    instead copy the trick from the Linux kernel, introduce a forward
+    branch and back again.
+
+    I have, however, had a hard time measuring the difference between
+    the two versions in microbenchmarks -- I am leaving it in nevertheless
+    as it apparently does not hurt either.
+*/
+
+struct gcc_alpha_operations_base
+{
+    static BOOST_FORCEINLINE void fence_before(memory_order order) BOOST_NOEXCEPT
+    {
+        if ((order & memory_order_release) != 0)
+            __asm__ __volatile__ ("mb" ::: "memory");
+    }
+
+    static BOOST_FORCEINLINE void fence_after(memory_order order) BOOST_NOEXCEPT
+    {
+        if ((order & (memory_order_consume | memory_order_acquire)) != 0)
+            __asm__ __volatile__ ("mb" ::: "memory");
+    }
+
+    static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT
+    {
+        if (order == memory_order_seq_cst)
+            __asm__ __volatile__ ("mb" ::: "memory");
+    }
+};
+
+
+template< bool Signed >
+struct operations< 4u, Signed > :
+    public gcc_alpha_operations_base
+{
+    typedef typename make_storage_type< 4u, Signed >::type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        storage = v;
+        fence_after_store(order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v = storage;
+        fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "mov %3, %1\n"
+            "ldl_l %0, %2\n"
+            "stl_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (tmp)        // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        fence_before(success_order);
+        int success;
+        storage_type current;
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldl_l %2, %4\n"                // current = *(&storage)
+            "cmpeq %2, %0, %3\n"            // success = current == expected
+            "mov %2, %0\n"                  // expected = current
+            "beq %3, 2f\n"                  // if (success == 0) goto end
+            "stl_c %1, %4\n"                // storage = desired; desired = store succeeded
+            "mov %1, %3\n"                  // success = desired
+            "2:\n"
+            : "+&r" (expected),  // %0
+              "+&r" (desired),   // %1
+              "=&r" (current),   // %2
+              "=&r" (success)    // %3
+            : "m" (storage)      // %4
+            :
+        );
+        if (success)
+            fence_after(success_order);
+        else
+            fence_after(failure_order);
+        return !!success;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        int success;
+        storage_type current, tmp;
+        fence_before(success_order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "mov %5, %1\n"                  // tmp = desired
+            "ldl_l %2, %4\n"                // current = *(&storage)
+            "cmpeq %2, %0, %3\n"            // success = current == expected
+            "mov %2, %0\n"                  // expected = current
+            "beq %3, 2f\n"                  // if (success == 0) goto end
+            "stl_c %1, %4\n"                // storage = tmp; tmp = store succeeded
+            "beq %1, 3f\n"                  // if (tmp == 0) goto retry
+            "mov %1, %3\n"                  // success = tmp
+            "2:\n"
+
+            ".subsection 2\n"
+            "3: br 1b\n"
+            ".previous\n"
+
+            : "+&r" (expected),  // %0
+              "=&r" (tmp),       // %1
+              "=&r" (current),   // %2
+              "=&r" (success)    // %3
+            : "m" (storage),     // %4
+              "r" (desired)      // %5
+            :
+        );
+        if (success)
+            fence_after(success_order);
+        else
+            fence_after(failure_order);
+        return !!success;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldl_l %0, %2\n"
+            "addl %0, %3, %1\n"
+            "stl_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldl_l %0, %2\n"
+            "subl %0, %3, %1\n"
+            "stl_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldl_l %0, %2\n"
+            "and %0, %3, %1\n"
+            "stl_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldl_l %0, %2\n"
+            "bis %0, %3, %1\n"
+            "stl_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldl_l %0, %2\n"
+            "xor %0, %3, %1\n"
+            "stl_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        return !!exchange(storage, (storage_type)1, order);
+    }
+
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        store(storage, 0, order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+
+template< >
+struct operations< 1u, false > :
+    public operations< 4u, false >
+{
+    typedef operations< 4u, false > base_type;
+    typedef base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldl_l %0, %2\n"
+            "addl %0, %3, %1\n"
+            "zapnot %1, #1, %1\n"
+            "stl_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldl_l %0, %2\n"
+            "subl %0, %3, %1\n"
+            "zapnot %1, #1, %1\n"
+            "stl_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+};
+
+template< >
+struct operations< 1u, true > :
+    public operations< 4u, true >
+{
+    typedef operations< 4u, true > base_type;
+    typedef base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldl_l %0, %2\n"
+            "addl %0, %3, %1\n"
+            "sextb %1, %1\n"
+            "stl_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldl_l %0, %2\n"
+            "subl %0, %3, %1\n"
+            "sextb %1, %1\n"
+            "stl_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+};
+
+
+template< >
+struct operations< 2u, false > :
+    public operations< 4u, false >
+{
+    typedef operations< 4u, false > base_type;
+    typedef base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldl_l %0, %2\n"
+            "addl %0, %3, %1\n"
+            "zapnot %1, #3, %1\n"
+            "stl_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldl_l %0, %2\n"
+            "subl %0, %3, %1\n"
+            "zapnot %1, #3, %1\n"
+            "stl_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+};
+
+template< >
+struct operations< 2u, true > :
+    public operations< 4u, true >
+{
+    typedef operations< 4u, true > base_type;
+    typedef base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldl_l %0, %2\n"
+            "addl %0, %3, %1\n"
+            "sextw %1, %1\n"
+            "stl_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldl_l %0, %2\n"
+            "subl %0, %3, %1\n"
+            "sextw %1, %1\n"
+            "stl_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+};
+
+
+template< bool Signed >
+struct operations< 8u, Signed > :
+    public gcc_alpha_operations_base
+{
+    typedef typename make_storage_type< 8u, Signed >::type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        storage = v;
+        fence_after_store(order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v = storage;
+        fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "mov %3, %1\n"
+            "ldq_l %0, %2\n"
+            "stq_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (tmp)        // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        fence_before(success_order);
+        int success;
+        storage_type current;
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldq_l %2, %4\n"                // current = *(&storage)
+            "cmpeq %2, %0, %3\n"            // success = current == expected
+            "mov %2, %0\n"                  // expected = current
+            "beq %3, 2f\n"                  // if (success == 0) goto end
+            "stq_c %1, %4\n"                // storage = desired; desired = store succeeded
+            "mov %1, %3\n"                  // success = desired
+            "2:\n"
+            : "+&r" (expected),  // %0
+              "+&r" (desired),   // %1
+              "=&r" (current),   // %2
+              "=&r" (success)    // %3
+            : "m" (storage)      // %4
+            :
+        );
+        if (success)
+            fence_after(success_order);
+        else
+            fence_after(failure_order);
+        return !!success;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        int success;
+        storage_type current, tmp;
+        fence_before(success_order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "mov %5, %1\n"                  // tmp = desired
+            "ldq_l %2, %4\n"                // current = *(&storage)
+            "cmpeq %2, %0, %3\n"            // success = current == expected
+            "mov %2, %0\n"                  // expected = current
+            "beq %3, 2f\n"                  // if (success == 0) goto end
+            "stq_c %1, %4\n"                // storage = tmp; tmp = store succeeded
+            "beq %1, 3f\n"                  // if (tmp == 0) goto retry
+            "mov %1, %3\n"                  // success = tmp
+            "2:\n"
+
+            ".subsection 2\n"
+            "3: br 1b\n"
+            ".previous\n"
+
+            : "+&r" (expected),  // %0
+              "=&r" (tmp),       // %1
+              "=&r" (current),   // %2
+              "=&r" (success)    // %3
+            : "m" (storage),     // %4
+              "r" (desired)      // %5
+            :
+        );
+        if (success)
+            fence_after(success_order);
+        else
+            fence_after(failure_order);
+        return !!success;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldq_l %0, %2\n"
+            "addq %0, %3, %1\n"
+            "stq_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldq_l %0, %2\n"
+            "subq %0, %3, %1\n"
+            "stq_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldq_l %0, %2\n"
+            "and %0, %3, %1\n"
+            "stq_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldq_l %0, %2\n"
+            "bis %0, %3, %1\n"
+            "stq_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, modified;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldq_l %0, %2\n"
+            "xor %0, %3, %1\n"
+            "stq_c %1, %2\n"
+            "beq %1, 2f\n"
+
+            ".subsection 2\n"
+            "2: br 1b\n"
+            ".previous\n"
+
+            : "=&r" (original),  // %0
+              "=&r" (modified)   // %1
+            : "m" (storage),     // %2
+              "r" (v)            // %3
+            :
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        return !!exchange(storage, (storage_type)1, order);
+    }
+
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        store(storage, 0, order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+
+BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        __asm__ __volatile__ ("mb" ::: "memory");
+}
+
+BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        __asm__ __volatile__ ("" ::: "memory");
+}
+
+} // namespace detail
+} // namespace atomics
+} // namespace autoboost
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_ALPHA_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/ops_gcc_arm.hpp b/contrib/autoboost/boost/atomic/detail/ops_gcc_arm.hpp
new file mode 100644
index 000000000..e9ac0b2fb
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/ops_gcc_arm.hpp
@@ -0,0 +1,971 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2013 Tim Blechmann
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_gcc_arm.hpp
+ *
+ * This header contains implementation of the \c operations template.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_ARM_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_GCC_ARM_HPP_INCLUDED_
+
+#include <boost/cstdint.hpp>
+#include <boost/memory_order.hpp>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/operations_fwd.hpp>
+#include <boost/atomic/detail/ops_extending_cas_based.hpp>
+#include <boost/atomic/capabilities.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace autoboost {
+namespace atomics {
+namespace detail {
+
+// From the ARM Architecture Reference Manual for architecture v6:
+//
+// LDREX{<cond>} <Rd>, [<Rn>]
+// <Rd> Specifies the destination register for the memory word addressed by <Rd>
+// <Rn> Specifies the register containing the address.
+//
+// STREX{<cond>} <Rd>, <Rm>, [<Rn>]
+// <Rd> Specifies the destination register for the returned status value.
+//      0  if the operation updates memory
+//      1  if the operation fails to update memory
+// <Rm> Specifies the register containing the word to be stored to memory.
+// <Rn> Specifies the register containing the address.
+// Rd must not be the same register as Rm or Rn.
+//
+// ARM v7 is like ARM v6 plus:
+// There are half-word and byte versions of the LDREX and STREX instructions,
+// LDREXH, LDREXB, STREXH and STREXB.
+// There are also double-word versions, LDREXD and STREXD.
+// (Actually it looks like these are available from version 6k onwards.)
+// FIXME these are not yet used; should be mostly a matter of copy-and-paste.
+// I think you can supply an immediate offset to the address.
+//
+// A memory barrier is effected using a "co-processor 15" instruction,
+// though a separate assembler mnemonic is available for it in v7.
+//
+// "Thumb 1" is a subset of the ARM instruction set that uses a 16-bit encoding.  It
+// doesn't include all instructions and in particular it doesn't include the co-processor
+// instruction used for the memory barrier or the load-locked/store-conditional
+// instructions.  So, if we're compiling in "Thumb 1" mode, we need to wrap all of our
+// asm blocks with code to temporarily change to ARM mode.
+//
+// You can only change between ARM and Thumb modes when branching using the bx instruction.
+// bx takes an address specified in a register.  The least significant bit of the address
+// indicates the mode, so 1 is added to indicate that the destination code is Thumb.
+// A temporary register is needed for the address and is passed as an argument to these
+// macros.  It must be one of the "low" registers accessible to Thumb code, specified
+// using the "l" attribute in the asm statement.
+//
+// Architecture v7 introduces "Thumb 2", which does include (almost?) all of the ARM
+// instruction set.  (Actually, there was an extension of v6 called v6T2 which supported
+// "Thumb 2" mode, but its architecture manual is no longer available, referring to v7.)
+// So in v7 we don't need to change to ARM mode; we can write "universal
+// assembler" which will assemble to Thumb 2 or ARM code as appropriate.  The only thing
+// we need to do to make this "universal" assembler mode work is to insert "IT" instructions
+// to annotate the conditional instructions.  These are ignored in other modes (e.g. v6),
+// so they can always be present.
+
+// A note about memory_order_consume. Technically, this architecture allows to avoid
+// unnecessary memory barrier after consume load since it supports data dependency ordering.
+// However, some compiler optimizations may break a seemingly valid code relying on data
+// dependency tracking by injecting bogus branches to aid out of order execution.
+// This may happen not only in Boost.Atomic code but also in user's code, which we have no
+// control of. See this thread: http://lists.boost.org/Archives/boost/2014/06/213890.php.
+// For this reason we promote memory_order_consume to memory_order_acquire.
+
+#if defined(__thumb__) && !defined(__thumb2__)
+#define BOOST_ATOMIC_DETAIL_ARM_ASM_START(TMPREG) "adr " #TMPREG ", 8f\n" "bx " #TMPREG "\n" ".arm\n" ".align 4\n" "8:\n"
+#define BOOST_ATOMIC_DETAIL_ARM_ASM_END(TMPREG)   "adr " #TMPREG ", 9f + 1\n" "bx " #TMPREG "\n" ".thumb\n" ".align 2\n" "9:\n"
+#define BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(var) "=&l" (var)
+#else
+// The tmpreg may be wasted in this case, which is non-optimal.
+#define BOOST_ATOMIC_DETAIL_ARM_ASM_START(TMPREG)
+#define BOOST_ATOMIC_DETAIL_ARM_ASM_END(TMPREG)
+#define BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(var) "=&r" (var)
+#endif
+
+struct gcc_arm_operations_base
+{
+    static BOOST_FORCEINLINE void fence_before(memory_order order) BOOST_NOEXCEPT
+    {
+        if ((order & memory_order_release) != 0)
+            hardware_full_fence();
+    }
+
+    static BOOST_FORCEINLINE void fence_after(memory_order order) BOOST_NOEXCEPT
+    {
+        if ((order & (memory_order_consume | memory_order_acquire)) != 0)
+            hardware_full_fence();
+    }
+
+    static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT
+    {
+        if (order == memory_order_seq_cst)
+            hardware_full_fence();
+    }
+
+    static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT
+    {
+#if defined(BOOST_ATOMIC_DETAIL_ARM_HAS_DMB)
+        // Older binutils (supposedly, older than 2.21.1) didn't support symbolic or numeric arguments of the "dmb" instruction such as "ish" or "#11".
+        // As a workaround we have to inject encoded bytes of the instruction. There are two encodings for the instruction: ARM and Thumb. See ARM Architecture Reference Manual, A8.8.43.
+        // Since we cannot detect binutils version at compile time, we'll have to always use this hack.
+        __asm__ __volatile__
+        (
+#if defined(__thumb2__)
+            ".short 0xF3BF, 0x8F5B\n" // dmb ish
+#else
+            ".word 0xF57FF05B\n" // dmb ish
+#endif
+            :
+            :
+            : "memory"
+        );
+#else
+        int tmp;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
+            "mcr\tp15, 0, r0, c7, c10, 5\n"
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
+            : "=&l" (tmp)
+            :
+            : "memory"
+        );
+#endif
+    }
+};
+
+
+template< bool Signed >
+struct operations< 4u, Signed > :
+    public gcc_arm_operations_base
+{
+    typedef typename make_storage_type< 4u, Signed >::type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        storage = v;
+        fence_after_store(order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v = storage;
+        fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original;
+        fence_before(order);
+        uint32_t tmp;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "1:\n"
+            "ldrex %[original], %[storage]\n"          // load the original value
+            "strex %[tmp], %[value], %[storage]\n"     // store the replacement, tmp = store failed
+            "teq   %[tmp], #0\n"                       // check if store succeeded
+            "bne   1b\n"
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [tmp] "=&l" (tmp), [original] "=&r" (original), [storage] "+Q" (storage)
+            : [value] "r" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        fence_before(success_order);
+        uint32_t success;
+        uint32_t tmp;
+        storage_type original;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "mov     %[success], #0\n"                      // success = 0
+            "ldrex   %[original], %[storage]\n"             // original = *(&storage)
+            "cmp     %[original], %[expected]\n"            // flags = original==expected
+            "itt     eq\n"                                  // [hint that the following 2 instructions are conditional on flags.equal]
+            "strexeq %[success], %[desired], %[storage]\n"  // if (flags.equal) *(&storage) = desired, success = store failed
+            "eoreq   %[success], %[success], #1\n"          // if (flags.equal) success ^= 1 (i.e. make it 1 if store succeeded)
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [original] "=&r" (original),  // %0
+              [success] "=&r" (success),    // %1
+              [tmp] "=&l" (tmp),            // %2
+              [storage] "+Q" (storage)      // %3
+            : [expected] "r" (expected),    // %4
+              [desired] "r" (desired)       // %5
+            : "cc"
+        );
+        if (success)
+            fence_after(success_order);
+        else
+            fence_after(failure_order);
+        expected = original;
+        return !!success;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        fence_before(success_order);
+        uint32_t success;
+        uint32_t tmp;
+        storage_type original;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "mov     %[success], #0\n"                      // success = 0
+            "1:\n"
+            "ldrex   %[original], %[storage]\n"             // original = *(&storage)
+            "cmp     %[original], %[expected]\n"            // flags = original==expected
+            "bne     2f\n"                                  // if (!flags.equal) goto end
+            "strex   %[success], %[desired], %[storage]\n"  // *(&storage) = desired, success = store failed
+            "eors    %[success], %[success], #1\n"          // success ^= 1 (i.e. make it 1 if store succeeded); flags.equal = success == 0
+            "beq     1b\n"                                  // if (flags.equal) goto retry
+            "2:\n"
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [original] "=&r" (original),  // %0
+              [success] "=&r" (success),    // %1
+              [tmp] "=&l" (tmp),            // %2
+              [storage] "+Q" (storage)      // %3
+            : [expected] "r" (expected),    // %4
+              [desired] "r" (desired)       // %5
+            : "cc"
+        );
+        if (success)
+            fence_after(success_order);
+        else
+            fence_after(failure_order);
+        expected = original;
+        return !!success;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        uint32_t tmp;
+        storage_type original, result;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "1:\n"
+            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
+            "add     %[result], %[original], %[value]\n"  // result = original + value
+            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n"                        // flags = tmp==0
+            "bne     1b\n"                                // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [original] "=&r" (original),  // %0
+              [result] "=&r" (result),      // %1
+              [tmp] "=&l" (tmp),            // %2
+              [storage] "+Q" (storage)      // %3
+            : [value] "r" (v)               // %4
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        uint32_t tmp;
+        storage_type original, result;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "1:\n"
+            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
+            "sub     %[result], %[original], %[value]\n"  // result = original - value
+            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n"                        // flags = tmp==0
+            "bne     1b\n"                                // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [original] "=&r" (original),  // %0
+              [result] "=&r" (result),      // %1
+              [tmp] "=&l" (tmp),            // %2
+              [storage] "+Q" (storage)      // %3
+            : [value] "r" (v)               // %4
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        uint32_t tmp;
+        storage_type original, result;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "1:\n"
+            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
+            "and     %[result], %[original], %[value]\n"  // result = original & value
+            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n"                        // flags = tmp==0
+            "bne     1b\n"                                // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [original] "=&r" (original),  // %0
+              [result] "=&r" (result),      // %1
+              [tmp] "=&l" (tmp),            // %2
+              [storage] "+Q" (storage)      // %3
+            : [value] "r" (v)               // %4
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        uint32_t tmp;
+        storage_type original, result;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "1:\n"
+            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
+            "orr     %[result], %[original], %[value]\n"  // result = original | value
+            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n"                        // flags = tmp==0
+            "bne     1b\n"                                // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [original] "=&r" (original),  // %0
+              [result] "=&r" (result),      // %1
+              [tmp] "=&l" (tmp),            // %2
+              [storage] "+Q" (storage)      // %3
+            : [value] "r" (v)               // %4
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        uint32_t tmp;
+        storage_type original, result;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "1:\n"
+            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
+            "eor     %[result], %[original], %[value]\n"  // result = original ^ value
+            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n"                        // flags = tmp==0
+            "bne     1b\n"                                // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [original] "=&r" (original),  // %0
+              [result] "=&r" (result),      // %1
+              [tmp] "=&l" (tmp),            // %2
+              [storage] "+Q" (storage)      // %3
+            : [value] "r" (v)               // %4
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        return !!exchange(storage, (storage_type)1, order);
+    }
+
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        store(storage, 0, order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+
+template< >
+struct operations< 1u, false > :
+    public operations< 4u, false >
+{
+    typedef operations< 4u, false > base_type;
+    typedef base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        uint32_t tmp;
+        storage_type original, result;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "1:\n"
+            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
+            "add     %[result], %[original], %[value]\n"  // result = original + value
+            "uxtb    %[result], %[result]\n"              // zero extend result from 8 to 32 bits
+            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n"                        // flags = tmp==0
+            "bne     1b\n"                                // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [original] "=&r" (original),  // %0
+              [result] "=&r" (result),      // %1
+              [tmp] "=&l" (tmp),            // %2
+              [storage] "+Q" (storage)      // %3
+            : [value] "r" (v)               // %4
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        uint32_t tmp;
+        storage_type original, result;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "1:\n"
+            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
+            "sub     %[result], %[original], %[value]\n"  // result = original - value
+            "uxtb    %[result], %[result]\n"              // zero extend result from 8 to 32 bits
+            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n"                        // flags = tmp==0
+            "bne     1b\n"                                // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [original] "=&r" (original),  // %0
+              [result] "=&r" (result),      // %1
+              [tmp] "=&l" (tmp),            // %2
+              [storage] "+Q" (storage)      // %3
+            : [value] "r" (v)               // %4
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+};
+
+template< >
+struct operations< 1u, true > :
+    public operations< 4u, true >
+{
+    typedef operations< 4u, true > base_type;
+    typedef base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        uint32_t tmp;
+        storage_type original, result;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "1:\n"
+            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
+            "add     %[result], %[original], %[value]\n"  // result = original + value
+            "sxtb    %[result], %[result]\n"              // sign extend result from 8 to 32 bits
+            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n"                        // flags = tmp==0
+            "bne     1b\n"                                // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [original] "=&r" (original),  // %0
+              [result] "=&r" (result),      // %1
+              [tmp] "=&l" (tmp),            // %2
+              [storage] "+Q" (storage)      // %3
+            : [value] "r" (v)               // %4
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        uint32_t tmp;
+        storage_type original, result;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "1:\n"
+            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
+            "sub     %[result], %[original], %[value]\n"  // result = original - value
+            "sxtb    %[result], %[result]\n"              // sign extend result from 8 to 32 bits
+            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n"                        // flags = tmp==0
+            "bne     1b\n"                                // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [original] "=&r" (original),  // %0
+              [result] "=&r" (result),      // %1
+              [tmp] "=&l" (tmp),            // %2
+              [storage] "+Q" (storage)      // %3
+            : [value] "r" (v)               // %4
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+};
+
+
+template< >
+struct operations< 2u, false > :
+    public operations< 4u, false >
+{
+    typedef operations< 4u, false > base_type;
+    typedef base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        uint32_t tmp;
+        storage_type original, result;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "1:\n"
+            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
+            "add     %[result], %[original], %[value]\n"  // result = original + value
+            "uxth    %[result], %[result]\n"              // zero extend result from 16 to 32 bits
+            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n"                        // flags = tmp==0
+            "bne     1b\n"                                // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [original] "=&r" (original),  // %0
+              [result] "=&r" (result),      // %1
+              [tmp] "=&l" (tmp),            // %2
+              [storage] "+Q" (storage)      // %3
+            : [value] "r" (v)               // %4
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        uint32_t tmp;
+        storage_type original, result;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "1:\n"
+            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
+            "sub     %[result], %[original], %[value]\n"  // result = original - value
+            "uxth    %[result], %[result]\n"              // zero extend result from 16 to 32 bits
+            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n"                        // flags = tmp==0
+            "bne     1b\n"                                // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [original] "=&r" (original),  // %0
+              [result] "=&r" (result),      // %1
+              [tmp] "=&l" (tmp),            // %2
+              [storage] "+Q" (storage)      // %3
+            : [value] "r" (v)               // %4
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+};
+
+template< >
+struct operations< 2u, true > :
+    public operations< 4u, true >
+{
+    typedef operations< 4u, true > base_type;
+    typedef base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        uint32_t tmp;
+        storage_type original, result;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "1:\n"
+            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
+            "add     %[result], %[original], %[value]\n"  // result = original + value
+            "sxth    %[result], %[result]\n"              // sign extend result from 16 to 32 bits
+            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n"                        // flags = tmp==0
+            "bne     1b\n"                                // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [original] "=&r" (original),  // %0
+              [result] "=&r" (result),      // %1
+              [tmp] "=&l" (tmp),            // %2
+              [storage] "+Q" (storage)      // %3
+            : [value] "r" (v)               // %4
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        uint32_t tmp;
+        storage_type original, result;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp])
+            "1:\n"
+            "ldrex   %[original], %[storage]\n"           // original = *(&storage)
+            "sub     %[result], %[original], %[value]\n"  // result = original - value
+            "sxth    %[result], %[result]\n"              // sign extend result from 16 to 32 bits
+            "strex   %[tmp], %[result], %[storage]\n"     // *(&storage) = result, tmp = store failed
+            "teq     %[tmp], #0\n"                        // flags = tmp==0
+            "bne     1b\n"                                // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp])
+            : [original] "=&r" (original),  // %0
+              [result] "=&r" (result),      // %1
+              [tmp] "=&l" (tmp),            // %2
+              [storage] "+Q" (storage)      // %3
+            : [value] "r" (v)               // %4
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+};
+
+
+#if defined(BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXD_STREXD)
+
+// Unlike 32-bit operations, for 64-bit loads and stores we must use ldrexd/strexd.
+// Any other instructions result in a non-atomic sequence of 32-bit accesses.
+// See "ARM Architecture Reference Manual ARMv7-A and ARMv7-R edition",
+// Section A3.5.3 "Atomicity in the ARM architecture".
+
+// In the asm blocks below we have to use 32-bit register pairs to compose 64-bit values.
+// In order to pass the 64-bit operands to/from asm blocks, we use undocumented gcc feature:
+// the lower half (Rt) of the operand is accessible normally, via the numbered placeholder (e.g. %0),
+// and the upper half (Rt2) - via the same placeholder with an 'H' after the '%' sign (e.g. %H0).
+// See: http://hardwarebug.org/2010/07/06/arm-inline-asm-secrets/
+
+template< bool Signed >
+struct operations< 8u, Signed > :
+    public gcc_arm_operations_base
+{
+    typedef typename make_storage_type< 8u, Signed >::type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        exchange(storage, v, order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original;
+        uint32_t tmp;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
+            "ldrexd %1, %H1, [%2]\n"
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
+            : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
+              "=&r" (original)   // %1
+            : "r" (&storage)     // %2
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original;
+        fence_before(order);
+        uint32_t tmp;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
+            "1:\n"
+            "ldrexd %1, %H1, [%3]\n"        // load the original value
+            "strexd %0, %2, %H2, [%3]\n"    // store the replacement, tmp = store failed
+            "teq    %0, #0\n"               // check if store succeeded
+            "bne    1b\n"
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
+            : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
+              "=&r" (original)   // %1
+            : "r" (v),           // %2
+              "r" (&storage)     // %3
+            : "cc", "memory"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        fence_before(success_order);
+        uint32_t tmp;
+        storage_type original, old_val = expected;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
+            "ldrexd   %1, %H1, [%3]\n"               // original = *(&storage)
+            "cmp      %1, %2\n"                      // flags = original.lo==old_val.lo
+            "ittt     eq\n"                          // [hint that the following 3 instructions are conditional on flags.equal]
+            "cmpeq    %H1, %H2\n"                    // if (flags.equal) flags = original.hi==old_val.hi
+            "strexdeq %0, %4, %H4, [%3]\n"           // if (flags.equal) *(&storage) = desired, tmp = store failed
+            "teqeq    %0, #0\n"                      // if (flags.equal) flags = tmp==0
+            "ite      eq\n"                          // [hint that the following 2 instructions are conditional on flags.equal]
+            "moveq    %2, #1\n"                      // if (flags.equal) old_val.lo = 1
+            "movne    %2, #0\n"                      // if (!flags.equal) old_val.lo = 0
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
+            : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
+              "=&r" (original),  // %1
+              "+r" (old_val)     // %2
+            : "r" (&storage),    // %3
+              "r" (desired)      // %4
+            : "cc", "memory"
+        );
+        const uint32_t success = (uint32_t)old_val;
+        if (success)
+            fence_after(success_order);
+        else
+            fence_after(failure_order);
+        expected = original;
+        return !!success;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        fence_before(success_order);
+        uint32_t tmp;
+        storage_type original, old_val = expected;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
+            "1:\n"
+            "ldrexd  %1, %H1, [%3]\n"               // original = *(&storage)
+            "cmp     %1, %2\n"                      // flags = original.lo==old_val.lo
+            "it      eq\n"                          // [hint that the following instruction is conditional on flags.equal]
+            "cmpeq   %H1, %H2\n"                    // if (flags.equal) flags = original.hi==old_val.hi
+            "bne     2f\n"                          // if (!flags.equal) goto end
+            "strexd  %0, %4, %H4, [%3]\n"           // *(&storage) = desired, tmp = store failed
+            "teq     %0, #0\n"                      // flags.equal = tmp == 0
+            "bne     1b\n"                          // if (flags.equal) goto retry
+            "2:\n"
+            "ite      eq\n"                         // [hint that the following 2 instructions are conditional on flags.equal]
+            "moveq    %2, #1\n"                     // if (flags.equal) old_val.lo = 1
+            "movne    %2, #0\n"                     // if (!flags.equal) old_val.lo = 0
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
+            : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
+              "=&r" (original),  // %1
+              "+r" (old_val)     // %2
+            : "r" (&storage),    // %3
+              "r" (desired)      // %4
+            : "cc", "memory"
+        );
+        const uint32_t success = (uint32_t)old_val;
+        if (success)
+            fence_after(success_order);
+        else
+            fence_after(failure_order);
+        expected = original;
+        return !!success;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        storage_type original, result;
+        uint32_t tmp;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
+            "1:\n"
+            "ldrexd  %1, %H1, [%3]\n"               // original = *(&storage)
+            "adds    %2, %1, %4\n"                  // result = original + value
+            "adc     %H2, %H1, %H4\n"
+            "strexd  %0, %2, %H2, [%3]\n"           // *(&storage) = result, tmp = store failed
+            "teq     %0, #0\n"                      // flags = tmp==0
+            "bne     1b\n"                          // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
+            : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
+              "=&r" (original),  // %1
+              "=&r" (result)     // %2
+            : "r" (&storage),    // %3
+              "r" (v)            // %4
+            : "cc", "memory"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        storage_type original, result;
+        uint32_t tmp;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
+            "1:\n"
+            "ldrexd  %1, %H1, [%3]\n"               // original = *(&storage)
+            "subs    %2, %1, %4\n"                  // result = original - value
+            "sbc     %H2, %H1, %H4\n"
+            "strexd  %0, %2, %H2, [%3]\n"           // *(&storage) = result, tmp = store failed
+            "teq     %0, #0\n"                      // flags = tmp==0
+            "bne     1b\n"                          // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
+            : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
+              "=&r" (original),  // %1
+              "=&r" (result)     // %2
+            : "r" (&storage),    // %3
+              "r" (v)            // %4
+            : "cc", "memory"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        storage_type original, result;
+        uint32_t tmp;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
+            "1:\n"
+            "ldrexd  %1, %H1, [%3]\n"               // original = *(&storage)
+            "and     %2, %1, %4\n"                  // result = original & value
+            "and     %H2, %H1, %H4\n"
+            "strexd  %0, %2, %H2, [%3]\n"           // *(&storage) = result, tmp = store failed
+            "teq     %0, #0\n"                      // flags = tmp==0
+            "bne     1b\n"                          // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
+            : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
+              "=&r" (original),  // %1
+              "=&r" (result)     // %2
+            : "r" (&storage),    // %3
+              "r" (v)            // %4
+            : "cc", "memory"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        storage_type original, result;
+        uint32_t tmp;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
+            "1:\n"
+            "ldrexd  %1, %H1, [%3]\n"               // original = *(&storage)
+            "orr     %2, %1, %4\n"                  // result = original | value
+            "orr     %H2, %H1, %H4\n"
+            "strexd  %0, %2, %H2, [%3]\n"           // *(&storage) = result, tmp = store failed
+            "teq     %0, #0\n"                      // flags = tmp==0
+            "bne     1b\n"                          // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
+            : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
+              "=&r" (original),  // %1
+              "=&r" (result)     // %2
+            : "r" (&storage),    // %3
+              "r" (v)            // %4
+            : "cc", "memory"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        storage_type original, result;
+        uint32_t tmp;
+        __asm__ __volatile__
+        (
+            BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0)
+            "1:\n"
+            "ldrexd  %1, %H1, [%3]\n"               // original = *(&storage)
+            "eor     %2, %1, %4\n"                  // result = original ^ value
+            "eor     %H2, %H1, %H4\n"
+            "strexd  %0, %2, %H2, [%3]\n"           // *(&storage) = result, tmp = store failed
+            "teq     %0, #0\n"                      // flags = tmp==0
+            "bne     1b\n"                          // if (!flags.equal) goto retry
+            BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0)
+            : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0
+              "=&r" (original),  // %1
+              "=&r" (result)     // %2
+            : "r" (&storage),    // %3
+              "r" (v)            // %4
+            : "cc", "memory"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        return !!exchange(storage, (storage_type)1, order);
+    }
+
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        store(storage, 0, order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+#endif // defined(BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXD_STREXD)
+
+
+BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        gcc_arm_operations_base::hardware_full_fence();
+}
+
+BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        __asm__ __volatile__ ("" ::: "memory");
+}
+
+} // namespace detail
+} // namespace atomics
+} // namespace autoboost
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_ARM_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/ops_gcc_atomic.hpp b/contrib/autoboost/boost/atomic/detail/ops_gcc_atomic.hpp
new file mode 100644
index 000000000..90b8784d0
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/ops_gcc_atomic.hpp
@@ -0,0 +1,380 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_gcc_atomic.hpp
+ *
+ * This header contains implementation of the \c operations template.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_ATOMIC_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_GCC_ATOMIC_HPP_INCLUDED_
+
+#include <boost/memory_order.hpp>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/operations_fwd.hpp>
+#include <boost/atomic/capabilities.hpp>
+#if defined(__clang__) && (defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B) || defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B))
+#include <boost/atomic/detail/ops_gcc_x86_dcas.hpp>
+#include <boost/atomic/detail/ops_cas_based.hpp>
+#endif
+
+#if __GCC_ATOMIC_LLONG_LOCK_FREE != BOOST_ATOMIC_LLONG_LOCK_FREE || __GCC_ATOMIC_LONG_LOCK_FREE != BOOST_ATOMIC_LONG_LOCK_FREE ||\
+    __GCC_ATOMIC_INT_LOCK_FREE != BOOST_ATOMIC_INT_LOCK_FREE || __GCC_ATOMIC_SHORT_LOCK_FREE != BOOST_ATOMIC_SHORT_LOCK_FREE ||\
+    __GCC_ATOMIC_CHAR_LOCK_FREE != BOOST_ATOMIC_CHAR_LOCK_FREE || __GCC_ATOMIC_BOOL_LOCK_FREE != BOOST_ATOMIC_BOOL_LOCK_FREE ||\
+    __GCC_ATOMIC_WCHAR_T_LOCK_FREE != BOOST_ATOMIC_WCHAR_T_LOCK_FREE
+// There are platforms where we need to use larger storage types
+#include <boost/atomic/detail/int_sizes.hpp>
+#include <boost/atomic/detail/ops_extending_cas_based.hpp>
+#endif
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if defined(__INTEL_COMPILER)
+// This is used to suppress warning #32013 described below for Intel Compiler.
+// In debug builds the compiler does not inline any functions, so basically
+// every atomic function call results in this warning. I don't know any other
+// way to selectively disable just this one warning.
+#pragma system_header
+#endif
+
+namespace autoboost {
+namespace atomics {
+namespace detail {
+
+/*!
+ * The function converts \c boost::memory_order values to the compiler-specific constants.
+ *
+ * NOTE: The intention is that the function is optimized away by the compiler, and the
+ *       compiler-specific constants are passed to the intrinsics. I know constexpr doesn't
+ *       work in this case because the standard atomics interface require memory ordering
+ *       constants to be passed as function arguments, at which point they stop being constexpr.
+ *       However it is crucial that the compiler sees constants and not runtime values,
+ *       because otherwise it just ignores the ordering value and always uses seq_cst.
+ *       This is the case with Intel C++ Compiler 14.0.3 (Composer XE 2013 SP1, update 3) and
+ *       gcc 4.8.2. Intel Compiler issues a warning in this case:
+ *
+ *       warning #32013: Invalid memory order specified. Defaulting to seq_cst memory order.
+ *
+ *       while gcc acts silently.
+ *
+ *       To mitigate the problem ALL functions, including the atomic<> members must be
+ *       declared with BOOST_FORCEINLINE. In this case the compilers are able to see that
+ *       all functions are called with constant orderings and call intrinstcts properly.
+ *
+ *       Unfortunately, this still doesn't work in debug mode as the compiler doesn't
+ *       inline functions even when marked with BOOST_FORCEINLINE. In this case all atomic
+ *       operaions will be executed with seq_cst semantics.
+ */
+BOOST_FORCEINLINE BOOST_CONSTEXPR int convert_memory_order_to_gcc(memory_order order) BOOST_NOEXCEPT
+{
+    return (order == memory_order_relaxed ? __ATOMIC_RELAXED : (order == memory_order_consume ? __ATOMIC_CONSUME :
+        (order == memory_order_acquire ? __ATOMIC_ACQUIRE : (order == memory_order_release ? __ATOMIC_RELEASE :
+        (order == memory_order_acq_rel ? __ATOMIC_ACQ_REL : __ATOMIC_SEQ_CST)))));
+}
+
+template< typename T >
+struct gcc_atomic_operations
+{
+    typedef T storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        __atomic_store_n(&storage, v, atomics::detail::convert_memory_order_to_gcc(order));
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        return __atomic_load_n(&storage, atomics::detail::convert_memory_order_to_gcc(order));
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        return __atomic_fetch_add(&storage, v, atomics::detail::convert_memory_order_to_gcc(order));
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        return __atomic_fetch_sub(&storage, v, atomics::detail::convert_memory_order_to_gcc(order));
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        return __atomic_exchange_n(&storage, v, atomics::detail::convert_memory_order_to_gcc(order));
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        return __atomic_compare_exchange_n
+        (
+            &storage, &expected, desired, false,
+            atomics::detail::convert_memory_order_to_gcc(success_order),
+            atomics::detail::convert_memory_order_to_gcc(failure_order)
+        );
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        return __atomic_compare_exchange_n
+        (
+            &storage, &expected, desired, true,
+            atomics::detail::convert_memory_order_to_gcc(success_order),
+            atomics::detail::convert_memory_order_to_gcc(failure_order)
+        );
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        return __atomic_fetch_and(&storage, v, atomics::detail::convert_memory_order_to_gcc(order));
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        return __atomic_fetch_or(&storage, v, atomics::detail::convert_memory_order_to_gcc(order));
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        return __atomic_fetch_xor(&storage, v, atomics::detail::convert_memory_order_to_gcc(order));
+    }
+
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        return __atomic_test_and_set(&storage, atomics::detail::convert_memory_order_to_gcc(order));
+    }
+
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        __atomic_clear(const_cast< storage_type* >(&storage), atomics::detail::convert_memory_order_to_gcc(order));
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile& storage) BOOST_NOEXCEPT
+    {
+        return __atomic_is_lock_free(sizeof(storage_type), &storage);
+    }
+};
+
+#if BOOST_ATOMIC_INT128_LOCK_FREE > 0
+#if defined(__clang__) && defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B)
+
+// Workaround for clang bug: http://llvm.org/bugs/show_bug.cgi?id=19149
+// Clang 3.4 does not implement 128-bit __atomic* intrinsics even though it defines __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16
+template< bool Signed >
+struct operations< 16u, Signed > :
+    public cas_based_operations< gcc_dcas_x86_64< Signed > >
+{
+};
+
+#else
+
+template< bool Signed >
+struct operations< 16u, Signed > :
+    public gcc_atomic_operations< typename make_storage_type< 16u, Signed >::type >
+{
+};
+
+#endif
+#endif
+
+
+#if BOOST_ATOMIC_INT64_LOCK_FREE > 0
+#if defined(__clang__) && defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B)
+
+// Workaround for clang bug http://llvm.org/bugs/show_bug.cgi?id=19355
+template< bool Signed >
+struct operations< 8u, Signed > :
+    public cas_based_operations< gcc_dcas_x86< Signed > >
+{
+};
+
+#elif (BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 8 && __GCC_ATOMIC_LLONG_LOCK_FREE != BOOST_ATOMIC_LLONG_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 8 && __GCC_ATOMIC_LONG_LOCK_FREE != BOOST_ATOMIC_LONG_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_INT == 8 && __GCC_ATOMIC_INT_LOCK_FREE != BOOST_ATOMIC_INT_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 8 && __GCC_ATOMIC_SHORT_LOCK_FREE != BOOST_ATOMIC_SHORT_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 8 && __GCC_ATOMIC_WCHAR_T_LOCK_FREE != BOOST_ATOMIC_WCHAR_T_LOCK_FREE)
+
+#define BOOST_ATOMIC_DETAIL_INT64_EXTENDED
+
+template< bool Signed >
+struct operations< 8u, Signed > :
+    public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 16u, Signed >::type >, 8u, Signed >
+{
+};
+
+#else
+
+template< bool Signed >
+struct operations< 8u, Signed > :
+    public gcc_atomic_operations< typename make_storage_type< 8u, Signed >::type >
+{
+};
+
+#endif
+#endif
+
+#if BOOST_ATOMIC_INT32_LOCK_FREE > 0
+#if (BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 4 && __GCC_ATOMIC_LLONG_LOCK_FREE != BOOST_ATOMIC_LLONG_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 4 && __GCC_ATOMIC_LONG_LOCK_FREE != BOOST_ATOMIC_LONG_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_INT == 4 && __GCC_ATOMIC_INT_LOCK_FREE != BOOST_ATOMIC_INT_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 4 && __GCC_ATOMIC_SHORT_LOCK_FREE != BOOST_ATOMIC_SHORT_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 4 && __GCC_ATOMIC_WCHAR_T_LOCK_FREE != BOOST_ATOMIC_WCHAR_T_LOCK_FREE)
+
+#define BOOST_ATOMIC_DETAIL_INT32_EXTENDED
+
+#if !defined(BOOST_ATOMIC_DETAIL_INT64_EXTENDED)
+
+template< bool Signed >
+struct operations< 4u, Signed > :
+    public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 8u, Signed >::type >, 4u, Signed >
+{
+};
+
+#else // !defined(BOOST_ATOMIC_DETAIL_INT64_EXTENDED)
+
+template< bool Signed >
+struct operations< 4u, Signed > :
+    public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 16u, Signed >::type >, 4u, Signed >
+{
+};
+
+#endif // !defined(BOOST_ATOMIC_DETAIL_INT64_EXTENDED)
+
+#else
+
+template< bool Signed >
+struct operations< 4u, Signed > :
+    public gcc_atomic_operations< typename make_storage_type< 4u, Signed >::type >
+{
+};
+
+#endif
+#endif
+
+#if BOOST_ATOMIC_INT16_LOCK_FREE > 0
+#if (BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 2 && __GCC_ATOMIC_LLONG_LOCK_FREE != BOOST_ATOMIC_LLONG_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 2 && __GCC_ATOMIC_LONG_LOCK_FREE != BOOST_ATOMIC_LONG_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_INT == 2 && __GCC_ATOMIC_INT_LOCK_FREE != BOOST_ATOMIC_INT_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 2 && __GCC_ATOMIC_SHORT_LOCK_FREE != BOOST_ATOMIC_SHORT_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 2 && __GCC_ATOMIC_WCHAR_T_LOCK_FREE != BOOST_ATOMIC_WCHAR_T_LOCK_FREE)
+
+#define BOOST_ATOMIC_DETAIL_INT16_EXTENDED
+
+#if !defined(BOOST_ATOMIC_DETAIL_INT32_EXTENDED)
+
+template< bool Signed >
+struct operations< 2u, Signed > :
+    public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 4u, Signed >::type >, 2u, Signed >
+{
+};
+
+#elif !defined(BOOST_ATOMIC_DETAIL_INT64_EXTENDED)
+
+template< bool Signed >
+struct operations< 2u, Signed > :
+    public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 8u, Signed >::type >, 2u, Signed >
+{
+};
+
+#else
+
+template< bool Signed >
+struct operations< 2u, Signed > :
+    public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 16u, Signed >::type >, 2u, Signed >
+{
+};
+
+#endif
+
+#else
+
+template< bool Signed >
+struct operations< 2u, Signed > :
+    public gcc_atomic_operations< typename make_storage_type< 2u, Signed >::type >
+{
+};
+
+#endif
+#endif
+
+#if BOOST_ATOMIC_INT8_LOCK_FREE > 0
+#if (BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 1 && __GCC_ATOMIC_LLONG_LOCK_FREE != BOOST_ATOMIC_LLONG_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 1 && __GCC_ATOMIC_LONG_LOCK_FREE != BOOST_ATOMIC_LONG_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_INT == 1 && __GCC_ATOMIC_INT_LOCK_FREE != BOOST_ATOMIC_INT_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 1 && __GCC_ATOMIC_SHORT_LOCK_FREE != BOOST_ATOMIC_SHORT_LOCK_FREE) ||\
+    (BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 1 && __GCC_ATOMIC_WCHAR_T_LOCK_FREE != BOOST_ATOMIC_WCHAR_T_LOCK_FREE) ||\
+    (__GCC_ATOMIC_CHAR_LOCK_FREE != BOOST_ATOMIC_CHAR_LOCK_FREE) ||\
+    (__GCC_ATOMIC_BOOL_LOCK_FREE != BOOST_ATOMIC_BOOL_LOCK_FREE)
+
+#if !defined(BOOST_ATOMIC_DETAIL_INT16_EXTENDED)
+
+template< bool Signed >
+struct operations< 1u, Signed > :
+    public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 2u, Signed >::type >, 1u, Signed >
+{
+};
+
+#elif !defined(BOOST_ATOMIC_DETAIL_INT32_EXTENDED)
+
+template< bool Signed >
+struct operations< 1u, Signed > :
+    public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 4u, Signed >::type >, 1u, Signed >
+{
+};
+
+#elif !defined(BOOST_ATOMIC_DETAIL_INT64_EXTENDED)
+
+template< bool Signed >
+struct operations< 1u, Signed > :
+    public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 8u, Signed >::type >, 1u, Signed >
+{
+};
+
+#else
+
+template< bool Signed >
+struct operations< 1u, Signed > :
+    public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 16u, Signed >::type >, 1u, Signed >
+{
+};
+
+#endif
+
+#else
+
+template< bool Signed >
+struct operations< 1u, Signed > :
+    public gcc_atomic_operations< typename make_storage_type< 1u, Signed >::type >
+{
+};
+
+#endif
+#endif
+
+#undef BOOST_ATOMIC_DETAIL_INT16_EXTENDED
+#undef BOOST_ATOMIC_DETAIL_INT32_EXTENDED
+#undef BOOST_ATOMIC_DETAIL_INT64_EXTENDED
+
+BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT
+{
+    __atomic_thread_fence(atomics::detail::convert_memory_order_to_gcc(order));
+}
+
+BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT
+{
+    __atomic_signal_fence(atomics::detail::convert_memory_order_to_gcc(order));
+}
+
+} // namespace detail
+} // namespace atomics
+} // namespace autoboost
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_ATOMIC_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/ops_gcc_ppc.hpp b/contrib/autoboost/boost/atomic/detail/ops_gcc_ppc.hpp
new file mode 100644
index 000000000..24cc3873c
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/ops_gcc_ppc.hpp
@@ -0,0 +1,775 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2013 Tim Blechmann
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_gcc_ppc.hpp
+ *
+ * This header contains implementation of the \c operations template.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_PPC_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_GCC_PPC_HPP_INCLUDED_
+
+#include <boost/memory_order.hpp>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/operations_fwd.hpp>
+#include <boost/atomic/capabilities.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace autoboost {
+namespace atomics {
+namespace detail {
+
+/*
+    Refer to: Motorola: "Programming Environments Manual for 32-Bit
+    Implementations of the PowerPC Architecture", Appendix E:
+    "Synchronization Programming Examples" for an explanation of what is
+    going on here (can be found on the web at various places by the
+    name "MPCFPE32B.pdf", Google is your friend...)
+
+    Most of the atomic operations map to instructions in a relatively
+    straight-forward fashion, but "load"s may at first glance appear
+    a bit strange as they map to:
+
+            lwz %rX, addr
+            cmpw %rX, %rX
+            bne- 1f
+        1:
+
+    That is, the CPU is forced to perform a branch that "formally" depends
+    on the value retrieved from memory. This scheme has an overhead of
+    about 1-2 clock cycles per load, but it allows to map "acquire" to
+    the "isync" instruction instead of "sync" uniformly and for all type
+    of atomic operations. Since "isync" has a cost of about 15 clock
+    cycles, while "sync" hast a cost of about 50 clock cycles, the small
+    penalty to atomic loads more than compensates for this.
+
+    Byte- and halfword-sized atomic values are realized by encoding the
+    value to be represented into a word, performing sign/zero extension
+    as appropriate. This means that after add/sub operations the value
+    needs fixing up to accurately preserve the wrap-around semantic of
+    the smaller type. (Nothing special needs to be done for the bit-wise
+    and the "exchange type" operators as the compiler already sees to
+    it that values carried in registers are extended appropriately and
+    everything falls into place naturally).
+
+    The register constraint "b"  instructs gcc to use any register
+    except r0; this is sometimes required because the encoding for
+    r0 is used to signify "constant zero" in a number of instructions,
+    making r0 unusable in this place. For simplicity this constraint
+    is used everywhere since I am to lazy to look this up on a
+    per-instruction basis, and ppc has enough registers for this not
+    to pose a problem.
+*/
+
+// A note about memory_order_consume. Technically, this architecture allows to avoid
+// unnecessary memory barrier after consume load since it supports data dependency ordering.
+// However, some compiler optimizations may break a seemingly valid code relying on data
+// dependency tracking by injecting bogus branches to aid out of order execution.
+// This may happen not only in Boost.Atomic code but also in user's code, which we have no
+// control of. See this thread: http://lists.boost.org/Archives/boost/2014/06/213890.php.
+// For this reason we promote memory_order_consume to memory_order_acquire.
+
+struct gcc_ppc_operations_base
+{
+    static BOOST_FORCEINLINE void fence_before(memory_order order) BOOST_NOEXCEPT
+    {
+#if defined(__powerpc64__)
+        if (order == memory_order_seq_cst)
+            __asm__ __volatile__ ("sync" ::: "memory");
+        else if ((order & memory_order_release) != 0)
+            __asm__ __volatile__ ("lwsync" ::: "memory");
+#else
+        if ((order & memory_order_release) != 0)
+            __asm__ __volatile__ ("sync" ::: "memory");
+#endif
+    }
+
+    static BOOST_FORCEINLINE void fence_after(memory_order order) BOOST_NOEXCEPT
+    {
+        if ((order & (memory_order_consume | memory_order_acquire)) != 0)
+            __asm__ __volatile__ ("isync" ::: "memory");
+    }
+
+    static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT
+    {
+        if (order == memory_order_seq_cst)
+            __asm__ __volatile__ ("sync" ::: "memory");
+    }
+};
+
+
+template< bool Signed >
+struct operations< 4u, Signed > :
+    public gcc_ppc_operations_base
+{
+    typedef typename make_storage_type< 4u, Signed >::type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "stw %1, %0\n"
+            : "+m" (storage)
+            : "r" (v)
+        );
+        fence_after_store(order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v;
+        __asm__ __volatile__
+        (
+            "lwz %0, %1\n"
+            "cmpw %0, %0\n"
+            "bne- 1f\n"
+            "1:\n"
+            : "=&r" (v)
+            : "m" (storage)
+            : "cr0"
+        );
+        fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "lwarx %0,%y1\n"
+            "stwcx. %2,%y1\n"
+            "bne- 1b\n"
+            : "=&b" (original), "+Z" (storage)
+            : "b" (v)
+            : "cr0"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        int success;
+        fence_before(success_order);
+        __asm__ __volatile__
+        (
+            "li %1, 0\n"
+            "lwarx %0,%y2\n"
+            "cmpw %0, %3\n"
+            "bne- 1f\n"
+            "stwcx. %4,%y2\n"
+            "bne- 1f\n"
+            "li %1, 1\n"
+            "1:"
+            : "=&b" (expected), "=&b" (success), "+Z" (storage)
+            : "b" (expected), "b" (desired)
+            : "cr0"
+        );
+        if (success)
+            fence_after(success_order);
+        else
+            fence_after(failure_order);
+        return !!success;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        int success;
+        fence_before(success_order);
+        __asm__ __volatile__
+        (
+            "li %1, 0\n"
+            "0: lwarx %0,%y2\n"
+            "cmpw %0, %3\n"
+            "bne- 1f\n"
+            "stwcx. %4,%y2\n"
+            "bne- 0b\n"
+            "li %1, 1\n"
+            "1:"
+            : "=&b" (expected), "=&b" (success), "+Z" (storage)
+            : "b" (expected), "b" (desired)
+            : "cr0"
+        );
+        if (success)
+            fence_after(success_order);
+        else
+            fence_after(failure_order);
+        return !!success;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "lwarx %0,%y2\n"
+            "add %1,%0,%3\n"
+            "stwcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "lwarx %0,%y2\n"
+            "sub %1,%0,%3\n"
+            "stwcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "lwarx %0,%y2\n"
+            "and %1,%0,%3\n"
+            "stwcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "lwarx %0,%y2\n"
+            "or %1,%0,%3\n"
+            "stwcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "lwarx %0,%y2\n"
+            "xor %1,%0,%3\n"
+            "stwcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        return !!exchange(storage, (storage_type)1, order);
+    }
+
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        store(storage, 0, order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+
+template< >
+struct operations< 1u, false > :
+    public operations< 4u, false >
+{
+    typedef operations< 4u, false > base_type;
+    typedef base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "lwarx %0,%y2\n"
+            "add %1,%0,%3\n"
+            "rlwinm %1, %1, 0, 0xff\n"
+            "stwcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "lwarx %0,%y2\n"
+            "sub %1,%0,%3\n"
+            "rlwinm %1, %1, 0, 0xff\n"
+            "stwcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+};
+
+template< >
+struct operations< 1u, true > :
+    public operations< 4u, true >
+{
+    typedef operations< 4u, true > base_type;
+    typedef base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "lwarx %0,%y2\n"
+            "add %1,%0,%3\n"
+            "extsb %1, %1\n"
+            "stwcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "lwarx %0,%y2\n"
+            "sub %1,%0,%3\n"
+            "extsb %1, %1\n"
+            "stwcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+};
+
+
+template< >
+struct operations< 2u, false > :
+    public operations< 4u, false >
+{
+    typedef operations< 4u, false > base_type;
+    typedef base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "lwarx %0,%y2\n"
+            "add %1,%0,%3\n"
+            "rlwinm %1, %1, 0, 0xffff\n"
+            "stwcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "lwarx %0,%y2\n"
+            "sub %1,%0,%3\n"
+            "rlwinm %1, %1, 0, 0xffff\n"
+            "stwcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+};
+
+template< >
+struct operations< 2u, true > :
+    public operations< 4u, true >
+{
+    typedef operations< 4u, true > base_type;
+    typedef base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "lwarx %0,%y2\n"
+            "add %1,%0,%3\n"
+            "extsh %1, %1\n"
+            "stwcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "lwarx %0,%y2\n"
+            "sub %1,%0,%3\n"
+            "extsh %1, %1\n"
+            "stwcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+};
+
+
+#if defined(__powerpc64__)
+
+template< bool Signed >
+struct operations< 8u, Signed > :
+    public gcc_ppc_operations_base
+{
+    typedef typename make_storage_type< 8u, Signed >::type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "std %1, %0\n"
+            : "+m" (storage)
+            : "r" (v)
+        );
+        fence_after_store(order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v;
+        __asm__ __volatile__
+        (
+            "ld %0, %1\n"
+            "cmpd %0, %0\n"
+            "bne- 1f\n"
+            "1:\n"
+            : "=&b" (v)
+            : "m" (storage)
+            : "cr0"
+        );
+        fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldarx %0,%y1\n"
+            "stdcx. %2,%y1\n"
+            "bne- 1b\n"
+            : "=&b" (original), "+Z" (storage)
+            : "b" (v)
+            : "cr0"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        int success;
+        fence_before(success_order);
+        __asm__ __volatile__
+        (
+            "li %1, 0\n"
+            "ldarx %0,%y2\n"
+            "cmpd %0, %3\n"
+            "bne- 1f\n"
+            "stdcx. %4,%y2\n"
+            "bne- 1f\n"
+            "li %1, 1\n"
+            "1:"
+            : "=&b" (expected), "=&b" (success), "+Z" (storage)
+            : "b" (expected), "b" (desired)
+            : "cr0"
+        );
+        if (success)
+            fence_after(success_order);
+        else
+            fence_after(failure_order);
+        return !!success;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        int success;
+        fence_before(success_order);
+        __asm__ __volatile__
+        (
+            "li %1, 0\n"
+            "0: ldarx %0,%y2\n"
+            "cmpd %0, %3\n"
+            "bne- 1f\n"
+            "stdcx. %4,%y2\n"
+            "bne- 0b\n"
+            "li %1, 1\n"
+            "1:"
+            : "=&b" (expected), "=&b" (success), "+Z" (storage)
+            : "b" (expected), "b" (desired)
+            : "cr0"
+        );
+        if (success)
+            fence_after(success_order);
+        else
+            fence_after(failure_order);
+        return !!success;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldarx %0,%y2\n"
+            "add %1,%0,%3\n"
+            "stdcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldarx %0,%y2\n"
+            "sub %1,%0,%3\n"
+            "stdcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldarx %0,%y2\n"
+            "and %1,%0,%3\n"
+            "stdcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldarx %0,%y2\n"
+            "or %1,%0,%3\n"
+            "stdcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type original, tmp;
+        fence_before(order);
+        __asm__ __volatile__
+        (
+            "1:\n"
+            "ldarx %0,%y2\n"
+            "xor %1,%0,%3\n"
+            "stdcx. %1,%y2\n"
+            "bne- 1b\n"
+            : "=&b" (original), "=&b" (tmp), "+Z" (storage)
+            : "b" (v)
+            : "cc"
+        );
+        fence_after(order);
+        return original;
+    }
+
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        return !!exchange(storage, (storage_type)1, order);
+    }
+
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        store(storage, 0, order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+#endif // defined(__powerpc64__)
+
+
+BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT
+{
+    switch (order)
+    {
+    case memory_order_consume:
+    case memory_order_acquire:
+        __asm__ __volatile__ ("isync" ::: "memory");
+        break;
+    case memory_order_release:
+#if defined(__powerpc64__)
+        __asm__ __volatile__ ("lwsync" ::: "memory");
+        break;
+#endif
+    case memory_order_acq_rel:
+    case memory_order_seq_cst:
+        __asm__ __volatile__ ("sync" ::: "memory");
+        break;
+    default:;
+    }
+}
+
+BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        __asm__ __volatile__ ("" ::: "memory");
+}
+
+} // namespace detail
+} // namespace atomics
+} // namespace autoboost
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_PPC_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/ops_gcc_sparc.hpp b/contrib/autoboost/boost/atomic/detail/ops_gcc_sparc.hpp
new file mode 100644
index 000000000..92e279066
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/ops_gcc_sparc.hpp
@@ -0,0 +1,245 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2010 Helge Bahmann
+ * Copyright (c) 2013 Tim Blechmann
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_gcc_sparc.hpp
+ *
+ * This header contains implementation of the \c operations template.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_SPARC_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_GCC_SPARC_HPP_INCLUDED_
+
+#include <boost/memory_order.hpp>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/operations_fwd.hpp>
+#include <boost/atomic/capabilities.hpp>
+#include <boost/atomic/detail/ops_cas_based.hpp>
+#include <boost/atomic/detail/ops_extending_cas_based.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace autoboost {
+namespace atomics {
+namespace detail {
+
+struct gcc_sparc_cas_base
+{
+    static BOOST_FORCEINLINE void fence_before(memory_order order) BOOST_NOEXCEPT
+    {
+        if (order == memory_order_seq_cst)
+            __asm__ __volatile__ ("membar #Sync" ::: "memory");
+        else if ((order & memory_order_release) != 0)
+            __asm__ __volatile__ ("membar #StoreStore | #LoadStore" ::: "memory");
+    }
+
+    static BOOST_FORCEINLINE void fence_after(memory_order order) BOOST_NOEXCEPT
+    {
+        if (order == memory_order_seq_cst)
+            __asm__ __volatile__ ("membar #Sync" ::: "memory");
+        else if ((order & (memory_order_consume | memory_order_acquire)) != 0)
+            __asm__ __volatile__ ("membar #StoreStore | #LoadStore" ::: "memory");
+    }
+
+    static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT
+    {
+        if (order == memory_order_seq_cst)
+            __asm__ __volatile__ ("membar #Sync" ::: "memory");
+    }
+};
+
+template< bool Signed >
+struct gcc_sparc_cas32 :
+    public gcc_sparc_cas_base
+{
+    typedef typename make_storage_type< 4u, Signed >::type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before_store(order);
+        storage = v;
+        fence_after_store(order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v = storage;
+        fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        fence_before(success_order);
+        storage_type previous = expected;
+        __asm__ __volatile__
+        (
+            "cas [%1], %2, %0"
+            : "+r" (desired)
+            : "r" (&storage), "r" (previous)
+            : "memory"
+        );
+        const bool success = (desired == previous);
+        if (success)
+            fence_after(success_order);
+        else
+            fence_after(failure_order);
+        expected = desired;
+        return success;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        return compare_exchange_strong(storage, expected, desired, success_order, failure_order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+template< bool Signed >
+struct operations< 4u, Signed > :
+    public cas_based_operations< gcc_sparc_cas32< Signed > >
+{
+    typedef cas_based_operations< gcc_sparc_cas32< Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before(order);
+        __asm__ __volatile__
+        (
+            "swap [%1], %0"
+            : "+r" (v)
+            : "r" (&storage)
+            : "memory"
+        );
+        base_type::fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        return !!exchange(storage, (storage_type)1, order);
+    }
+};
+
+template< bool Signed >
+struct operations< 1u, Signed > :
+    public extending_cas_based_operations< operations< 4u, Signed >, 1u, Signed >
+{
+};
+
+template< bool Signed >
+struct operations< 2u, Signed > :
+    public extending_cas_based_operations< operations< 4u, Signed >, 2u, Signed >
+{
+};
+
+template< bool Signed >
+struct gcc_sparc_cas64 :
+    public gcc_sparc_cas_base
+{
+    typedef typename make_storage_type< 8u, Signed >::type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before_store(order);
+        storage = v;
+        fence_after_store(order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v = storage;
+        fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        fence_before(success_order);
+        storage_type previous = expected;
+        __asm__ __volatile__
+        (
+            "casx [%1], %2, %0"
+            : "+r" (desired)
+            : "r" (&storage), "r" (previous)
+            : "memory"
+        );
+        const bool success = (desired == previous);
+        if (success)
+            fence_after(success_order);
+        else
+            fence_after(failure_order);
+        expected = desired;
+        return success;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        return compare_exchange_strong(storage, expected, desired, success_order, failure_order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+template< bool Signed >
+struct operations< 8u, Signed > :
+    public cas_based_operations< gcc_sparc_cas64< Signed > >
+{
+};
+
+
+BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT
+{
+    switch (order)
+    {
+    case memory_order_release:
+        __asm__ __volatile__ ("membar #StoreStore | #LoadStore" ::: "memory");
+        break;
+    case memory_order_consume:
+    case memory_order_acquire:
+        __asm__ __volatile__ ("membar #LoadLoad | #LoadStore" ::: "memory");
+        break;
+    case memory_order_acq_rel:
+        __asm__ __volatile__ ("membar #LoadLoad | #LoadStore | #StoreStore" ::: "memory");
+        break;
+    case memory_order_seq_cst:
+        __asm__ __volatile__ ("membar #Sync" ::: "memory");
+        break;
+    case memory_order_relaxed:
+    default:
+        break;
+    }
+}
+
+BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        __asm__ __volatile__ ("" ::: "memory");
+}
+
+} // namespace detail
+} // namespace atomics
+} // namespace autoboost
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_SPARC_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/ops_gcc_sync.hpp b/contrib/autoboost/boost/atomic/detail/ops_gcc_sync.hpp
new file mode 100644
index 000000000..3fb17f78e
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/ops_gcc_sync.hpp
@@ -0,0 +1,237 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2011 Helge Bahmann
+ * Copyright (c) 2013 Tim Blechmann
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_gcc_sync.hpp
+ *
+ * This header contains implementation of the \c operations template.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_SYNC_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_GCC_SYNC_HPP_INCLUDED_
+
+#include <boost/memory_order.hpp>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/operations_fwd.hpp>
+#include <boost/atomic/detail/ops_extending_cas_based.hpp>
+#include <boost/atomic/capabilities.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace autoboost {
+namespace atomics {
+namespace detail {
+
+struct gcc_sync_operations_base
+{
+    static BOOST_FORCEINLINE void fence_before_store(memory_order order) BOOST_NOEXCEPT
+    {
+        if ((order & memory_order_release) != 0)
+            __sync_synchronize();
+    }
+
+    static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT
+    {
+        if (order == memory_order_seq_cst)
+            __sync_synchronize();
+    }
+
+    static BOOST_FORCEINLINE void fence_after_load(memory_order order) BOOST_NOEXCEPT
+    {
+        if ((order & (memory_order_acquire | memory_order_consume)) != 0)
+            __sync_synchronize();
+    }
+};
+
+template< typename T >
+struct gcc_sync_operations :
+    public gcc_sync_operations_base
+{
+    typedef T storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before_store(order);
+        storage = v;
+        fence_after_store(order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v = storage;
+        fence_after_load(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return __sync_fetch_and_add(&storage, v);
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return __sync_fetch_and_sub(&storage, v);
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        // GCC docs mention that not all architectures may support full exchange semantics for this intrinsic. However, GCC's implementation of
+        // std::atomic<> uses this intrinsic unconditionally. We do so as well. In case if some architectures actually don't support this, we can always
+        // add a check here and fall back to a CAS loop.
+        if ((order & memory_order_release) != 0)
+            __sync_synchronize();
+        return __sync_lock_test_and_set(&storage, v);
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type expected2 = expected;
+        storage_type old_val = __sync_val_compare_and_swap(&storage, expected2, desired);
+
+        if (old_val == expected2)
+        {
+            return true;
+        }
+        else
+        {
+            expected = old_val;
+            return false;
+        }
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        return compare_exchange_strong(storage, expected, desired, success_order, failure_order);
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return __sync_fetch_and_and(&storage, v);
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return __sync_fetch_and_or(&storage, v);
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return __sync_fetch_and_xor(&storage, v);
+    }
+
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        if ((order & memory_order_release) != 0)
+            __sync_synchronize();
+        return !!__sync_lock_test_and_set(&storage, 1);
+    }
+
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        __sync_lock_release(&storage);
+        if (order == memory_order_seq_cst)
+            __sync_synchronize();
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+#if BOOST_ATOMIC_INT8_LOCK_FREE > 0
+template< bool Signed >
+struct operations< 1u, Signed > :
+#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1)
+    public gcc_sync_operations< typename make_storage_type< 1u, Signed >::type >
+#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2)
+    public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 2u, Signed >::type >, 1u, Signed >
+#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)
+    public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 4u, Signed >::type >, 1u, Signed >
+#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)
+    public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 8u, Signed >::type >, 1u, Signed >
+#else
+    public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 16u, Signed >::type >, 1u, Signed >
+#endif
+{
+};
+#endif
+
+#if BOOST_ATOMIC_INT16_LOCK_FREE > 0
+template< bool Signed >
+struct operations< 2u, Signed > :
+#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2)
+    public gcc_sync_operations< typename make_storage_type< 2u, Signed >::type >
+#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)
+    public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 4u, Signed >::type >, 2u, Signed >
+#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)
+    public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 8u, Signed >::type >, 2u, Signed >
+#else
+    public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 16u, Signed >::type >, 2u, Signed >
+#endif
+{
+};
+#endif
+
+#if BOOST_ATOMIC_INT32_LOCK_FREE > 0
+template< bool Signed >
+struct operations< 4u, Signed > :
+#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)
+    public gcc_sync_operations< typename make_storage_type< 4u, Signed >::type >
+#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)
+    public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 8u, Signed >::type >, 4u, Signed >
+#else
+    public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 16u, Signed >::type >, 4u, Signed >
+#endif
+{
+};
+#endif
+
+#if BOOST_ATOMIC_INT64_LOCK_FREE > 0
+template< bool Signed >
+struct operations< 8u, Signed > :
+#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)
+    public gcc_sync_operations< typename make_storage_type< 8u, Signed >::type >
+#else
+    public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 16u, Signed >::type >, 8u, Signed >
+#endif
+{
+};
+#endif
+
+#if BOOST_ATOMIC_INT128_LOCK_FREE > 0
+template< bool Signed >
+struct operations< 16u, Signed > :
+    public gcc_sync_operations< typename make_storage_type< 16u, Signed >::type >
+{
+};
+#endif
+
+BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        __sync_synchronize();
+}
+
+BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        __asm__ __volatile__ ("" ::: "memory");
+}
+
+} // namespace detail
+} // namespace atomics
+} // namespace autoboost
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_SYNC_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/ops_gcc_x86.hpp b/contrib/autoboost/boost/atomic/detail/ops_gcc_x86.hpp
new file mode 100644
index 000000000..39288e0dd
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/ops_gcc_x86.hpp
@@ -0,0 +1,510 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2012 Tim Blechmann
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_gcc_x86.hpp
+ *
+ * This header contains implementation of the \c operations template.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_X86_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_GCC_X86_HPP_INCLUDED_
+
+#include <boost/memory_order.hpp>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/operations_fwd.hpp>
+#include <boost/atomic/capabilities.hpp>
+#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B) || defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B)
+#include <boost/atomic/detail/ops_gcc_x86_dcas.hpp>
+#include <boost/atomic/detail/ops_cas_based.hpp>
+#endif
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if defined(__x86_64__)
+#define BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER "rdx"
+#else
+#define BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER "edx"
+#endif
+
+namespace autoboost {
+namespace atomics {
+namespace detail {
+
+struct gcc_x86_operations_base
+{
+    static BOOST_FORCEINLINE void fence_before(memory_order order) BOOST_NOEXCEPT
+    {
+        if ((order & memory_order_release) != 0)
+            __asm__ __volatile__ ("" ::: "memory");
+    }
+
+    static BOOST_FORCEINLINE void fence_after(memory_order order) BOOST_NOEXCEPT
+    {
+        if ((order & memory_order_acquire) != 0)
+            __asm__ __volatile__ ("" ::: "memory");
+    }
+};
+
+template< typename T, typename Derived >
+struct gcc_x86_operations :
+    public gcc_x86_operations_base
+{
+    typedef T storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        if (order != memory_order_seq_cst)
+        {
+            fence_before(order);
+            storage = v;
+            fence_after(order);
+        }
+        else
+        {
+            Derived::exchange(storage, v, order);
+        }
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v = storage;
+        fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        return Derived::fetch_add(storage, -v, order);
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        return Derived::compare_exchange_strong(storage, expected, desired, success_order, failure_order);
+    }
+
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        return !!Derived::exchange(storage, (storage_type)1, order);
+    }
+
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        store(storage, (storage_type)0, order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+template< bool Signed >
+struct operations< 1u, Signed > :
+    public gcc_x86_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > >
+{
+    typedef gcc_x86_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        __asm__ __volatile__
+        (
+            "lock; xaddb %0, %1"
+            : "+q" (v), "+m" (storage)
+            :
+            : "cc", "memory"
+        );
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        __asm__ __volatile__
+        (
+            "xchgb %0, %1"
+            : "+q" (v), "+m" (storage)
+            :
+            : "memory"
+        );
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type previous = expected;
+        bool success;
+        __asm__ __volatile__
+        (
+            "lock; cmpxchgb %3, %1\n\t"
+            "sete %2"
+            : "+a" (previous), "+m" (storage), "=q" (success)
+            : "q" (desired)
+            : "cc", "memory"
+        );
+        expected = previous;
+        return success;
+    }
+
+#define BOOST_ATOMIC_DETAIL_CAS_LOOP(op, argument, result)\
+    __asm__ __volatile__\
+    (\
+        "xor %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER ", %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER "\n\t"\
+        ".align 16\n\t"\
+        "1: movb %[arg], %%dl\n\t"\
+        op " %%al, %%dl\n\t"\
+        "lock; cmpxchgb %%dl, %[storage]\n\t"\
+        "jne 1b"\
+        : [res] "+a" (result), [storage] "+m" (storage)\
+        : [arg] "q" (argument)\
+        : "cc", BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER, "memory"\
+    )
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type res = storage;
+        BOOST_ATOMIC_DETAIL_CAS_LOOP("andb", v, res);
+        return res;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type res = storage;
+        BOOST_ATOMIC_DETAIL_CAS_LOOP("orb", v, res);
+        return res;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type res = storage;
+        BOOST_ATOMIC_DETAIL_CAS_LOOP("xorb", v, res);
+        return res;
+    }
+
+#undef BOOST_ATOMIC_DETAIL_CAS_LOOP
+};
+
+template< bool Signed >
+struct operations< 2u, Signed > :
+    public gcc_x86_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > >
+{
+    typedef gcc_x86_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        __asm__ __volatile__
+        (
+            "lock; xaddw %0, %1"
+            : "+q" (v), "+m" (storage)
+            :
+            : "cc", "memory"
+        );
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        __asm__ __volatile__
+        (
+            "xchgw %0, %1"
+            : "+q" (v), "+m" (storage)
+            :
+            : "memory"
+        );
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type previous = expected;
+        bool success;
+        __asm__ __volatile__
+        (
+            "lock; cmpxchgw %3, %1\n\t"
+            "sete %2"
+            : "+a" (previous), "+m" (storage), "=q" (success)
+            : "q" (desired)
+            : "cc", "memory"
+        );
+        expected = previous;
+        return success;
+    }
+
+#define BOOST_ATOMIC_DETAIL_CAS_LOOP(op, argument, result)\
+    __asm__ __volatile__\
+    (\
+        "xor %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER ", %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER "\n\t"\
+        ".align 16\n\t"\
+        "1: movw %[arg], %%dx\n\t"\
+        op " %%ax, %%dx\n\t"\
+        "lock; cmpxchgw %%dx, %[storage]\n\t"\
+        "jne 1b"\
+        : [res] "+a" (result), [storage] "+m" (storage)\
+        : [arg] "q" (argument)\
+        : "cc", BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER, "memory"\
+    )
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type res = storage;
+        BOOST_ATOMIC_DETAIL_CAS_LOOP("andw", v, res);
+        return res;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type res = storage;
+        BOOST_ATOMIC_DETAIL_CAS_LOOP("orw", v, res);
+        return res;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type res = storage;
+        BOOST_ATOMIC_DETAIL_CAS_LOOP("xorw", v, res);
+        return res;
+    }
+
+#undef BOOST_ATOMIC_DETAIL_CAS_LOOP
+};
+
+template< bool Signed >
+struct operations< 4u, Signed > :
+    public gcc_x86_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > >
+{
+    typedef gcc_x86_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        __asm__ __volatile__
+        (
+            "lock; xaddl %0, %1"
+            : "+r" (v), "+m" (storage)
+            :
+            : "cc", "memory"
+        );
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        __asm__ __volatile__
+        (
+            "xchgl %0, %1"
+            : "+r" (v), "+m" (storage)
+            :
+            : "memory"
+        );
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type previous = expected;
+        bool success;
+        __asm__ __volatile__
+        (
+            "lock; cmpxchgl %3, %1\n\t"
+            "sete %2"
+            : "+a" (previous), "+m" (storage), "=q" (success)
+            : "r" (desired)
+            : "cc", "memory"
+        );
+        expected = previous;
+        return success;
+    }
+
+#define BOOST_ATOMIC_DETAIL_CAS_LOOP(op, argument, result)\
+    __asm__ __volatile__\
+    (\
+        "xor %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER ", %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER "\n\t"\
+        ".align 16\n\t"\
+        "1: movl %[arg], %%edx\n\t"\
+        op " %%eax, %%edx\n\t"\
+        "lock; cmpxchgl %%edx, %[storage]\n\t"\
+        "jne 1b"\
+        : [res] "+a" (result), [storage] "+m" (storage)\
+        : [arg] "r" (argument)\
+        : "cc", BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER, "memory"\
+    )
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type res = storage;
+        BOOST_ATOMIC_DETAIL_CAS_LOOP("andl", v, res);
+        return res;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type res = storage;
+        BOOST_ATOMIC_DETAIL_CAS_LOOP("orl", v, res);
+        return res;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type res = storage;
+        BOOST_ATOMIC_DETAIL_CAS_LOOP("xorl", v, res);
+        return res;
+    }
+
+#undef BOOST_ATOMIC_DETAIL_CAS_LOOP
+};
+
+#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B)
+
+template< bool Signed >
+struct operations< 8u, Signed > :
+    public cas_based_operations< gcc_dcas_x86< Signed > >
+{
+};
+
+#elif defined(__x86_64__)
+
+template< bool Signed >
+struct operations< 8u, Signed > :
+    public gcc_x86_operations< typename make_storage_type< 8u, Signed >::type, operations< 8u, Signed > >
+{
+    typedef gcc_x86_operations< typename make_storage_type< 8u, Signed >::type, operations< 8u, Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        __asm__ __volatile__
+        (
+            "lock; xaddq %0, %1"
+            : "+r" (v), "+m" (storage)
+            :
+            : "cc", "memory"
+        );
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        __asm__ __volatile__
+        (
+            "xchgq %0, %1"
+            : "+r" (v), "+m" (storage)
+            :
+            : "memory"
+        );
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type previous = expected;
+        bool success;
+        __asm__ __volatile__
+        (
+            "lock; cmpxchgq %3, %1\n\t"
+            "sete %2"
+            : "+a" (previous), "+m" (storage), "=q" (success)
+            : "r" (desired)
+            : "cc", "memory"
+        );
+        expected = previous;
+        return success;
+    }
+
+#define BOOST_ATOMIC_DETAIL_CAS_LOOP(op, argument, result)\
+    __asm__ __volatile__\
+    (\
+        "xor %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER ", %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER "\n\t"\
+        ".align 16\n\t"\
+        "1: movq %[arg], %%rdx\n\t"\
+        op " %%rax, %%rdx\n\t"\
+        "lock; cmpxchgq %%rdx, %[storage]\n\t"\
+        "jne 1b"\
+        : [res] "+a" (result), [storage] "+m" (storage)\
+        : [arg] "r" (argument)\
+        : "cc", BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER, "memory"\
+    )
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type res = storage;
+        BOOST_ATOMIC_DETAIL_CAS_LOOP("andq", v, res);
+        return res;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type res = storage;
+        BOOST_ATOMIC_DETAIL_CAS_LOOP("orq", v, res);
+        return res;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type res = storage;
+        BOOST_ATOMIC_DETAIL_CAS_LOOP("xorq", v, res);
+        return res;
+    }
+
+#undef BOOST_ATOMIC_DETAIL_CAS_LOOP
+};
+
+#endif
+
+#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B)
+
+template< bool Signed >
+struct operations< 16u, Signed > :
+    public cas_based_operations< gcc_dcas_x86_64< Signed > >
+{
+};
+
+#endif // defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B)
+
+BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order == memory_order_seq_cst)
+    {
+        __asm__ __volatile__
+        (
+#if defined(__x86_64__) || defined(__SSE2__)
+            "mfence\n"
+#else
+            "lock; addl $0, (%%esp)\n"
+#endif
+            ::: "memory"
+        );
+    }
+    else if ((order & (memory_order_acquire | memory_order_release)) != 0)
+    {
+        __asm__ __volatile__ ("" ::: "memory");
+    }
+}
+
+BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        __asm__ __volatile__ ("" ::: "memory");
+}
+
+} // namespace detail
+} // namespace atomics
+} // namespace autoboost
+
+#undef BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_X86_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/ops_gcc_x86_dcas.hpp b/contrib/autoboost/boost/atomic/detail/ops_gcc_x86_dcas.hpp
new file mode 100644
index 000000000..f25a27328
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/ops_gcc_x86_dcas.hpp
@@ -0,0 +1,308 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2012 Tim Blechmann
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_gcc_x86_dcas.hpp
+ *
+ * This header contains implementation of the double-width CAS primitive for x86.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_X86_DCAS_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_GCC_X86_DCAS_HPP_INCLUDED_
+
+#include <boost/cstdint.hpp>
+#include <boost/memory_order.hpp>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/capabilities.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace autoboost {
+namespace atomics {
+namespace detail {
+
+#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B)
+
+template< bool Signed >
+struct gcc_dcas_x86
+{
+    typedef typename make_storage_type< 8u, Signed >::type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        if ((((uint32_t)&storage) & 0x00000007) == 0)
+        {
+#if defined(__SSE2__)
+            __asm__ __volatile__
+            (
+#if defined(__AVX__)
+                "vmovq %1, %%xmm4\n\t"
+                "vmovq %%xmm4, %0\n\t"
+#else
+                "movq %1, %%xmm4\n\t"
+                "movq %%xmm4, %0\n\t"
+#endif
+                : "=m" (storage)
+                : "m" (v)
+                : "memory", "xmm4"
+            );
+#else
+            __asm__ __volatile__
+            (
+                "fildll %1\n\t"
+                "fistpll %0\n\t"
+                : "=m" (storage)
+                : "m" (v)
+                : "memory"
+            );
+#endif
+        }
+        else
+        {
+#if defined(__PIC__)
+            uint32_t scratch;
+            __asm__ __volatile__
+            (
+                "movl %%ebx, %[scratch]\n\t"
+                "movl %[value_lo], %%ebx\n\t"
+                "movl 0(%[dest]), %%eax\n\t"
+                "movl 4(%[dest]), %%edx\n\t"
+                ".align 16\n\t"
+                "1: lock; cmpxchg8b 0(%[dest])\n\t"
+                "jne 1b\n\t"
+                "movl %[scratch], %%ebx"
+                : [scratch] "=m,m" (scratch)
+                : [value_lo] "a,a" ((uint32_t)v), "c,c" ((uint32_t)(v >> 32)), [dest] "D,S" (&storage)
+                : "cc", "edx", "memory"
+            );
+#else
+            __asm__ __volatile__
+            (
+                "movl 0(%[dest]), %%eax\n\t"
+                "movl 4(%[dest]), %%edx\n\t"
+                ".align 16\n\t"
+                "1: lock; cmpxchg8b 0(%[dest])\n\t"
+                "jne 1b\n\t"
+                :
+                : [value_lo] "b,b" ((uint32_t)v), "c,c" ((uint32_t)(v >> 32)), [dest] "D,S" (&storage)
+                : "cc", "eax", "edx", "memory"
+            );
+#endif
+        }
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type value;
+
+        if ((((uint32_t)&storage) & 0x00000007) == 0)
+        {
+#if defined(__SSE2__)
+            __asm__ __volatile__
+            (
+#if defined(__AVX__)
+                "vmovq %1, %%xmm4\n\t"
+                "vmovq %%xmm4, %0\n\t"
+#else
+                "movq %1, %%xmm4\n\t"
+                "movq %%xmm4, %0\n\t"
+#endif
+                : "=m" (value)
+                : "m" (storage)
+                : "memory", "xmm4"
+            );
+#else
+            __asm__ __volatile__
+            (
+                "fildll %1\n\t"
+                "fistpll %0\n\t"
+                : "=m" (value)
+                : "m" (storage)
+                : "memory"
+            );
+#endif
+        }
+        else
+        {
+#if defined(__clang__)
+            // Clang cannot allocate eax:edx register pairs but it has sync intrinsics
+            value = __sync_val_compare_and_swap(&storage, (storage_type)0, (storage_type)0);
+#else
+            // We don't care for comparison result here; the previous value will be stored into value anyway.
+            // Also we don't care for ebx and ecx values, they just have to be equal to eax and edx before cmpxchg8b.
+            __asm__ __volatile__
+            (
+                "movl %%ebx, %%eax\n\t"
+                "movl %%ecx, %%edx\n\t"
+                "lock; cmpxchg8b %[storage]"
+                : "=&A" (value)
+                : [storage] "m" (storage)
+                : "cc", "memory"
+            );
+#endif
+        }
+
+        return value;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+    {
+#if defined(__clang__)
+        // Clang cannot allocate eax:edx register pairs but it has sync intrinsics
+        storage_type old_expected = expected;
+        expected = __sync_val_compare_and_swap(&storage, old_expected, desired);
+        return expected == old_expected;
+#elif defined(__PIC__)
+        // Make sure ebx is saved and restored properly in case
+        // of position independent code. To make this work
+        // setup register constraints such that ebx can not be
+        // used by accident e.g. as base address for the variable
+        // to be modified. Accessing "scratch" should always be okay,
+        // as it can only be placed on the stack (and therefore
+        // accessed through ebp or esp only).
+        //
+        // In theory, could push/pop ebx onto/off the stack, but movs
+        // to a prepared stack slot turn out to be faster.
+
+        uint32_t scratch;
+        bool success;
+        __asm__ __volatile__
+        (
+            "movl %%ebx, %[scratch]\n\t"
+            "movl %[desired_lo], %%ebx\n\t"
+            "lock; cmpxchg8b %[dest]\n\t"
+            "movl %[scratch], %%ebx\n\t"
+            "sete %[success]"
+            : "+A,A,A,A,A,A" (expected), [dest] "+m,m,m,m,m,m" (storage), [scratch] "=m,m,m,m,m,m" (scratch), [success] "=q,m,q,m,q,m" (success)
+            : [desired_lo] "S,S,D,D,m,m" ((uint32_t)desired), "c,c,c,c,c,c" ((uint32_t)(desired >> 32))
+            : "cc", "memory"
+        );
+        return success;
+#else
+        bool success;
+        __asm__ __volatile__
+        (
+            "lock; cmpxchg8b %[dest]\n\t"
+            "sete %[success]"
+            : "+A,A" (expected), [dest] "+m,m" (storage), [success] "=q,m" (success)
+            : "b,b" ((uint32_t)desired), "c,c" ((uint32_t)(desired >> 32))
+            : "cc", "memory"
+        );
+        return success;
+#endif
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        return compare_exchange_strong(storage, expected, desired, success_order, failure_order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+#endif // defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B)
+
+#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B)
+
+template< bool Signed >
+struct gcc_dcas_x86_64
+{
+    typedef typename make_storage_type< 16u, Signed >::type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        uint64_t const* p_value = (uint64_t const*)&v;
+        __asm__ __volatile__
+        (
+            "movq 0(%[dest]), %%rax\n\t"
+            "movq 8(%[dest]), %%rdx\n\t"
+            ".align 16\n\t"
+            "1: lock; cmpxchg16b 0(%[dest])\n\t"
+            "jne 1b"
+            :
+            : "b" (p_value[0]), "c" (p_value[1]), [dest] "r" (&storage)
+            : "cc", "rax", "rdx", "memory"
+        );
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order) BOOST_NOEXCEPT
+    {
+#if defined(__clang__)
+        // Clang cannot allocate rax:rdx register pairs but it has sync intrinsics
+        storage_type value = storage_type();
+        return __sync_val_compare_and_swap(&storage, value, value);
+#else
+        storage_type value;
+
+        // We don't care for comparison result here; the previous value will be stored into value anyway.
+        // Also we don't care for rbx and rcx values, they just have to be equal to rax and rdx before cmpxchg16b.
+        __asm__ __volatile__
+        (
+            "movq %%rbx, %%rax\n\t"
+            "movq %%rcx, %%rdx\n\t"
+            "lock; cmpxchg16b %[storage]"
+            : "=&A" (value)
+            : [storage] "m" (storage)
+            : "cc", "memory"
+        );
+
+        return value;
+#endif
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+    {
+#if defined(__clang__)
+        // Clang cannot allocate rax:rdx register pairs but it has sync intrinsics
+        storage_type old_expected = expected;
+        expected = __sync_val_compare_and_swap(&storage, old_expected, desired);
+        return expected == old_expected;
+#else
+        uint64_t const* p_desired = (uint64_t const*)&desired;
+        bool success;
+        __asm__ __volatile__
+        (
+            "lock; cmpxchg16b %[dest]\n\t"
+            "sete %[success]"
+            : "+A,A" (expected), [dest] "+m,m" (storage), [success] "=q,m" (success)
+            : "b,b" (p_desired[0]), "c,c" (p_desired[1])
+            : "cc", "memory"
+        );
+        return success;
+#endif
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        return compare_exchange_strong(storage, expected, desired, success_order, failure_order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+#endif // defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B)
+
+} // namespace detail
+} // namespace atomics
+} // namespace autoboost
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_X86_DCAS_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/ops_linux_arm.hpp b/contrib/autoboost/boost/atomic/detail/ops_linux_arm.hpp
new file mode 100644
index 000000000..0fa1af7f8
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/ops_linux_arm.hpp
@@ -0,0 +1,177 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009, 2011 Helge Bahmann
+ * Copyright (c) 2009 Phil Endecott
+ * Copyright (c) 2013 Tim Blechmann
+ * Linux-specific code by Phil Endecott
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_linux_arm.hpp
+ *
+ * This header contains implementation of the \c operations template.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_LINUX_ARM_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_LINUX_ARM_HPP_INCLUDED_
+
+#include <boost/memory_order.hpp>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/operations_fwd.hpp>
+#include <boost/atomic/capabilities.hpp>
+#include <boost/atomic/detail/ops_cas_based.hpp>
+#include <boost/atomic/detail/ops_extending_cas_based.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace autoboost {
+namespace atomics {
+namespace detail {
+
+// Different ARM processors have different atomic instructions.  In particular,
+// architecture versions before v6 (which are still in widespread use, e.g. the
+// Intel/Marvell XScale chips like the one in the NSLU2) have only atomic swap.
+// On Linux the kernel provides some support that lets us abstract away from
+// these differences: it provides emulated CAS and barrier functions at special
+// addresses that are guaranteed not to be interrupted by the kernel.  Using
+// this facility is slightly slower than inline assembler would be, but much
+// faster than a system call.
+//
+// While this emulated CAS is "strong" in the sense that it does not fail
+// "spuriously" (i.e.: it never fails to perform the exchange when the value
+// found equals the value expected), it does not return the found value on
+// failure. To satisfy the atomic API, compare_exchange_{weak|strong} must
+// return the found value on failure, and we have to manually load this value
+// after the emulated CAS reports failure. This in turn introduces a race
+// between the CAS failing (due to the "wrong" value being found) and subsequently
+// loading (which might turn up the "right" value). From an application's
+// point of view this looks like "spurious failure", and therefore the
+// emulated CAS is only good enough to provide compare_exchange_weak
+// semantics.
+
+struct linux_arm_cas_base
+{
+    static BOOST_FORCEINLINE void fence_before_store(memory_order order) BOOST_NOEXCEPT
+    {
+        if ((order & memory_order_release) != 0)
+            hardware_full_fence();
+    }
+
+    static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT
+    {
+        if (order == memory_order_seq_cst)
+            hardware_full_fence();
+    }
+
+    static BOOST_FORCEINLINE void fence_after_load(memory_order order) BOOST_NOEXCEPT
+    {
+        if ((order & (memory_order_consume | memory_order_acquire)) != 0)
+            hardware_full_fence();
+    }
+
+    static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT
+    {
+        typedef void (*kernel_dmb_t)(void);
+        ((kernel_dmb_t)0xffff0fa0)();
+    }
+};
+
+template< bool Signed >
+struct linux_arm_cas :
+    public linux_arm_cas_base
+{
+    typedef typename make_storage_type< 4u, Signed >::type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        fence_before_store(order);
+        storage = v;
+        fence_after_store(order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v = storage;
+        fence_after_load(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        while (true)
+        {
+            storage_type tmp = expected;
+            if (compare_exchange_weak(storage, tmp, desired, success_order, failure_order))
+                return true;
+            if (tmp != expected)
+            {
+                expected = tmp;
+                return false;
+            }
+        }
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+    {
+        typedef storage_type (*kernel_cmpxchg32_t)(storage_type oldval, storage_type newval, volatile storage_type* ptr);
+
+        if (((kernel_cmpxchg32_t)0xffff0fc0)(expected, desired, &storage) == 0)
+        {
+            return true;
+        }
+        else
+        {
+            expected = storage;
+            return false;
+        }
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+template< bool Signed >
+struct operations< 1u, Signed > :
+    public extending_cas_based_operations< cas_based_operations< linux_arm_cas< Signed > >, 1u, Signed >
+{
+};
+
+template< bool Signed >
+struct operations< 2u, Signed > :
+    public extending_cas_based_operations< cas_based_operations< linux_arm_cas< Signed > >, 2u, Signed >
+{
+};
+
+template< bool Signed >
+struct operations< 4u, Signed > :
+    public cas_based_operations< linux_arm_cas< Signed > >
+{
+};
+
+BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        linux_arm_cas_base::hardware_full_fence();
+}
+
+BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        __asm__ __volatile__ ("" ::: "memory");
+}
+
+} // namespace detail
+} // namespace atomics
+} // namespace autoboost
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_LINUX_ARM_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/ops_msvc_arm.hpp b/contrib/autoboost/boost/atomic/detail/ops_msvc_arm.hpp
new file mode 100644
index 000000000..b1a92848d
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/ops_msvc_arm.hpp
@@ -0,0 +1,820 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2012 Tim Blechmann
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_msvc_arm.hpp
+ *
+ * This header contains implementation of the \c operations template.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_MSVC_ARM_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_MSVC_ARM_HPP_INCLUDED_
+
+#include <intrin.h>
+#include <boost/memory_order.hpp>
+#include <boost/type_traits/make_signed.hpp>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/interlocked.hpp>
+#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/operations_fwd.hpp>
+#include <boost/atomic/capabilities.hpp>
+#include <boost/atomic/detail/ops_msvc_common.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#define BOOST_ATOMIC_DETAIL_ARM_LOAD8(p) __iso_volatile_load8((const volatile __int8*)(p))
+#define BOOST_ATOMIC_DETAIL_ARM_LOAD16(p) __iso_volatile_load16((const volatile __int16*)(p))
+#define BOOST_ATOMIC_DETAIL_ARM_LOAD32(p) __iso_volatile_load32((const volatile __int32*)(p))
+#define BOOST_ATOMIC_DETAIL_ARM_LOAD64(p) __iso_volatile_load64((const volatile __int64*)(p))
+#define BOOST_ATOMIC_DETAIL_ARM_STORE8(p, v) __iso_volatile_store8((volatile __int8*)(p), (__int8)(v))
+#define BOOST_ATOMIC_DETAIL_ARM_STORE16(p, v) __iso_volatile_store16((volatile __int16*)(p), (__int16)(v))
+#define BOOST_ATOMIC_DETAIL_ARM_STORE32(p, v) __iso_volatile_store32((volatile __int32*)(p), (__int32)(v))
+#define BOOST_ATOMIC_DETAIL_ARM_STORE64(p, v) __iso_volatile_store64((volatile __int64*)(p), (__int64)(v))
+
+namespace autoboost {
+namespace atomics {
+namespace detail {
+
+// A note about memory_order_consume. Technically, this architecture allows to avoid
+// unnecessary memory barrier after consume load since it supports data dependency ordering.
+// However, some compiler optimizations may break a seemingly valid code relying on data
+// dependency tracking by injecting bogus branches to aid out of order execution.
+// This may happen not only in Boost.Atomic code but also in user's code, which we have no
+// control of. See this thread: http://lists.boost.org/Archives/boost/2014/06/213890.php.
+// For this reason we promote memory_order_consume to memory_order_acquire.
+
+struct msvc_arm_operations_base
+{
+    static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT
+    {
+        __dmb(0xB); // _ARM_BARRIER_ISH, see armintr.h from MSVC 11 and later
+    }
+
+    static BOOST_FORCEINLINE void fence_before_store(memory_order order) BOOST_NOEXCEPT
+    {
+        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+
+        if ((order & memory_order_release) != 0)
+            hardware_full_fence();
+
+        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+    }
+
+    static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT
+    {
+        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+
+        if (order == memory_order_seq_cst)
+            hardware_full_fence();
+
+        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+    }
+
+    static BOOST_FORCEINLINE void fence_after_load(memory_order order) BOOST_NOEXCEPT
+    {
+        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+
+        if ((order & (memory_order_consume | memory_order_acquire)) != 0)
+            hardware_full_fence();
+
+        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+    }
+
+    static BOOST_FORCEINLINE BOOST_CONSTEXPR memory_order cas_common_order(memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        // Combine order flags together and promote memory_order_consume to memory_order_acquire
+        return static_cast< memory_order >(((failure_order | success_order) & ~memory_order_consume) | (((failure_order | success_order) & memory_order_consume) << 1u));
+    }
+};
+
+template< typename T, typename Derived >
+struct msvc_arm_operations :
+    public msvc_arm_operations_base
+{
+    typedef T storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        typedef typename make_signed< storage_type >::type signed_storage_type;
+        return Derived::fetch_add(storage, static_cast< storage_type >(-static_cast< signed_storage_type >(v)), order);
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        return Derived::compare_exchange_strong(storage, expected, desired, success_order, failure_order);
+    }
+
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        return !!Derived::exchange(storage, (storage_type)1, order);
+    }
+
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        Derived::store(storage, (storage_type)0, order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+template< bool Signed >
+struct operations< 1u, Signed > :
+    public msvc_arm_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > >
+{
+    typedef msvc_arm_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before_store(order);
+        BOOST_ATOMIC_DETAIL_ARM_STORE8(&storage, v);
+        base_type::fence_after_store(order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v = BOOST_ATOMIC_DETAIL_ARM_LOAD8(&storage);
+        base_type::fence_after_load(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE8_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE8_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE8_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE8(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        storage_type previous = expected, old_val;
+
+        switch (cas_common_order(success_order, failure_order))
+        {
+        case memory_order_relaxed:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_RELAXED(&storage, desired, previous));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_ACQUIRE(&storage, desired, previous));
+            break;
+        case memory_order_release:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_RELEASE(&storage, desired, previous));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8(&storage, desired, previous));
+            break;
+        }
+        expected = old_val;
+
+        return (previous == old_val);
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND8_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND8_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND8_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND8(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR8_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR8_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR8_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR8(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR8_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR8_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR8_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR8(&storage, v));
+            break;
+        }
+        return v;
+    }
+};
+
+template< bool Signed >
+struct operations< 2u, Signed > :
+    public msvc_arm_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > >
+{
+    typedef msvc_arm_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before_store(order);
+        BOOST_ATOMIC_DETAIL_ARM_STORE16(&storage, v);
+        base_type::fence_after_store(order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v = BOOST_ATOMIC_DETAIL_ARM_LOAD16(&storage);
+        base_type::fence_after_load(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE16_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE16_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE16_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE16(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        storage_type previous = expected, old_val;
+
+        switch (cas_common_order(success_order, failure_order))
+        {
+        case memory_order_relaxed:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_RELAXED(&storage, desired, previous));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_ACQUIRE(&storage, desired, previous));
+            break;
+        case memory_order_release:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_RELEASE(&storage, desired, previous));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16(&storage, desired, previous));
+            break;
+        }
+        expected = old_val;
+
+        return (previous == old_val);
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND16_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND16_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND16_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND16(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR16_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR16_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR16_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR16(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR16_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR16_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR16_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR16(&storage, v));
+            break;
+        }
+        return v;
+    }
+};
+
+template< bool Signed >
+struct operations< 4u, Signed > :
+    public msvc_arm_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > >
+{
+    typedef msvc_arm_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before_store(order);
+        BOOST_ATOMIC_DETAIL_ARM_STORE32(&storage, v);
+        base_type::fence_after_store(order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v = BOOST_ATOMIC_DETAIL_ARM_LOAD32(&storage);
+        base_type::fence_after_load(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        storage_type previous = expected, old_val;
+
+        switch (cas_common_order(success_order, failure_order))
+        {
+        case memory_order_relaxed:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_RELAXED(&storage, desired, previous));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_ACQUIRE(&storage, desired, previous));
+            break;
+        case memory_order_release:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_RELEASE(&storage, desired, previous));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(&storage, desired, previous));
+            break;
+        }
+        expected = old_val;
+
+        return (previous == old_val);
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR(&storage, v));
+            break;
+        }
+        return v;
+    }
+};
+
+template< bool Signed >
+struct operations< 8u, Signed > :
+    public msvc_arm_operations< typename make_storage_type< 8u, Signed >::type, operations< 8u, Signed > >
+{
+    typedef msvc_arm_operations< typename make_storage_type< 8u, Signed >::type, operations< 8u, Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before_store(order);
+        BOOST_ATOMIC_DETAIL_ARM_STORE64(&storage, v);
+        base_type::fence_after_store(order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v = BOOST_ATOMIC_DETAIL_ARM_LOAD64(&storage);
+        base_type::fence_after_load(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE64_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE64_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE64_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE64(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        storage_type previous = expected, old_val;
+
+        switch (cas_common_order(success_order, failure_order))
+        {
+        case memory_order_relaxed:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_RELAXED(&storage, desired, previous));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_ACQUIRE(&storage, desired, previous));
+            break;
+        case memory_order_release:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_RELEASE(&storage, desired, previous));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(&storage, desired, previous));
+            break;
+        }
+        expected = old_val;
+
+        return (previous == old_val);
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND64_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND64_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND64_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND64(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR64_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR64_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR64_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR64(&storage, v));
+            break;
+        }
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        switch (order)
+        {
+        case memory_order_relaxed:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR64_RELAXED(&storage, v));
+            break;
+        case memory_order_consume:
+        case memory_order_acquire:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR64_ACQUIRE(&storage, v));
+            break;
+        case memory_order_release:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR64_RELEASE(&storage, v));
+            break;
+        case memory_order_acq_rel:
+        case memory_order_seq_cst:
+        default:
+            v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR64(&storage, v));
+            break;
+        }
+        return v;
+    }
+};
+
+
+BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT
+{
+    BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+    if (order != memory_order_relaxed)
+        msvc_arm_operations_base::hardware_full_fence();
+    BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+}
+
+BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+}
+
+} // namespace detail
+} // namespace atomics
+} // namespace autoboost
+
+#undef BOOST_ATOMIC_DETAIL_ARM_LOAD8
+#undef BOOST_ATOMIC_DETAIL_ARM_LOAD16
+#undef BOOST_ATOMIC_DETAIL_ARM_LOAD32
+#undef BOOST_ATOMIC_DETAIL_ARM_LOAD64
+#undef BOOST_ATOMIC_DETAIL_ARM_STORE8
+#undef BOOST_ATOMIC_DETAIL_ARM_STORE16
+#undef BOOST_ATOMIC_DETAIL_ARM_STORE32
+#undef BOOST_ATOMIC_DETAIL_ARM_STORE64
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_MSVC_ARM_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/ops_msvc_common.hpp b/contrib/autoboost/boost/atomic/detail/ops_msvc_common.hpp
new file mode 100644
index 000000000..53628f360
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/ops_msvc_common.hpp
@@ -0,0 +1,38 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2012 Tim Blechmann
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_msvc_common.hpp
+ *
+ * This header contains common tools for MSVC implementation of the \c operations template.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_MSVC_COMMON_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_MSVC_COMMON_HPP_INCLUDED_
+
+#include <boost/atomic/detail/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+// Define compiler barriers
+#if defined(__INTEL_COMPILER)
+#define BOOST_ATOMIC_DETAIL_COMPILER_BARRIER() __memory_barrier()
+#elif defined(_MSC_VER) && !defined(_WIN32_WCE)
+extern "C" void _ReadWriteBarrier(void);
+#pragma intrinsic(_ReadWriteBarrier)
+#define BOOST_ATOMIC_DETAIL_COMPILER_BARRIER() _ReadWriteBarrier()
+#endif
+
+#ifndef BOOST_ATOMIC_DETAIL_COMPILER_BARRIER
+#define BOOST_ATOMIC_DETAIL_COMPILER_BARRIER()
+#endif
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_MSVC_COMMON_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/ops_msvc_x86.hpp b/contrib/autoboost/boost/atomic/detail/ops_msvc_x86.hpp
new file mode 100644
index 000000000..17597d301
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/ops_msvc_x86.hpp
@@ -0,0 +1,879 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2012 Tim Blechmann
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_msvc_x86.hpp
+ *
+ * This header contains implementation of the \c operations template.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_MSVC_X86_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_MSVC_X86_HPP_INCLUDED_
+
+#include <boost/memory_order.hpp>
+#include <boost/type_traits/make_signed.hpp>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/interlocked.hpp>
+#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/operations_fwd.hpp>
+#include <boost/atomic/capabilities.hpp>
+#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B) || defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B)
+#include <boost/cstdint.hpp>
+#include <boost/atomic/detail/ops_cas_based.hpp>
+#endif
+#include <boost/atomic/detail/ops_msvc_common.hpp>
+#if !defined(_M_IX86) && !(defined(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8) && defined(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16))
+#include <boost/atomic/detail/ops_extending_cas_based.hpp>
+#endif
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+// frame pointer register 'ebx' modified by inline assembly code. See the note below.
+#pragma warning(disable: 4731)
+#endif
+
+#if defined(_MSC_VER) && (defined(_M_AMD64) || (defined(_M_IX86) && defined(_M_IX86_FP) && _M_IX86_FP >= 2))
+extern "C" void _mm_mfence(void);
+#if defined(BOOST_MSVC)
+#pragma intrinsic(_mm_mfence)
+#endif
+#endif
+
+namespace autoboost {
+namespace atomics {
+namespace detail {
+
+/*
+ * Implementation note for asm blocks.
+ *
+ * http://msdn.microsoft.com/en-us/data/k1a8ss06%28v=vs.105%29
+ *
+ * Some SSE types require eight-byte stack alignment, forcing the compiler to emit dynamic stack-alignment code.
+ * To be able to access both the local variables and the function parameters after the alignment, the compiler
+ * maintains two frame pointers. If the compiler performs frame pointer omission (FPO), it will use EBP and ESP.
+ * If the compiler does not perform FPO, it will use EBX and EBP. To ensure code runs correctly, do not modify EBX
+ * in asm code if the function requires dynamic stack alignment as it could modify the frame pointer.
+ * Either move the eight-byte aligned types out of the function, or avoid using EBX.
+ *
+ * Since we have no way of knowing that the compiler uses FPO, we have to always save and restore ebx
+ * whenever we have to clobber it. Additionally, we disable warning C4731 above so that the compiler
+ * doesn't spam about ebx use.
+ */
+
+struct msvc_x86_operations_base
+{
+    static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT
+    {
+#if defined(_MSC_VER) && (defined(_M_AMD64) || (defined(_M_IX86) && defined(_M_IX86_FP) && _M_IX86_FP >= 2))
+        // Use mfence only if SSE2 is available
+        _mm_mfence();
+#else
+        long tmp;
+        BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&tmp, 0);
+#endif
+    }
+
+    static BOOST_FORCEINLINE void fence_before(memory_order) BOOST_NOEXCEPT
+    {
+        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+    }
+
+    static BOOST_FORCEINLINE void fence_after(memory_order) BOOST_NOEXCEPT
+    {
+        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+    }
+
+    static BOOST_FORCEINLINE void fence_after_load(memory_order) BOOST_NOEXCEPT
+    {
+        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+
+        // On x86 and x86_64 there is no need for a hardware barrier,
+        // even if seq_cst memory order is requested, because all
+        // seq_cst writes are implemented with lock-prefixed operations
+        // or xchg which has implied lock prefix. Therefore normal loads
+        // are already ordered with seq_cst stores on these architectures.
+    }
+};
+
+template< typename T, typename Derived >
+struct msvc_x86_operations :
+    public msvc_x86_operations_base
+{
+    typedef T storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        if (order != memory_order_seq_cst)
+        {
+            fence_before(order);
+            storage = v;
+            fence_after(order);
+        }
+        else
+        {
+            Derived::exchange(storage, v, order);
+        }
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type v = storage;
+        fence_after_load(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        typedef typename make_signed< storage_type >::type signed_storage_type;
+        return Derived::fetch_add(storage, static_cast< storage_type >(-static_cast< signed_storage_type >(v)), order);
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        return Derived::compare_exchange_strong(storage, expected, desired, success_order, failure_order);
+    }
+
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        return !!Derived::exchange(storage, (storage_type)1, order);
+    }
+
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        store(storage, (storage_type)0, order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+template< bool Signed >
+struct operations< 4u, Signed > :
+    public msvc_x86_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > >
+{
+    typedef msvc_x86_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(&storage, v));
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&storage, v));
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type previous = expected;
+        storage_type old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(&storage, desired, previous));
+        expected = old_val;
+        return (previous == old_val);
+    }
+
+#if defined(BOOST_ATOMIC_INTERLOCKED_AND)
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND(&storage, v));
+    }
+#else
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type res = storage;
+        while (!compare_exchange_strong(storage, res, res & v, order, memory_order_relaxed)) {}
+        return res;
+    }
+#endif
+
+#if defined(BOOST_ATOMIC_INTERLOCKED_OR)
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR(&storage, v));
+    }
+#else
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type res = storage;
+        while (!compare_exchange_strong(storage, res, res | v, order, memory_order_relaxed)) {}
+        return res;
+    }
+#endif
+
+#if defined(BOOST_ATOMIC_INTERLOCKED_XOR)
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR(&storage, v));
+    }
+#else
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        storage_type res = storage;
+        while (!compare_exchange_strong(storage, res, res ^ v, order, memory_order_relaxed)) {}
+        return res;
+    }
+#endif
+};
+
+#if defined(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8)
+
+template< bool Signed >
+struct operations< 1u, Signed > :
+    public msvc_x86_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > >
+{
+    typedef msvc_x86_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8(&storage, v));
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE8(&storage, v));
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type previous = expected;
+        storage_type old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8(&storage, desired, previous));
+        expected = old_val;
+        return (previous == old_val);
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND8(&storage, v));
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR8(&storage, v));
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR8(&storage, v));
+    }
+};
+
+#elif defined(_M_IX86)
+
+template< bool Signed >
+struct operations< 1u, Signed > :
+    public msvc_x86_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > >
+{
+    typedef msvc_x86_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before(order);
+        __asm
+        {
+            mov edx, storage
+            movzx eax, v
+            lock xadd byte ptr [edx], al
+            mov v, al
+        };
+        base_type::fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before(order);
+        __asm
+        {
+            mov edx, storage
+            movzx eax, v
+            xchg byte ptr [edx], al
+            mov v, al
+        };
+        base_type::fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before(success_order);
+        bool success;
+        __asm
+        {
+            mov esi, expected
+            mov edi, storage
+            movzx eax, byte ptr [esi]
+            movzx edx, desired
+            lock cmpxchg byte ptr [edi], dl
+            mov byte ptr [esi], al
+            sete success
+        };
+        // The success and failure fences are equivalent anyway
+        base_type::fence_after(success_order);
+        return success;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before(order);
+        int backup;
+        __asm
+        {
+            mov backup, ebx
+            xor edx, edx
+            mov edi, storage
+            movzx ebx, v
+            movzx eax, byte ptr [edi]
+            align 16
+        again:
+            mov dl, al
+            and dl, bl
+            lock cmpxchg byte ptr [edi], dl
+            jne again
+            mov v, al
+            mov ebx, backup
+        };
+        base_type::fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before(order);
+        int backup;
+        __asm
+        {
+            mov backup, ebx
+            xor edx, edx
+            mov edi, storage
+            movzx ebx, v
+            movzx eax, byte ptr [edi]
+            align 16
+        again:
+            mov dl, al
+            or dl, bl
+            lock cmpxchg byte ptr [edi], dl
+            jne again
+            mov v, al
+            mov ebx, backup
+        };
+        base_type::fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before(order);
+        int backup;
+        __asm
+        {
+            mov backup, ebx
+            xor edx, edx
+            mov edi, storage
+            movzx ebx, v
+            movzx eax, byte ptr [edi]
+            align 16
+        again:
+            mov dl, al
+            xor dl, bl
+            lock cmpxchg byte ptr [edi], dl
+            jne again
+            mov v, al
+            mov ebx, backup
+        };
+        base_type::fence_after(order);
+        return v;
+    }
+};
+
+#else
+
+template< bool Signed >
+struct operations< 1u, Signed > :
+    public extending_cas_based_operations< operations< 4u, Signed >, 1u, Signed >
+{
+};
+
+#endif
+
+#if defined(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16)
+
+template< bool Signed >
+struct operations< 2u, Signed > :
+    public msvc_x86_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > >
+{
+    typedef msvc_x86_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16(&storage, v));
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE16(&storage, v));
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type previous = expected;
+        storage_type old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16(&storage, desired, previous));
+        expected = old_val;
+        return (previous == old_val);
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND16(&storage, v));
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR16(&storage, v));
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR16(&storage, v));
+    }
+};
+
+#elif defined(_M_IX86)
+
+template< bool Signed >
+struct operations< 2u, Signed > :
+    public msvc_x86_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > >
+{
+    typedef msvc_x86_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before(order);
+        __asm
+        {
+            mov edx, storage
+            movzx eax, v
+            lock xadd word ptr [edx], ax
+            mov v, ax
+        };
+        base_type::fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before(order);
+        __asm
+        {
+            mov edx, storage
+            movzx eax, v
+            xchg word ptr [edx], ax
+            mov v, ax
+        };
+        base_type::fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before(success_order);
+        bool success;
+        __asm
+        {
+            mov esi, expected
+            mov edi, storage
+            movzx eax, word ptr [esi]
+            movzx edx, desired
+            lock cmpxchg word ptr [edi], dx
+            mov word ptr [esi], ax
+            sete success
+        };
+        // The success and failure fences are equivalent anyway
+        base_type::fence_after(success_order);
+        return success;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before(order);
+        int backup;
+        __asm
+        {
+            mov backup, ebx
+            xor edx, edx
+            mov edi, storage
+            movzx ebx, v
+            movzx eax, word ptr [edi]
+            align 16
+        again:
+            mov dx, ax
+            and dx, bx
+            lock cmpxchg word ptr [edi], dx
+            jne again
+            mov v, ax
+            mov ebx, backup
+        };
+        base_type::fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before(order);
+        int backup;
+        __asm
+        {
+            mov backup, ebx
+            xor edx, edx
+            mov edi, storage
+            movzx ebx, v
+            movzx eax, word ptr [edi]
+            align 16
+        again:
+            mov dx, ax
+            or dx, bx
+            lock cmpxchg word ptr [edi], dx
+            jne again
+            mov v, ax
+            mov ebx, backup
+        };
+        base_type::fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before(order);
+        int backup;
+        __asm
+        {
+            mov backup, ebx
+            xor edx, edx
+            mov edi, storage
+            movzx ebx, v
+            movzx eax, word ptr [edi]
+            align 16
+        again:
+            mov dx, ax
+            xor dx, bx
+            lock cmpxchg word ptr [edi], dx
+            jne again
+            mov v, ax
+            mov ebx, backup
+        };
+        base_type::fence_after(order);
+        return v;
+    }
+};
+
+#else
+
+template< bool Signed >
+struct operations< 2u, Signed > :
+    public extending_cas_based_operations< operations< 4u, Signed >, 2u, Signed >
+{
+};
+
+#endif
+
+
+#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B)
+
+template< bool Signed >
+struct msvc_dcas_x86
+{
+    typedef typename make_storage_type< 8u, Signed >::type storage_type;
+
+    // Intel 64 and IA-32 Architectures Software Developer's Manual, Volume 3A, 8.1.1. Guaranteed Atomic Operations:
+    //
+    // The Pentium processor (and newer processors since) guarantees that the following additional memory operations will always be carried out atomically:
+    // * Reading or writing a quadword aligned on a 64-bit boundary
+    //
+    // Luckily, the memory is almost always 8-byte aligned in our case because atomic<> uses 64 bit native types for storage and dynamic memory allocations
+    // have at least 8 byte alignment. The only unfortunate case is when atomic is placeod on the stack and it is not 8-byte aligned (like on 32 bit Windows).
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type volatile* p = &storage;
+        if (((uint32_t)p & 0x00000007) == 0)
+        {
+#if defined(_M_IX86_FP) && _M_IX86_FP >= 2
+#if defined(__AVX__)
+            __asm
+            {
+                mov edx, p
+                vmovq xmm4, v
+                vmovq qword ptr [edx], xmm4
+            };
+#else
+            __asm
+            {
+                mov edx, p
+                movq xmm4, v
+                movq qword ptr [edx], xmm4
+            };
+#endif
+#else
+            __asm
+            {
+                mov edx, p
+                fild v
+                fistp qword ptr [edx]
+            };
+#endif
+        }
+        else
+        {
+            int backup;
+            __asm
+            {
+                mov backup, ebx
+                mov edi, p
+                mov ebx, dword ptr [v]
+                mov ecx, dword ptr [v + 4]
+                mov eax, dword ptr [edi]
+                mov edx, dword ptr [edi + 4]
+                align 16
+            again:
+                lock cmpxchg8b qword ptr [edi]
+                jne again
+                mov ebx, backup
+            };
+        }
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type const volatile* p = &storage;
+        storage_type value;
+
+        if (((uint32_t)p & 0x00000007) == 0)
+        {
+#if defined(_M_IX86_FP) && _M_IX86_FP >= 2
+#if defined(__AVX__)
+            __asm
+            {
+                mov edx, p
+                vmovq xmm4, qword ptr [edx]
+                vmovq value, xmm4
+            };
+#else
+            __asm
+            {
+                mov edx, p
+                movq xmm4, qword ptr [edx]
+                movq value, xmm4
+            };
+#endif
+#else
+            __asm
+            {
+                mov edx, p
+                fild qword ptr [edx]
+                fistp value
+            };
+#endif
+        }
+        else
+        {
+            // We don't care for comparison result here; the previous value will be stored into value anyway.
+            // Also we don't care for ebx and ecx values, they just have to be equal to eax and edx before cmpxchg8b.
+            __asm
+            {
+                mov edi, p
+                mov eax, ebx
+                mov edx, ecx
+                lock cmpxchg8b qword ptr [edi]
+                mov dword ptr [value], eax
+                mov dword ptr [value + 4], edx
+            };
+        }
+
+        return value;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type volatile* p = &storage;
+#if defined(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64)
+        const storage_type old_val = (storage_type)BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(p, desired, expected);
+        const bool result = (old_val == expected);
+        expected = old_val;
+        return result;
+#else
+        bool result;
+        int backup;
+        __asm
+        {
+            mov backup, ebx
+            mov edi, p
+            mov esi, expected
+            mov ebx, dword ptr [desired]
+            mov ecx, dword ptr [desired + 4]
+            mov eax, dword ptr [esi]
+            mov edx, dword ptr [esi + 4]
+            lock cmpxchg8b qword ptr [edi]
+            mov dword ptr [esi], eax
+            mov dword ptr [esi + 4], edx
+            mov ebx, backup
+            sete result
+        };
+        return result;
+#endif
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        return compare_exchange_strong(storage, expected, desired, success_order, failure_order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+template< bool Signed >
+struct operations< 8u, Signed > :
+    public cas_based_operations< msvc_dcas_x86< Signed > >
+{
+};
+
+#elif defined(_M_AMD64)
+
+template< bool Signed >
+struct operations< 8u, Signed > :
+    public msvc_x86_operations< typename make_storage_type< 8u, Signed >::type, operations< 8u, Signed > >
+{
+    typedef msvc_x86_operations< typename make_storage_type< 8u, Signed >::type, operations< 8u, Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(&storage, v));
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE64(&storage, v));
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type previous = expected;
+        storage_type old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(&storage, desired, previous));
+        expected = old_val;
+        return (previous == old_val);
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND64(&storage, v));
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR64(&storage, v));
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR64(&storage, v));
+    }
+};
+
+#endif
+
+#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B)
+
+template< bool Signed >
+struct msvc_dcas_x86_64
+{
+    typedef typename make_storage_type< 16u, Signed >::type storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type value = const_cast< storage_type& >(storage);
+        while (!BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE128(&storage, v, &value)) {}
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order) BOOST_NOEXCEPT
+    {
+        storage_type value = storage_type();
+        BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE128(&storage, value, &value);
+        return value;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT
+    {
+        return !!BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE128(&storage, desired, &expected);
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        return compare_exchange_strong(storage, expected, desired, success_order, failure_order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+template< bool Signed >
+struct operations< 16u, Signed > :
+    public cas_based_operations< msvc_dcas_x86_64< Signed > >
+{
+};
+
+#endif // defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B)
+
+BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT
+{
+    BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+    if (order == memory_order_seq_cst)
+        msvc_x86_operations_base::hardware_full_fence();
+    BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+}
+
+BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+}
+
+} // namespace detail
+} // namespace atomics
+} // namespace autoboost
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_MSVC_X86_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/atomic/detail/ops_windows.hpp b/contrib/autoboost/boost/atomic/detail/ops_windows.hpp
new file mode 100644
index 000000000..2b4a36d1d
--- /dev/null
+++ b/contrib/autoboost/boost/atomic/detail/ops_windows.hpp
@@ -0,0 +1,215 @@
+/*
+ * 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)
+ *
+ * Copyright (c) 2009 Helge Bahmann
+ * Copyright (c) 2012 Tim Blechmann
+ * Copyright (c) 2014 Andrey Semashev
+ */
+/*!
+ * \file   atomic/detail/ops_windows.hpp
+ *
+ * This header contains implementation of the \c operations template.
+ *
+ * This implementation is the most basic version for Windows. It should
+ * work for any non-MSVC-like compilers as long as there are Interlocked WinAPI
+ * functions available. This version is also used for WinCE.
+ *
+ * Notably, this implementation is not as efficient as other
+ * versions based on compiler intrinsics.
+ */
+
+#ifndef BOOST_ATOMIC_DETAIL_OPS_WINDOWS_HPP_INCLUDED_
+#define BOOST_ATOMIC_DETAIL_OPS_WINDOWS_HPP_INCLUDED_
+
+#include <boost/memory_order.hpp>
+#include <boost/type_traits/make_signed.hpp>
+#include <boost/atomic/detail/config.hpp>
+#include <boost/atomic/detail/interlocked.hpp>
+#include <boost/atomic/detail/storage_type.hpp>
+#include <boost/atomic/detail/operations_fwd.hpp>
+#include <boost/atomic/capabilities.hpp>
+#include <boost/atomic/detail/ops_msvc_common.hpp>
+#include <boost/atomic/detail/ops_extending_cas_based.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace autoboost {
+namespace atomics {
+namespace detail {
+
+struct windows_operations_base
+{
+    static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT
+    {
+        long tmp;
+        BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&tmp, 0);
+    }
+
+    static BOOST_FORCEINLINE void fence_before(memory_order) BOOST_NOEXCEPT
+    {
+        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+    }
+
+    static BOOST_FORCEINLINE void fence_after(memory_order) BOOST_NOEXCEPT
+    {
+        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+    }
+};
+
+template< typename T, typename Derived >
+struct windows_operations :
+    public windows_operations_base
+{
+    typedef T storage_type;
+
+    static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        Derived::exchange(storage, v, order);
+    }
+
+    static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        return Derived::fetch_add(const_cast< storage_type volatile& >(storage), (storage_type)0, order);
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        typedef typename make_signed< storage_type >::type signed_storage_type;
+        return Derived::fetch_add(storage, static_cast< storage_type >(-static_cast< signed_storage_type >(v)), order);
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_weak(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        return Derived::compare_exchange_strong(storage, expected, desired, success_order, failure_order);
+    }
+
+    static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        return !!Derived::exchange(storage, (storage_type)1, order);
+    }
+
+    static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT
+    {
+        store(storage, (storage_type)0, order);
+    }
+
+    static BOOST_FORCEINLINE bool is_lock_free(storage_type const volatile&) BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+template< bool Signed >
+struct operations< 4u, Signed > :
+    public windows_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > >
+{
+    typedef windows_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > > base_type;
+    typedef typename base_type::storage_type storage_type;
+
+    static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before(order);
+        v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(&storage, v));
+        base_type::fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+        base_type::fence_before(order);
+        v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&storage, v));
+        base_type::fence_after(order);
+        return v;
+    }
+
+    static BOOST_FORCEINLINE bool compare_exchange_strong(
+        storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
+    {
+        storage_type previous = expected;
+        base_type::fence_before(success_order);
+        storage_type old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(&storage, desired, previous));
+        expected = old_val;
+        // The success and failure fences are the same anyway
+        base_type::fence_after(success_order);
+        return (previous == old_val);
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+#if defined(BOOST_ATOMIC_INTERLOCKED_AND)
+        base_type::fence_before(order);
+        v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND(&storage, v));
+        base_type::fence_after(order);
+        return v;
+#else
+        storage_type res = storage;
+        while (!compare_exchange_strong(storage, res, res & v, order, memory_order_relaxed)) {}
+        return res;
+#endif
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+#if defined(BOOST_ATOMIC_INTERLOCKED_OR)
+        base_type::fence_before(order);
+        v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR(&storage, v));
+        base_type::fence_after(order);
+        return v;
+#else
+        storage_type res = storage;
+        while (!compare_exchange_strong(storage, res, res | v, order, memory_order_relaxed)) {}
+        return res;
+#endif
+    }
+
+    static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT
+    {
+#if defined(BOOST_ATOMIC_INTERLOCKED_XOR)
+        base_type::fence_before(order);
+        v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR(&storage, v));
+        base_type::fence_after(order);
+        return v;
+#else
+        storage_type res = storage;
+        while (!compare_exchange_strong(storage, res, res ^ v, order, memory_order_relaxed)) {}
+        return res;
+#endif
+    }
+};
+
+template< bool Signed >
+struct operations< 1u, Signed > :
+    public extending_cas_based_operations< operations< 4u, Signed >, 1u, Signed >
+{
+};
+
+template< bool Signed >
+struct operations< 2u, Signed > :
+    public extending_cas_based_operations< operations< 4u, Signed >, 2u, Signed >
+{
+};
+
+BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT
+{
+    BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+    if (order == memory_order_seq_cst)
+        windows_operations_base::hardware_full_fence();
+    BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+}
+
+BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT
+{
+    if (order != memory_order_relaxed)
+        BOOST_ATOMIC_DETAIL_COMPILER_BARRIER();
+}
+
+} // namespace detail
+} // namespace atomics
+} // namespace autoboost
+
+#endif // BOOST_ATOMIC_DETAIL_OPS_WINDOWS_HPP_INCLUDED_
diff --git a/contrib/autoboost/boost/chrono/config.hpp b/contrib/autoboost/boost/chrono/config.hpp
index 751b68644..4461cb3f4 100644
--- a/contrib/autoboost/boost/chrono/config.hpp
+++ b/contrib/autoboost/boost/chrono/config.hpp
@@ -191,26 +191,6 @@
 #endif
 
 
-
-//  enable automatic library variant selection  ------------------------------//
-
-#if !defined(BOOST_CHRONO_SOURCE) && !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_CHRONO_NO_LIB)
-//
-// Set the name of our library; this will get undef'ed by auto_link.hpp
-// once it's done with it:
-//
-#define BOOST_LIB_NAME autoboost_chrono
-//
-// If we're importing code from a dll, then tell auto_link.hpp about it:
-//
-#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_CHRONO_DYN_LINK)
-#  define BOOST_DYN_LINK
-#endif
-//
-// And include the header that does the work:
-//
-#include <boost/config/auto_link.hpp>
-#endif  // auto-linking disabled
 #endif // BOOST_CHRONO_HEADER_ONLY
 #endif // BOOST_CHRONO_CONFIG_HPP
 
diff --git a/contrib/autoboost/boost/context/detail/config.hpp b/contrib/autoboost/boost/context/detail/config.hpp
index 5c5957632..e9228612e 100644
--- a/contrib/autoboost/boost/context/detail/config.hpp
+++ b/contrib/autoboost/boost/context/detail/config.hpp
@@ -27,14 +27,6 @@
 # define BOOST_CONTEXT_DECL
 #endif
 
-#if ! defined(BOOST_CONTEXT_SOURCE) && ! defined(BOOST_ALL_NO_LIB) && ! defined(BOOST_CONTEXT_NO_LIB)
-# define BOOST_LIB_NAME autoboost_context
-# if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_CONTEXT_DYN_LINK)
-#  define BOOST_DYN_LINK
-# endif
-# include <boost/config/auto_link.hpp>
-#endif
-
 #undef BOOST_CONTEXT_CALLDECL
 #if (defined(i386) || defined(__i386__) || defined(__i386) \
     || defined(__i486__) || defined(__i586__) || defined(__i686__) \
diff --git a/contrib/autoboost/boost/coroutine/all.hpp b/contrib/autoboost/boost/coroutine/all.hpp
deleted file mode 100644
index 42f63a0a7..000000000
--- a/contrib/autoboost/boost/coroutine/all.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_ALL_H
-#define BOOST_COROUTINES_ALL_H
-
-#include <boost/coroutine/attributes.hpp>
-#include <boost/coroutine/coroutine.hpp>
-#include <boost/coroutine/exceptions.hpp>
-#include <boost/coroutine/flags.hpp>
-#include <boost/coroutine/protected_stack_allocator.hpp>
-#include <boost/coroutine/segmented_stack_allocator.hpp>
-#include <boost/coroutine/stack_allocator.hpp>
-#include <boost/coroutine/stack_context.hpp>
-#include <boost/coroutine/stack_traits.hpp>
-#include <boost/coroutine/standard_stack_allocator.hpp>
-
-#endif // BOOST_COROUTINES_ALL_H
diff --git a/contrib/autoboost/boost/coroutine/asymmetric_coroutine.hpp b/contrib/autoboost/boost/coroutine/asymmetric_coroutine.hpp
deleted file mode 100644
index 81f05722c..000000000
--- a/contrib/autoboost/boost/coroutine/asymmetric_coroutine.hpp
+++ /dev/null
@@ -1,2243 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_ASYMMETRIC_COROUTINE_H
-#define BOOST_COROUTINES_ASYMMETRIC_COROUTINE_H
-
-#include <cstddef>
-#include <iterator>
-#include <memory>
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/move/move.hpp>
-#include <boost/range.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/utility/explicit_operator_bool.hpp>
-
-#include <boost/coroutine/attributes.hpp>
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/detail/coroutine_context.hpp>
-#include <boost/coroutine/detail/parameters.hpp>
-#include <boost/coroutine/exceptions.hpp>
-#include <boost/coroutine/stack_allocator.hpp>
-#include <boost/coroutine/detail/pull_coroutine_impl.hpp>
-#include <boost/coroutine/detail/pull_coroutine_object.hpp>
-#include <boost/coroutine/detail/pull_coroutine_synthesized.hpp>
-#include <boost/coroutine/detail/push_coroutine_impl.hpp>
-#include <boost/coroutine/detail/push_coroutine_object.hpp>
-#include <boost/coroutine/detail/push_coroutine_synthesized.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-
-template< typename R >
-class pull_coroutine;
-
-template< typename Arg >
-class push_coroutine
-{
-private:
-    template< typename V, typename X, typename Y, typename Z >
-    friend class detail::pull_coroutine_object;
-
-    typedef detail::push_coroutine_impl< Arg >          impl_type;
-    typedef detail::push_coroutine_synthesized< Arg >   synth_type;
-    typedef detail::parameters< Arg >                   param_type;
-
-    struct dummy {};
-
-    impl_type       *   impl_;
-
-    BOOST_MOVABLE_BUT_NOT_COPYABLE( push_coroutine)
-
-    explicit push_coroutine( detail::synthesized_t::flag_t, impl_type & impl) :
-        impl_( & impl)
-    { BOOST_ASSERT( impl_); }
-
-public:
-    push_coroutine() BOOST_NOEXCEPT :
-        impl_( 0)
-    {}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-# ifdef BOOST_MSVC
-    typedef void ( * coroutine_fn)( pull_coroutine< Arg > &);
-
-    explicit push_coroutine( coroutine_fn,
-                             attributes const& = attributes() );
-
-    template< typename StackAllocator >
-    explicit push_coroutine( coroutine_fn,
-                             attributes const&,
-                             StackAllocator);
-# endif
-    template< typename Fn >
-    explicit push_coroutine( BOOST_RV_REF( Fn),
-                             attributes const& = attributes() );
-
-    template< typename Fn, typename StackAllocator >
-    explicit push_coroutine( BOOST_RV_REF( Fn),
-                             attributes const&,
-                             StackAllocator);
-#else
-    template< typename Fn >
-    explicit push_coroutine( Fn fn,
-                             attributes const& = attributes() );
-
-    template< typename Fn, typename StackAllocator >
-    explicit push_coroutine( Fn fn,
-                             attributes const&,
-                             StackAllocator);
-
-    template< typename Fn >
-    explicit push_coroutine( BOOST_RV_REF( Fn),
-                             attributes const& = attributes() );
-
-    template< typename Fn, typename StackAllocator >
-    explicit push_coroutine( BOOST_RV_REF( Fn),
-                             attributes const&,
-                             StackAllocator);
-#endif
-
-    ~push_coroutine()
-    {
-        if ( 0 != impl_)
-        {
-            impl_->destroy();
-            impl_ = 0;
-        }
-    }
-
-    push_coroutine( BOOST_RV_REF( push_coroutine) other) BOOST_NOEXCEPT :
-        impl_( 0)
-    { swap( other); }
-
-    push_coroutine & operator=( BOOST_RV_REF( push_coroutine) other) BOOST_NOEXCEPT
-    {
-        push_coroutine tmp( autoboost::move( other) );
-        swap( tmp);
-        return * this;
-    }
-
-    BOOST_EXPLICIT_OPERATOR_BOOL();
-
-    bool operator!() const BOOST_NOEXCEPT
-    { return 0 == impl_ || impl_->is_complete(); }
-
-    void swap( push_coroutine & other) BOOST_NOEXCEPT
-    { std::swap( impl_, other.impl_); }
-
-    push_coroutine & operator()( Arg arg)
-    {
-        BOOST_ASSERT( * this);
-
-        impl_->push( arg);
-        return * this;
-    }
-
-    class iterator : public std::iterator< std::output_iterator_tag, void, void, void, void >
-    {
-    private:
-       push_coroutine< Arg >    *   c_;
-
-    public:
-        iterator() :
-           c_( 0)
-        {}
-
-        explicit iterator( push_coroutine< Arg > * c) :
-            c_( c)
-        {}
-
-        iterator & operator=( Arg a)
-        {
-            BOOST_ASSERT( c_);
-            if ( ! ( * c_)( a) ) c_ = 0;
-            return * this;
-        }
-
-        bool operator==( iterator const& other) const
-        { return other.c_ == c_; }
-
-        bool operator!=( iterator const& other) const
-        { return other.c_ != c_; }
-
-        iterator & operator*()
-        { return * this; }
-
-        iterator & operator++()
-        { return * this; }
-    };
-
-    struct const_iterator;
-};
-
-template< typename Arg >
-class push_coroutine< Arg & >
-{
-private:
-    template< typename V, typename X, typename Y, typename Z >
-    friend class detail::pull_coroutine_object;
-
-    typedef detail::push_coroutine_impl< Arg & >          impl_type;
-    typedef detail::push_coroutine_synthesized< Arg & >   synth_type;
-    typedef detail::parameters< Arg & >                   param_type;
-
-    struct dummy {};
-
-    impl_type       *   impl_;
-
-    BOOST_MOVABLE_BUT_NOT_COPYABLE( push_coroutine)
-
-    explicit push_coroutine( detail::synthesized_t::flag_t, impl_type & impl) :
-        impl_( & impl)
-    { BOOST_ASSERT( impl_); }
-
-public:
-    push_coroutine() BOOST_NOEXCEPT :
-        impl_( 0)
-    {}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-# ifdef BOOST_MSVC
-    typedef void ( * coroutine_fn)( pull_coroutine< Arg & > &);
-
-    explicit push_coroutine( coroutine_fn,
-                             attributes const& = attributes() );
-
-    template< typename StackAllocator >
-    explicit push_coroutine( coroutine_fn,
-                             attributes const&,
-                             StackAllocator);
-# endif
-    template< typename Fn >
-    explicit push_coroutine( BOOST_RV_REF( Fn),
-                             attributes const& = attributes() );
-
-    template< typename Fn, typename StackAllocator >
-    explicit push_coroutine( BOOST_RV_REF( Fn),
-                             attributes const&,
-                             StackAllocator);
-#else
-    template< typename Fn >
-    explicit push_coroutine( Fn,
-                             attributes const& = attributes() );
-
-    template< typename Fn, typename StackAllocator >
-    explicit push_coroutine( Fn,
-                             attributes const&,
-                             StackAllocator);
-
-    template< typename Fn >
-    explicit push_coroutine( BOOST_RV_REF( Fn),
-                             attributes const& = attributes() );
-
-    template< typename Fn, typename StackAllocator >
-    explicit push_coroutine( BOOST_RV_REF( Fn),
-                             attributes const&,
-                             StackAllocator);
-#endif
-
-    ~push_coroutine()
-    {
-        if ( 0 != impl_)
-        {
-            impl_->destroy();
-            impl_ = 0;
-        }
-    }
-
-    push_coroutine( BOOST_RV_REF( push_coroutine) other) BOOST_NOEXCEPT :
-        impl_( 0)
-    { swap( other); }
-
-    push_coroutine & operator=( BOOST_RV_REF( push_coroutine) other) BOOST_NOEXCEPT
-    {
-        push_coroutine tmp( autoboost::move( other) );
-        swap( tmp);
-        return * this;
-    }
-
-    BOOST_EXPLICIT_OPERATOR_BOOL();
-
-    bool operator!() const BOOST_NOEXCEPT
-    { return 0 == impl_ || impl_->is_complete(); }
-
-    void swap( push_coroutine & other) BOOST_NOEXCEPT
-    { std::swap( impl_, other.impl_); }
-
-    push_coroutine & operator()( Arg & arg)
-    {
-        BOOST_ASSERT( * this);
-
-        impl_->push( arg);
-        return * this;
-    }
-
-    class iterator : public std::iterator< std::output_iterator_tag, void, void, void, void >
-    {
-    private:
-       push_coroutine< Arg & >  *   c_;
-
-    public:
-        iterator() :
-           c_( 0)
-        {}
-
-        explicit iterator( push_coroutine< Arg & > * c) :
-            c_( c)
-        {}
-
-        iterator & operator=( Arg & a)
-        {
-            BOOST_ASSERT( c_);
-            if ( ! ( * c_)( a) ) c_ = 0;
-            return * this;
-        }
-
-        bool operator==( iterator const& other) const
-        { return other.c_ == c_; }
-
-        bool operator!=( iterator const& other) const
-        { return other.c_ != c_; }
-
-        iterator & operator*()
-        { return * this; }
-
-        iterator & operator++()
-        { return * this; }
-    };
-
-    struct const_iterator;
-};
-
-template<>
-class push_coroutine< void >
-{
-private:
-    template< typename V, typename X, typename Y, typename Z >
-    friend class detail::pull_coroutine_object;
-
-    typedef detail::push_coroutine_impl< void >          impl_type;
-    typedef detail::push_coroutine_synthesized< void >   synth_type;
-    typedef detail::parameters< void >                   param_type;
-
-    struct dummy {};
-
-    impl_type       *   impl_;
-
-    BOOST_MOVABLE_BUT_NOT_COPYABLE( push_coroutine)
-
-    explicit push_coroutine( detail::synthesized_t::flag_t, impl_type & impl) :
-        impl_( & impl)
-    { BOOST_ASSERT( impl_); }
-
-public:
-    push_coroutine() BOOST_NOEXCEPT :
-        impl_( 0)
-    {}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-# ifdef BOOST_MSVC
-    typedef void ( * coroutine_fn)( pull_coroutine< void > &);
-
-    explicit push_coroutine( coroutine_fn,
-                             attributes const& = attributes() );
-
-    template< typename StackAllocator >
-    explicit push_coroutine( coroutine_fn,
-                             attributes const&,
-                             StackAllocator);
-# endif
-    template< typename Fn >
-    explicit push_coroutine( BOOST_RV_REF( Fn),
-                             attributes const& = attributes() );
-
-    template< typename Fn, typename StackAllocator >
-    explicit push_coroutine( BOOST_RV_REF( Fn),
-                             attributes const&,
-                             StackAllocator);
-#else
-    template< typename Fn >
-    explicit push_coroutine( Fn,
-                             attributes const& = attributes() );
-
-    template< typename Fn, typename StackAllocator >
-    explicit push_coroutine( Fn,
-                             attributes const&,
-                             StackAllocator);
-
-    template< typename Fn >
-    explicit push_coroutine( BOOST_RV_REF( Fn),
-                             attributes const& = attributes() );
-
-    template< typename Fn, typename StackAllocator >
-    explicit push_coroutine( BOOST_RV_REF( Fn),
-                             attributes const&,
-                             StackAllocator);
-#endif
-
-    ~push_coroutine()
-    {
-        if ( 0 != impl_)
-        {
-            impl_->destroy();
-            impl_ = 0;
-        }
-    }
-
-    inline push_coroutine( BOOST_RV_REF( push_coroutine) other) BOOST_NOEXCEPT :
-        impl_( 0)
-    { swap( other); }
-
-    inline push_coroutine & operator=( BOOST_RV_REF( push_coroutine) other) BOOST_NOEXCEPT
-    {
-        push_coroutine tmp( autoboost::move( other) );
-        swap( tmp);
-        return * this;
-    }
-
-    BOOST_EXPLICIT_OPERATOR_BOOL();
-
-    inline bool operator!() const BOOST_NOEXCEPT
-    { return 0 == impl_ || impl_->is_complete(); }
-
-    inline void swap( push_coroutine & other) BOOST_NOEXCEPT
-    { std::swap( impl_, other.impl_); }
-
-    inline push_coroutine & operator()()
-    {
-        BOOST_ASSERT( * this);
-
-        impl_->push();
-        return * this;
-    }
-
-    struct iterator;
-    struct const_iterator;
-};
-
-
-
-template< typename R >
-class pull_coroutine
-{
-private:
-    template< typename V, typename X, typename Y, typename Z >
-    friend class detail::push_coroutine_object;
-
-    typedef detail::pull_coroutine_impl< R >            impl_type;
-    typedef detail::pull_coroutine_synthesized< R >     synth_type;
-    typedef detail::parameters< R >                     param_type;
-
-    struct dummy {};
-
-    impl_type       *   impl_;
-
-    BOOST_MOVABLE_BUT_NOT_COPYABLE( pull_coroutine)
-
-    explicit pull_coroutine( detail::synthesized_t::flag_t, impl_type & impl) :
-        impl_( & impl)
-    { BOOST_ASSERT( impl_); }
-
-public:
-    pull_coroutine() BOOST_NOEXCEPT :
-        impl_( 0)
-    {}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-# ifdef BOOST_MSVC
-    typedef void ( * coroutine_fn)( push_coroutine< R > &);
-
-    explicit pull_coroutine( coroutine_fn fn,
-                             attributes const& attrs = attributes() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        stack_allocator stack_alloc;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R >, R, coroutine_fn, stack_allocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-
-    template< typename StackAllocator >
-    explicit pull_coroutine( coroutine_fn fn,
-                             attributes const& attrs,
-                             StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R >, R, coroutine_fn, StackAllocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-# endif
-    template< typename Fn >
-    explicit pull_coroutine( BOOST_RV_REF( Fn) fn,
-                             attributes const& attrs = attributes() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        stack_allocator stack_alloc;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R >, R, Fn, stack_allocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit pull_coroutine( BOOST_RV_REF( Fn) fn,
-                             attributes const& attrs,
-                             StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R >, R, Fn, StackAllocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-#else
-    template< typename Fn >
-    explicit pull_coroutine( Fn fn,
-                             attributes const& attrs = attributes() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        stack_allocator stack_alloc;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R >, R, Fn, stack_allocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit pull_coroutine( Fn fn,
-                             attributes const& attrs,
-                             StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R >, R, Fn, StackAllocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-
-    template< typename Fn >
-    explicit pull_coroutine( BOOST_RV_REF( Fn) fn,
-                             attributes const& attrs = attributes() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        stack_allocator stack_alloc;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R >, R, Fn, stack_allocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit pull_coroutine( BOOST_RV_REF( Fn) fn,
-                             attributes const& attrs,
-                             StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R >, R, Fn, StackAllocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-#endif
-
-    ~pull_coroutine()
-    {
-        if ( 0 != impl_)
-        {
-            impl_->destroy();
-            impl_ = 0;
-        }
-    }
-
-    pull_coroutine( BOOST_RV_REF( pull_coroutine) other) BOOST_NOEXCEPT :
-        impl_( 0)
-    { swap( other); }
-
-    pull_coroutine & operator=( BOOST_RV_REF( pull_coroutine) other) BOOST_NOEXCEPT
-    {
-        pull_coroutine tmp( autoboost::move( other) );
-        swap( tmp);
-        return * this;
-    }
-
-    BOOST_EXPLICIT_OPERATOR_BOOL();
-
-    bool operator!() const BOOST_NOEXCEPT
-    { return 0 == impl_ || impl_->is_complete(); }
-
-    void swap( pull_coroutine & other) BOOST_NOEXCEPT
-    { std::swap( impl_, other.impl_); }
-
-    pull_coroutine & operator()()
-    {
-        BOOST_ASSERT( * this);
-
-        impl_->pull();
-        return * this;
-    }
-
-    R get() const
-    {
-        BOOST_ASSERT( 0 != impl_);
-
-        return impl_->get();
-    }
-
-    class iterator : public std::iterator< std::input_iterator_tag, typename remove_reference< R >::type >
-    {
-    private:
-        pull_coroutine< R > *   c_;
-        R                   *   val_;
-
-        void fetch_()
-        {
-            BOOST_ASSERT( c_);
-
-            if ( ! ( * c_) )
-            {
-                c_ = 0;
-                val_ = 0;
-                return;
-            }
-            val_ = c_->impl_->get_pointer();
-        }
-
-        void increment_()
-        {
-            BOOST_ASSERT( c_);
-            BOOST_ASSERT( * c_);
-
-            ( * c_)();
-            fetch_();
-        }
-
-    public:
-        typedef typename iterator::pointer      pointer_t;
-        typedef typename iterator::reference    reference_t;
-
-        iterator() :
-            c_( 0), val_( 0)
-        {}
-
-        explicit iterator( pull_coroutine< R > * c) :
-            c_( c), val_( 0)
-        { fetch_(); }
-
-        iterator( iterator const& other) :
-            c_( other.c_), val_( other.val_)
-        {}
-
-        iterator & operator=( iterator const& other)
-        {
-            if ( this == & other) return * this;
-            c_ = other.c_;
-            val_ = other.val_;
-            return * this;
-        }
-
-        bool operator==( iterator const& other) const
-        { return other.c_ == c_ && other.val_ == val_; }
-
-        bool operator!=( iterator const& other) const
-        { return other.c_ != c_ || other.val_ != val_; }
-
-        iterator & operator++()
-        {
-            increment_();
-            return * this;
-        }
-
-        iterator operator++( int)
-        {
-            iterator tmp( * this);
-            ++*this;
-            return tmp;
-        }
-
-        reference_t operator*() const
-        {
-            if ( ! val_)
-                autoboost::throw_exception(
-                    invalid_result() );
-            return * val_;
-        }
-
-        pointer_t operator->() const
-        {
-            if ( ! val_)
-                autoboost::throw_exception(
-                    invalid_result() );
-            return val_;
-        }
-    };
-
-    friend class iterator;
-
-    struct const_iterator;
-};
-
-template< typename R >
-class pull_coroutine< R & >
-{
-private:
-    template< typename V, typename X, typename Y, typename Z >
-    friend class detail::push_coroutine_object;
-
-    typedef detail::pull_coroutine_impl< R & >            impl_type;
-    typedef detail::pull_coroutine_synthesized< R & >     synth_type;
-    typedef detail::parameters< R & >                     param_type;
-
-    struct dummy {};
-
-    impl_type       *   impl_;
-
-    BOOST_MOVABLE_BUT_NOT_COPYABLE( pull_coroutine)
-
-    explicit pull_coroutine( detail::synthesized_t::flag_t, impl_type & impl) :
-        impl_( & impl)
-    { BOOST_ASSERT( impl_); }
-
-public:
-    pull_coroutine() BOOST_NOEXCEPT :
-        impl_( 0)
-    {}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-# ifdef BOOST_MSVC
-    typedef void ( * coroutine_fn)( push_coroutine< R & > &);
-
-    explicit pull_coroutine( coroutine_fn fn,
-                             attributes const& attrs = attributes() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        stack_allocator stack_alloc;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R & >, R &, coroutine_fn, stack_allocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-
-    template< typename StackAllocator >
-    explicit pull_coroutine( coroutine_fn fn,
-                             attributes const& attrs,
-                             StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R & >, R &, coroutine_fn, StackAllocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-# endif
-    template< typename Fn >
-    explicit pull_coroutine( BOOST_RV_REF( Fn) fn,
-                             attributes const& attrs = attributes() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        stack_allocator stack_alloc;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R & >, R &, Fn, stack_allocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit pull_coroutine( BOOST_RV_REF( Fn) fn,
-                             attributes const& attrs,
-                             StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R & >, R &, Fn, StackAllocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-#else
-    template< typename Fn >
-    explicit pull_coroutine( Fn fn,
-                             attributes const& attrs = attributes() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        stack_allocator stack_alloc;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R & >, R &, Fn, stack_allocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit pull_coroutine( Fn fn,
-                             attributes const& attrs,
-                             StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R & >, R &, Fn, StackAllocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-
-    template< typename Fn >
-    explicit pull_coroutine( BOOST_RV_REF( Fn) fn,
-                             attributes const& attrs = attributes() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        stack_allocator stack_alloc;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R & >, R &, Fn, stack_allocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit pull_coroutine( BOOST_RV_REF( Fn) fn,
-                             attributes const& attrs,
-                             StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< R & >, R &, Fn, StackAllocator
-        >                                                        object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-#endif
-
-    ~pull_coroutine()
-    {
-        if ( 0 != impl_)
-        {
-            impl_->destroy();
-            impl_ = 0;
-        }
-    }
-
-    pull_coroutine( BOOST_RV_REF( pull_coroutine) other) BOOST_NOEXCEPT :
-        impl_( 0)
-    { swap( other); }
-
-    pull_coroutine & operator=( BOOST_RV_REF( pull_coroutine) other) BOOST_NOEXCEPT
-    {
-        pull_coroutine tmp( autoboost::move( other) );
-        swap( tmp);
-        return * this;
-    }
-
-    BOOST_EXPLICIT_OPERATOR_BOOL();
-
-    bool operator!() const BOOST_NOEXCEPT
-    { return 0 == impl_ || impl_->is_complete(); }
-
-    void swap( pull_coroutine & other) BOOST_NOEXCEPT
-    { std::swap( impl_, other.impl_); }
-
-    pull_coroutine & operator()()
-    {
-        BOOST_ASSERT( * this);
-
-        impl_->pull();
-        return * this;
-    }
-
-    R & get() const
-    { return impl_->get(); }
-
-    class iterator : public std::iterator< std::input_iterator_tag, R >
-    {
-    private:
-        pull_coroutine< R & >   *   c_;
-        R                       *   val_;
-
-        void fetch_()
-        {
-            BOOST_ASSERT( c_);
-
-            if ( ! ( * c_) )
-            {
-                c_ = 0;
-                val_ = 0;
-                return;
-            }
-            val_ = c_->impl_->get_pointer();
-        }
-
-        void increment_()
-        {
-            BOOST_ASSERT( c_);
-            BOOST_ASSERT( * c_);
-
-            ( * c_)();
-            fetch_();
-        }
-
-    public:
-        typedef typename iterator::pointer      pointer_t;
-        typedef typename iterator::reference    reference_t;
-
-        iterator() :
-            c_( 0), val_( 0)
-        {}
-
-        explicit iterator( pull_coroutine< R & > * c) :
-            c_( c), val_( 0)
-        { fetch_(); }
-
-        iterator( iterator const& other) :
-            c_( other.c_), val_( other.val_)
-        {}
-
-        iterator & operator=( iterator const& other)
-        {
-            if ( this == & other) return * this;
-            c_ = other.c_;
-            val_ = other.val_;
-            return * this;
-        }
-
-        bool operator==( iterator const& other) const
-        { return other.c_ == c_ && other.val_ == val_; }
-
-        bool operator!=( iterator const& other) const
-        { return other.c_ != c_ || other.val_ != val_; }
-
-        iterator & operator++()
-        {
-            increment_();
-            return * this;
-        }
-
-        iterator operator++( int)
-        {
-            iterator tmp( * this);
-            ++*this;
-            return tmp;
-        }
-
-        reference_t operator*() const
-        {
-            if ( ! val_)
-                autoboost::throw_exception(
-                    invalid_result() );
-            return * val_;
-        }
-
-        pointer_t operator->() const
-        {
-            if ( ! val_)
-                autoboost::throw_exception(
-                    invalid_result() );
-            return val_;
-        }
-    };
-
-    friend class iterator;
-
-    struct const_iterator;
-};
-
-template<>
-class pull_coroutine< void >
-{
-private:
-    template< typename V, typename X, typename Y, typename Z >
-    friend class detail::push_coroutine_object;
-
-    typedef detail::pull_coroutine_impl< void >            impl_type;
-    typedef detail::pull_coroutine_synthesized< void >     synth_type;
-    typedef detail::parameters< void >                     param_type;
-
-    struct dummy {};
-
-    impl_type       *   impl_;
-
-    BOOST_MOVABLE_BUT_NOT_COPYABLE( pull_coroutine)
-
-    explicit pull_coroutine( detail::synthesized_t::flag_t, impl_type & impl) :
-        impl_( & impl)
-    { BOOST_ASSERT( impl_); }
-
-public:
-    pull_coroutine() BOOST_NOEXCEPT :
-        impl_( 0)
-    {}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-# ifdef BOOST_MSVC
-    typedef void ( * coroutine_fn)( push_coroutine< void > &);
-
-    explicit pull_coroutine( coroutine_fn fn,
-                             attributes const& attrs = attributes() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        stack_allocator stack_alloc;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< void >, void, coroutine_fn, stack_allocator
-        >                                       object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-
-    template< typename StackAllocator >
-    explicit pull_coroutine( coroutine_fn fn,
-                             attributes const& attrs,
-                             StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< void >, void, coroutine_fn, StackAllocator
-        >                                                                   object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-# endif
-    template< typename Fn >
-    explicit pull_coroutine( BOOST_RV_REF( Fn) fn,
-                             attributes const& attrs = attributes() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        stack_allocator stack_alloc;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< void >, void, Fn, stack_allocator
-        >                                                       object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit pull_coroutine( BOOST_RV_REF( Fn) fn,
-                             attributes const& attrs,
-                             StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< void >, void, Fn, StackAllocator
-        >                                                       object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-#else
-    template< typename Fn >
-    explicit pull_coroutine( Fn fn,
-                             attributes const& attrs = attributes() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        stack_allocator stack_alloc;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< void >, void, Fn, stack_allocator
-        >                                                       object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit pull_coroutine( Fn fn,
-                             attributes const& attrs,
-                             StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< void >, void, Fn, StackAllocator
-        >                                                       object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-
-    template< typename Fn >
-    explicit pull_coroutine( BOOST_RV_REF( Fn) fn,
-                             attributes const& attrs = attributes() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        stack_allocator stack_alloc;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< void >, void, Fn, stack_allocator
-        >                                           object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit pull_coroutine( BOOST_RV_REF( Fn) fn,
-                             attributes const& attrs,
-                             StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef detail::pull_coroutine_object<
-            push_coroutine< void >, void, Fn, StackAllocator
-        >                                           object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-        impl_->pull();
-    }
-#endif
-
-    ~pull_coroutine()
-    {
-        if ( 0 != impl_)
-        {
-            impl_->destroy();
-            impl_ = 0;
-        }
-    }
-
-    inline pull_coroutine( BOOST_RV_REF( pull_coroutine) other) BOOST_NOEXCEPT :
-        impl_( 0)
-    { swap( other); }
-
-    inline pull_coroutine & operator=( BOOST_RV_REF( pull_coroutine) other) BOOST_NOEXCEPT
-    {
-        pull_coroutine tmp( autoboost::move( other) );
-        swap( tmp);
-        return * this;
-    }
-
-    BOOST_EXPLICIT_OPERATOR_BOOL();
-
-    inline bool operator!() const BOOST_NOEXCEPT
-    { return 0 == impl_ || impl_->is_complete(); }
-
-    inline void swap( pull_coroutine & other) BOOST_NOEXCEPT
-    { std::swap( impl_, other.impl_); }
-
-    inline pull_coroutine & operator()()
-    {
-        BOOST_ASSERT( * this);
-
-        impl_->pull();
-        return * this;
-    }
-
-    struct iterator;
-    struct const_iterator;
-};
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-# ifdef BOOST_MSVC
-template< typename Arg >
-push_coroutine< Arg >::push_coroutine( coroutine_fn fn,
-                                       attributes const& attrs) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    stack_allocator stack_alloc;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg >, Arg, coroutine_fn, stack_allocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Arg >
-template< typename StackAllocator >
-push_coroutine< Arg >::push_coroutine( coroutine_fn fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg >, Arg, coroutine_fn, StackAllocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Arg >
-push_coroutine< Arg & >::push_coroutine( coroutine_fn fn,
-                                         attributes const& attrs) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    stack_allocator stack_alloc;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg & >, Arg &, coroutine_fn, stack_allocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Arg >
-template< typename StackAllocator >
-push_coroutine< Arg & >::push_coroutine( coroutine_fn fn,
-                                         attributes const& attrs,
-                                         StackAllocator stack_alloc) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg & >, Arg &, coroutine_fn, StackAllocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-inline push_coroutine< void >::push_coroutine( coroutine_fn fn,
-                                               attributes const& attrs) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    stack_allocator stack_alloc;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< void >, void, coroutine_fn, stack_allocator
-    >                                                               object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename StackAllocator >
-push_coroutine< void >::push_coroutine( coroutine_fn fn,
-                                        attributes const& attrs,
-                                        StackAllocator stack_alloc) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< void >, void, coroutine_fn, StackAllocator
-    >                                                               object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-# endif
-template< typename Arg >
-template< typename Fn >
-push_coroutine< Arg >::push_coroutine( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    stack_allocator stack_alloc;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg >, Arg, Fn, stack_allocator
-    >                                                    object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Arg >
-template< typename Fn, typename StackAllocator >
-push_coroutine< Arg >::push_coroutine( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg >, Arg, Fn, StackAllocator
-    >                                                    object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Arg >
-template< typename Fn >
-push_coroutine< Arg & >::push_coroutine( BOOST_RV_REF( Fn) fn,
-                                         attributes const& attrs) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    stack_allocator stack_alloc;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg & >, Arg &, Fn, stack_allocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Arg >
-template< typename Fn, typename StackAllocator >
-push_coroutine< Arg & >::push_coroutine( BOOST_RV_REF( Fn) fn,
-                                         attributes const& attrs,
-                                         StackAllocator stack_alloc) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg & >, Arg &, Fn, StackAllocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Fn >
-push_coroutine< void >::push_coroutine( BOOST_RV_REF( Fn) fn,
-                                        attributes const& attrs) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    stack_allocator stack_alloc;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< void >, void, Fn, stack_allocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Fn, typename StackAllocator >
-push_coroutine< void >::push_coroutine( BOOST_RV_REF( Fn) fn,
-                                        attributes const& attrs,
-                                        StackAllocator stack_alloc) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< void >, void, Fn, StackAllocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-#else
-template< typename Arg >
-template< typename Fn >
-push_coroutine< Arg >::push_coroutine( Fn fn,
-                                       attributes const& attrs) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    stack_allocator stack_alloc;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg >, Arg, Fn, stack_allocator
-    >                                                    object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Arg >
-template< typename Fn, typename StackAllocator >
-push_coroutine< Arg >::push_coroutine( Fn fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg >, Arg, Fn, StackAllocator
-    >                                                    object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Arg >
-template< typename Fn >
-push_coroutine< Arg & >::push_coroutine( Fn fn,
-                                         attributes const& attrs) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    stack_allocator stack_alloc;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg & >, Arg &, Fn, stack_allocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Arg >
-template< typename Fn, typename StackAllocator >
-push_coroutine< Arg & >::push_coroutine( Fn fn,
-                                         attributes const& attrs,
-                                         StackAllocator stack_alloc) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg & >, Arg &, Fn, StackAllocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Fn >
-push_coroutine< void >::push_coroutine( Fn fn,
-                                        attributes const& attrs) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    stack_allocator stack_alloc;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< void >, void, Fn, stack_allocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Fn, typename StackAllocator >
-push_coroutine< void >::push_coroutine( Fn fn,
-                                        attributes const& attrs,
-                                        StackAllocator stack_alloc) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< void >, void, Fn, StackAllocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Arg >
-template< typename Fn >
-push_coroutine< Arg >::push_coroutine( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    stack_allocator stack_alloc;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg >, Arg, Fn, stack_allocator
-    >                                                    object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Arg >
-template< typename Fn, typename StackAllocator >
-push_coroutine< Arg >::push_coroutine( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg >, Arg, Fn, StackAllocator
-    >                                                    object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Arg >
-template< typename Fn >
-push_coroutine< Arg & >::push_coroutine( BOOST_RV_REF( Fn) fn,
-                                         attributes const& attrs) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    stack_allocator stack_alloc;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg & >, Arg &, Fn, stack_allocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Arg >
-template< typename Fn, typename StackAllocator >
-push_coroutine< Arg & >::push_coroutine( BOOST_RV_REF( Fn) fn,
-                                         attributes const& attrs,
-                                         StackAllocator stack_alloc) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< Arg & >, Arg &, Fn, StackAllocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Fn >
-push_coroutine< void >::push_coroutine( BOOST_RV_REF( Fn) fn,
-                                        attributes const& attrs) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    stack_allocator stack_alloc;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< void >, void, Fn, stack_allocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-
-template< typename Fn, typename StackAllocator >
-push_coroutine< void >::push_coroutine( BOOST_RV_REF( Fn) fn,
-                                        attributes const& attrs,
-                                        StackAllocator stack_alloc) :
-    impl_( 0)
-{
-    // create a stack-context
-    stack_context stack_ctx;
-    // allocate the coroutine-stack
-    stack_alloc.allocate( stack_ctx, attrs.size);
-    BOOST_ASSERT( 0 < stack_ctx.sp);
-    // typedef of internal coroutine-type
-    typedef detail::push_coroutine_object<
-        pull_coroutine< void >, void, Fn, StackAllocator
-    >                                                            object_t;
-    // reserve space on top of coroutine-stack for internal coroutine-type
-    stack_context internal_stack_ctx;
-    internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-    internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-    BOOST_ASSERT( 0 < internal_stack_ctx.size);
-    // placement new for internal coroutine
-    impl_ = new ( internal_stack_ctx.sp) object_t(
-            fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-    BOOST_ASSERT( impl_);
-}
-#endif
-
-template< typename R >
-void swap( pull_coroutine< R > & l, pull_coroutine< R > & r) BOOST_NOEXCEPT
-{ l.swap( r); }
-
-template< typename Arg >
-void swap( push_coroutine< Arg > & l, push_coroutine< Arg > & r) BOOST_NOEXCEPT
-{ l.swap( r); }
-
-template< typename R >
-typename pull_coroutine< R >::iterator
-range_begin( pull_coroutine< R > & c)
-{ return typename pull_coroutine< R >::iterator( & c); }
-
-template< typename R >
-typename pull_coroutine< R >::iterator
-range_end( pull_coroutine< R > &)
-{ return typename pull_coroutine< R >::iterator(); }
-
-template< typename Arg >
-typename push_coroutine< Arg >::iterator
-range_begin( push_coroutine< Arg > & c)
-{ return typename push_coroutine< Arg >::iterator( & c); }
-
-template< typename Arg >
-typename push_coroutine< Arg >::iterator
-range_end( push_coroutine< Arg > &)
-{ return typename push_coroutine< Arg >::iterator(); }
-
-template< typename T >
-struct asymmetric_coroutine
-{
-    typedef push_coroutine< T > push_type;
-    typedef pull_coroutine< T > pull_type;
-};
-
-// deprecated
-template< typename T >
-struct coroutine
-{
-    typedef push_coroutine< T > push_type;
-    typedef pull_coroutine< T > pull_type;
-};
-
-template< typename R >
-typename pull_coroutine< R >::iterator
-begin( pull_coroutine< R > & c)
-{ return autoboost::begin( c); }
-
-template< typename R >
-typename pull_coroutine< R >::iterator
-end( pull_coroutine< R > & c)
-{ return autoboost::end( c); }
-
-template< typename R >
-typename push_coroutine< R >::iterator
-begin( push_coroutine< R > & c)
-{ return autoboost::begin( c); }
-
-template< typename R >
-typename push_coroutine< R >::iterator
-end( push_coroutine< R > & c)
-{ return autoboost::end( c); }
-
-}
-
-template< typename Arg >
-struct range_mutable_iterator< coroutines::push_coroutine< Arg > >
-{ typedef typename coroutines::push_coroutine< Arg >::iterator type; };
-
-template< typename R >
-struct range_mutable_iterator< coroutines::pull_coroutine< R > >
-{ typedef typename coroutines::pull_coroutine< R >::iterator type; };
-
-}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_ASYMMETRIC_COROUTINE_H
diff --git a/contrib/autoboost/boost/coroutine/attributes.hpp b/contrib/autoboost/boost/coroutine/attributes.hpp
deleted file mode 100644
index e46a485e7..000000000
--- a/contrib/autoboost/boost/coroutine/attributes.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_ATTRIBUTES_H
-#define BOOST_COROUTINES_ATTRIBUTES_H
-
-#include <cstddef>
-
-#include <boost/config.hpp>
-
-#include <boost/coroutine/flags.hpp>
-#include <boost/coroutine/stack_allocator.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-
-struct attributes
-{
-    std::size_t     size;
-    flag_unwind_t   do_unwind;
-    flag_fpu_t      preserve_fpu;
-
-    attributes() BOOST_NOEXCEPT :
-        size( stack_allocator::traits_type::default_size() ),
-        do_unwind( stack_unwind),
-        preserve_fpu( fpu_preserved)
-    {}
-
-    explicit attributes( std::size_t size_) BOOST_NOEXCEPT :
-        size( size_),
-        do_unwind( stack_unwind),
-        preserve_fpu( fpu_preserved)
-    {}
-
-    explicit attributes( flag_unwind_t do_unwind_) BOOST_NOEXCEPT :
-        size( stack_allocator::traits_type::default_size() ),
-        do_unwind( do_unwind_),
-        preserve_fpu( fpu_preserved)
-    {}
-
-    explicit attributes( flag_fpu_t preserve_fpu_) BOOST_NOEXCEPT :
-        size( stack_allocator::traits_type::default_size() ),
-        do_unwind( stack_unwind),
-        preserve_fpu( preserve_fpu_)
-    {}
-
-    explicit attributes(
-            std::size_t size_,
-            flag_unwind_t do_unwind_) BOOST_NOEXCEPT :
-        size( size_),
-        do_unwind( do_unwind_),
-        preserve_fpu( fpu_preserved)
-    {}
-
-    explicit attributes(
-            std::size_t size_,
-            flag_fpu_t preserve_fpu_) BOOST_NOEXCEPT :
-        size( size_),
-        do_unwind( stack_unwind),
-        preserve_fpu( preserve_fpu_)
-    {}
-
-    explicit attributes(
-            flag_unwind_t do_unwind_,
-            flag_fpu_t preserve_fpu_) BOOST_NOEXCEPT :
-        size( stack_allocator::traits_type::default_size() ),
-        do_unwind( do_unwind_),
-        preserve_fpu( preserve_fpu_)
-    {}
-
-    explicit attributes(
-            std::size_t size_,
-            flag_unwind_t do_unwind_,
-            flag_fpu_t preserve_fpu_) BOOST_NOEXCEPT :
-        size( size_),
-        do_unwind( do_unwind_),
-        preserve_fpu( preserve_fpu_)
-    {}
-};
-
-}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_ATTRIBUTES_H
diff --git a/contrib/autoboost/boost/coroutine/coroutine.hpp b/contrib/autoboost/boost/coroutine/coroutine.hpp
deleted file mode 100644
index 076ffd26e..000000000
--- a/contrib/autoboost/boost/coroutine/coroutine.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_COROUTINE_H
-#define BOOST_COROUTINES_COROUTINE_H
-
-#include <boost/coroutine/asymmetric_coroutine.hpp>
-#include <boost/coroutine/symmetric_coroutine.hpp>
-
-#endif // BOOST_COROUTINES_COROUTINE_H
diff --git a/contrib/autoboost/boost/coroutine/detail/config.hpp b/contrib/autoboost/boost/coroutine/detail/config.hpp
deleted file mode 100644
index 7a88561ee..000000000
--- a/contrib/autoboost/boost/coroutine/detail/config.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_CONFIG_H
-#define BOOST_COROUTINES_DETAIL_CONFIG_H
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#ifdef BOOST_COROUTINES_DECL
-# undef BOOST_COROUTINES_DECL
-#endif
-
-#if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_COROUTINES_DYN_LINK) ) && ! defined(BOOST_COROUTINES_STATIC_LINK)
-# if defined(BOOST_COROUTINES_SOURCE)
-#  define BOOST_COROUTINES_DECL BOOST_SYMBOL_EXPORT
-#  define BOOST_COROUTINES_BUILD_DLL
-# else
-#  define BOOST_COROUTINES_DECL BOOST_SYMBOL_IMPORT
-# endif
-#endif
-
-#if ! defined(BOOST_COROUTINES_DECL)
-# define BOOST_COROUTINES_DECL
-#endif
-
-#if ! defined(BOOST_COROUTINES_SOURCE) && ! defined(BOOST_ALL_NO_LIB) && ! defined(BOOST_COROUTINES_NO_LIB)
-# define BOOST_LIB_NAME autoboost_coroutine
-# if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_COROUTINES_DYN_LINK)
-#  define BOOST_DYN_LINK
-# endif
-# include <boost/config/auto_link.hpp>
-#endif
-
-#if defined(BOOST_USE_SEGMENTED_STACKS)
-# if ! ( (defined(__GNUC__) && __GNUC__ > 3 && __GNUC_MINOR__ > 6) || \
-         (defined(__clang__) && __clang_major__ > 2 && __clang_minor__ > 3) )
-#  error "compiler does not support segmented stacks"
-# endif
-# define BOOST_COROUTINES_SEGMENTS 10
-#endif
-
-#define BOOST_COROUTINES_UNIDIRECT
-#define BOOST_COROUTINES_SYMMETRIC
-
-#endif // BOOST_COROUTINES_DETAIL_CONFIG_H
diff --git a/contrib/autoboost/boost/coroutine/detail/coroutine_context.hpp b/contrib/autoboost/boost/coroutine/detail/coroutine_context.hpp
deleted file mode 100644
index 7d0c0bdb0..000000000
--- a/contrib/autoboost/boost/coroutine/detail/coroutine_context.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_COROUTINE_CONTEXT_H
-#define BOOST_COROUTINES_DETAIL_COROUTINE_CONTEXT_H
-
-#include <cstddef>
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/context/fcontext.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/stack_context.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-namespace detail {
-
-// class hold stack-context and coroutines execution-context
-class BOOST_COROUTINES_DECL coroutine_context
-                    
-{
-private:
-    stack_context           stack_ctx_;
-    context::fcontext_t     ctx_;
-
-public:
-    typedef void( * ctx_fn)( intptr_t);
-
-    // default ctor represents the current execution-context
-    coroutine_context();
-
-    // ctor creates a new execution-context running coroutine-fn `fn`
-    // `ctx_` will be allocated on top of the stack managed by parameter
-    // `stack_ctx`
-    coroutine_context( ctx_fn fn, stack_context const& stack_ctx);
-
-    coroutine_context( coroutine_context const&);
-
-    coroutine_context& operator=( coroutine_context const&);
-
-    intptr_t jump( coroutine_context &, intptr_t = 0, bool = true);
-
-    stack_context & stack_ctx()
-    { return stack_ctx_; }
-};
-
-}}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_COROUTINE_CONTEXT_H
diff --git a/contrib/autoboost/boost/coroutine/detail/flags.hpp b/contrib/autoboost/boost/coroutine/detail/flags.hpp
deleted file mode 100644
index dd28e5938..000000000
--- a/contrib/autoboost/boost/coroutine/detail/flags.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_FLAGS_H
-#define BOOST_COROUTINES_DETAIL_FLAGS_H
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-namespace detail {
-
-enum flag_t
-{
-    flag_started        = 1 << 1,
-    flag_running        = 1 << 2,
-    flag_complete       = 1 << 3,
-    flag_unwind_stack   = 1 << 4,
-    flag_force_unwind   = 1 << 5,
-    flag_preserve_fpu   = 1 << 6
-};
-
-struct unwind_t
-{
-    enum flag_t
-    { force_unwind = 1 };
-};
-
-struct synthesized_t
-{
-    enum flag_t
-    { syntesized = 1 };
-};
-
-}}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_FLAGS_H
diff --git a/contrib/autoboost/boost/coroutine/detail/parameters.hpp b/contrib/autoboost/boost/coroutine/detail/parameters.hpp
deleted file mode 100644
index acaf8c2c9..000000000
--- a/contrib/autoboost/boost/coroutine/detail/parameters.hpp
+++ /dev/null
@@ -1,102 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_PARAMETERS_H
-#define BOOST_COROUTINES_DETAIL_PARAMETERS_H
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-
-#include <boost/coroutine/detail/flags.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-namespace detail {
-
-template< typename Data >
-struct parameters
-{
-    Data                *   data;
-    bool                    do_unwind;
-    void                *   coro;
-
-    parameters() :
-        data( 0), do_unwind( false), coro( 0)
-    {}
-
-    explicit parameters( void * coro_) :
-        data( 0), do_unwind( false), coro( coro_)
-    { BOOST_ASSERT( 0 != coro); }
-
-    explicit parameters( Data * data_, void * coro_) :
-        data( data_), do_unwind( false), coro( coro_)
-    {
-        BOOST_ASSERT( 0 != data);
-        BOOST_ASSERT( 0 != coro);
-    }
-
-    explicit parameters( unwind_t::flag_t) :
-        data( 0), do_unwind( true)
-    {}
-};
-
-template< typename Data >
-struct parameters< Data & >
-{
-    Data                *   data;
-    bool                    do_unwind;
-    void                *   coro;
-
-    parameters() :
-        data( 0), do_unwind( false), coro( 0)
-    {}
-
-    explicit parameters( void * coro_) :
-        data( 0), do_unwind( false), coro( coro_)
-    { BOOST_ASSERT( 0 != coro); }
-
-    explicit parameters( Data * data_, void * coro_) :
-        data( data_), do_unwind( false), coro( coro_)
-    {
-        BOOST_ASSERT( 0 != data);
-        BOOST_ASSERT( 0 != coro);
-    }
-
-    explicit parameters( unwind_t::flag_t) :
-        data( 0), do_unwind( true), coro( 0)
-    {}
-};
-
-template<>
-struct parameters< void >
-{
-    bool                    do_unwind;
-    void                *   coro;
-
-    parameters() :
-        do_unwind( false), coro(0)
-    {}
-
-    parameters( void * coro_) :
-        do_unwind( false), coro( coro_)
-    { BOOST_ASSERT( 0 != coro); }
-
-    explicit parameters( unwind_t::flag_t) :
-        do_unwind( true), coro( 0)
-    {}
-};
-
-}}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_PARAMETERS_H
diff --git a/contrib/autoboost/boost/coroutine/detail/pull_coroutine_impl.hpp b/contrib/autoboost/boost/coroutine/detail/pull_coroutine_impl.hpp
deleted file mode 100644
index 77aa88f00..000000000
--- a/contrib/autoboost/boost/coroutine/detail/pull_coroutine_impl.hpp
+++ /dev/null
@@ -1,355 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_PULL_COROUTINE_IMPL_H
-#define BOOST_COROUTINES_DETAIL_PULL_COROUTINE_IMPL_H
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/exception_ptr.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/utility.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/detail/coroutine_context.hpp>
-#include <boost/coroutine/detail/flags.hpp>
-#include <boost/coroutine/detail/parameters.hpp>
-#include <boost/coroutine/detail/trampoline_pull.hpp>
-#include <boost/coroutine/exceptions.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-
-struct stack_context;
-
-namespace detail {
-
-template< typename R >
-class pull_coroutine_impl : private noncopyable
-{
-protected:
-    int                     flags_;
-    exception_ptr           except_;
-    coroutine_context   *   caller_;
-    coroutine_context   *   callee_;
-    R                   *   result_;
-
-public:
-    typedef parameters< R >                           param_type;
-
-    pull_coroutine_impl( coroutine_context * caller,
-                         coroutine_context * callee,
-                         bool unwind, bool preserve_fpu) :
-        flags_( 0),
-        except_(),
-        caller_( caller),
-        callee_( callee),
-        result_( 0)
-    {
-        if ( unwind) flags_ |= flag_force_unwind;
-        if ( preserve_fpu) flags_ |= flag_preserve_fpu;
-    }
-
-    pull_coroutine_impl( coroutine_context * caller,
-                         coroutine_context * callee,
-                         bool unwind, bool preserve_fpu,
-                         R * result) :
-        flags_( 0),
-        except_(),
-        caller_( caller),
-        callee_( callee),
-        result_( result)
-    {
-        if ( unwind) flags_ |= flag_force_unwind;
-        if ( preserve_fpu) flags_ |= flag_preserve_fpu;
-    }
-
-    virtual ~pull_coroutine_impl() {}
-
-    bool force_unwind() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_force_unwind); }
-
-    bool unwind_requested() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_unwind_stack); }
-
-    bool preserve_fpu() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_preserve_fpu); }
-
-    bool is_started() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_started); }
-
-    bool is_running() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_running); }
-
-    bool is_complete() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_complete); }
-
-    void unwind_stack() BOOST_NOEXCEPT
-    {
-        if ( is_started() && ! is_complete() && force_unwind() )
-        {
-            flags_ |= flag_unwind_stack;
-            param_type to( unwind_t::force_unwind);
-            caller_->jump(
-                * callee_,
-                reinterpret_cast< intptr_t >( & to),
-                preserve_fpu() );
-            flags_ &= ~flag_unwind_stack;
-
-            BOOST_ASSERT( is_complete() );
-        }
-    }
-
-    void pull()
-    {
-        BOOST_ASSERT( ! is_running() );
-        BOOST_ASSERT( ! is_complete() );
-
-        flags_ |= flag_running;
-        param_type to( this);
-        param_type * from(
-            reinterpret_cast< param_type * >(
-                caller_->jump(
-                    * callee_,
-                    reinterpret_cast< intptr_t >( & to),
-                    preserve_fpu() ) ) );
-        flags_ &= ~flag_running;
-        result_ = from->data;
-        if ( from->do_unwind) throw forced_unwind();
-        if ( except_) rethrow_exception( except_);
-    }
-
-    bool has_result() const
-    { return 0 != result_; }
-
-    R get() const
-    {
-        if ( ! has_result() )
-            autoboost::throw_exception(
-                invalid_result() );
-        return * result_;
-    }
-
-    R * get_pointer() const
-    {
-        if ( ! has_result() )
-            autoboost::throw_exception(
-                invalid_result() );
-        return result_;
-    }
-
-    virtual void destroy() = 0;
-};
-
-template< typename R >
-class pull_coroutine_impl< R & > : private noncopyable
-{
-protected:
-    int                     flags_;
-    exception_ptr           except_;
-    coroutine_context   *   caller_;
-    coroutine_context   *   callee_;
-    R                   *   result_;
-
-public:
-    typedef parameters< R & >                           param_type;
-
-    pull_coroutine_impl( coroutine_context * caller,
-                         coroutine_context * callee,
-                         bool unwind, bool preserve_fpu) :
-        flags_( 0),
-        except_(),
-        caller_( caller),
-        callee_( callee),
-        result_( 0)
-    {
-        if ( unwind) flags_ |= flag_force_unwind;
-        if ( preserve_fpu) flags_ |= flag_preserve_fpu;
-    }
-
-    pull_coroutine_impl( coroutine_context * caller,
-                         coroutine_context * callee,
-                         bool unwind, bool preserve_fpu,
-                         R * result) :
-        flags_( 0),
-        except_(),
-        caller_( caller),
-        callee_( callee),
-        result_( result)
-    {
-        if ( unwind) flags_ |= flag_force_unwind;
-        if ( preserve_fpu) flags_ |= flag_preserve_fpu;
-    }
-
-    virtual ~pull_coroutine_impl() {}
-
-    bool force_unwind() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_force_unwind); }
-
-    bool unwind_requested() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_unwind_stack); }
-
-    bool preserve_fpu() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_preserve_fpu); }
-
-    bool is_started() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_started); }
-
-    bool is_running() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_running); }
-
-    bool is_complete() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_complete); }
-
-    void unwind_stack() BOOST_NOEXCEPT
-    {
-        if ( is_started() && ! is_complete() && force_unwind() )
-        {
-            flags_ |= flag_unwind_stack;
-            param_type to( unwind_t::force_unwind);
-            caller_->jump(
-                * callee_,
-                reinterpret_cast< intptr_t >( & to),
-                preserve_fpu() );
-            flags_ &= ~flag_unwind_stack;
-
-            BOOST_ASSERT( is_complete() );
-        }
-    }
-
-    void pull()
-    {
-        BOOST_ASSERT( ! is_running() );
-        BOOST_ASSERT( ! is_complete() );
-
-        flags_ |= flag_running;
-        param_type to( this);
-        param_type * from(
-            reinterpret_cast< param_type * >(
-                caller_->jump(
-                    * callee_,
-                    reinterpret_cast< intptr_t >( & to),
-                    preserve_fpu() ) ) );
-        flags_ &= ~flag_running;
-        result_ = from->data;
-        if ( from->do_unwind) throw forced_unwind();
-        if ( except_) rethrow_exception( except_);
-    }
-
-    bool has_result() const
-    { return 0 != result_; }
-
-    R & get() const
-    {
-        if ( ! has_result() )
-            autoboost::throw_exception(
-                invalid_result() );
-        return * result_;
-    }
-
-    R * get_pointer() const
-    {
-        if ( ! has_result() )
-            autoboost::throw_exception(
-                invalid_result() );
-        return result_;
-    }
-
-    virtual void destroy() = 0;
-};
-
-template<>
-class pull_coroutine_impl< void > : private noncopyable
-{
-protected:
-    int                     flags_;
-    exception_ptr           except_;
-    coroutine_context   *   caller_;
-    coroutine_context   *   callee_;
-
-public:
-    typedef parameters< void >      param_type;
-
-    pull_coroutine_impl( coroutine_context * caller,
-                         coroutine_context * callee,
-                         bool unwind, bool preserve_fpu) :
-        flags_( 0),
-        except_(),
-        caller_( caller),
-        callee_( callee)
-    {
-        if ( unwind) flags_ |= flag_force_unwind;
-        if ( preserve_fpu) flags_ |= flag_preserve_fpu;
-    }
-
-    virtual ~pull_coroutine_impl() {}
-
-    inline bool force_unwind() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_force_unwind); }
-
-    inline bool unwind_requested() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_unwind_stack); }
-
-    inline bool preserve_fpu() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_preserve_fpu); }
-
-    inline bool is_started() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_started); }
-
-    inline bool is_running() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_running); }
-
-    inline bool is_complete() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_complete); }
-
-    inline void unwind_stack() BOOST_NOEXCEPT
-    {
-        if ( is_started() && ! is_complete() && force_unwind() )
-        {
-            flags_ |= flag_unwind_stack;
-            param_type to( unwind_t::force_unwind);
-            caller_->jump(
-                * callee_,
-                reinterpret_cast< intptr_t >( & to),
-                preserve_fpu() );
-            flags_ &= ~flag_unwind_stack;
-
-            BOOST_ASSERT( is_complete() );
-        }
-    }
-
-    inline void pull()
-    {
-        BOOST_ASSERT( ! is_running() );
-        BOOST_ASSERT( ! is_complete() );
-
-        flags_ |= flag_running;
-        param_type to( this);
-        param_type * from(
-            reinterpret_cast< param_type * >(
-                caller_->jump(
-                    * callee_,
-                    reinterpret_cast< intptr_t >( & to),
-                    preserve_fpu() ) ) );
-        flags_ &= ~flag_running;
-        if ( from->do_unwind) throw forced_unwind();
-        if ( except_) rethrow_exception( except_);
-    }
-
-    virtual void destroy() = 0;
-};
-
-}}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_PULL_COROUTINE_IMPL_H
diff --git a/contrib/autoboost/boost/coroutine/detail/pull_coroutine_object.hpp b/contrib/autoboost/boost/coroutine/detail/pull_coroutine_object.hpp
deleted file mode 100644
index 8c1ece06f..000000000
--- a/contrib/autoboost/boost/coroutine/detail/pull_coroutine_object.hpp
+++ /dev/null
@@ -1,324 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_PULL_COROUTINE_OBJECT_H
-#define BOOST_COROUTINES_DETAIL_PULL_COROUTINE_OBJECT_H
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/exception_ptr.hpp>
-#include <boost/move/move.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/detail/coroutine_context.hpp>
-#include <boost/coroutine/detail/flags.hpp>
-#include <boost/coroutine/detail/pull_coroutine_impl.hpp>
-#include <boost/coroutine/detail/trampoline_pull.hpp>
-#include <boost/coroutine/exceptions.hpp>
-#include <boost/coroutine/flags.hpp>
-#include <boost/coroutine/stack_context.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-#if defined(BOOST_MSVC)
-# pragma warning(push)
-# pragma warning(disable:4355)
-#endif
-
-namespace autoboost {
-namespace coroutines {
-namespace detail {
-
-struct pull_coroutine_context
-{
-    coroutine_context   caller;
-    coroutine_context   callee;
-
-    template< typename Coro >
-    pull_coroutine_context( stack_context const& stack_ctx, Coro *) :
-        caller(),
-        callee( trampoline_pull< Coro >, stack_ctx)
-    {}
-};
-
-template< typename PushCoro, typename R, typename Fn, typename StackAllocator >
-class pull_coroutine_object : private pull_coroutine_context,
-                              public pull_coroutine_impl< R >
-{
-private:
-    typedef pull_coroutine_context                                      ctx_t;
-    typedef pull_coroutine_impl< R >                                    base_t;
-    typedef pull_coroutine_object< PushCoro, R, Fn, StackAllocator >    obj_t;
-
-    Fn                  fn_;
-    stack_context       stack_ctx_;
-    StackAllocator      stack_alloc_;
-
-    static void deallocate_( obj_t * obj)
-    {
-        stack_context stack_ctx( obj->stack_ctx_);
-        StackAllocator stack_alloc( obj->stack_alloc_);
-        obj->unwind_stack();
-        obj->~obj_t();
-        stack_alloc.deallocate( stack_ctx);
-    }
-
-public:
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-    pull_coroutine_object( Fn fn, attributes const& attrs,
-                           stack_context const& stack_ctx,
-                           stack_context const& internal_stack_ctx,
-                           StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        ctx_t( internal_stack_ctx, this),
-        base_t( & this->caller,
-                & this->callee,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-        fn_( fn),
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-#endif
-
-    pull_coroutine_object( BOOST_RV_REF( Fn) fn, attributes const& attrs,
-                           stack_context const& stack_ctx,
-                           stack_context const& internal_stack_ctx,
-                           StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        ctx_t( internal_stack_ctx, this),
-        base_t( & this->caller,
-                & this->callee,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-        fn_( fn),
-#else
-        fn_( autoboost::forward< Fn >( fn) ),
-#endif
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-
-    void run()
-    {
-        BOOST_ASSERT( ! base_t::unwind_requested() );
-
-        base_t::flags_ |= flag_started;
-        base_t::flags_ |= flag_running;
-
-        // create push_coroutine
-        typename PushCoro::synth_type b( & this->callee, & this->caller, false, base_t::preserve_fpu() );
-        PushCoro push_coro( synthesized_t::syntesized, b);
-        try
-        { fn_( push_coro); }
-        catch ( forced_unwind const&)
-        {}
-        catch (...)
-        { base_t::except_ = current_exception(); }
-
-        base_t::flags_ |= flag_complete;
-        base_t::flags_ &= ~flag_running;
-        typename base_t::param_type to;
-        this->callee.jump(
-            this->caller,
-            reinterpret_cast< intptr_t >( & to),
-            base_t::preserve_fpu() );
-        BOOST_ASSERT_MSG( false, "pull_coroutine is complete");
-    }
-
-    void destroy()
-    { deallocate_( this); }
-};
-
-template< typename PushCoro, typename R, typename Fn, typename StackAllocator >
-class pull_coroutine_object< PushCoro, R &, Fn, StackAllocator > : private pull_coroutine_context,
-                                                                   public pull_coroutine_impl< R & >
-{
-private:
-    typedef pull_coroutine_context                                      ctx_t;
-    typedef pull_coroutine_impl< R & >                                  base_t;
-    typedef pull_coroutine_object< PushCoro, R &, Fn, StackAllocator >  obj_t;
-
-    Fn                  fn_;
-    stack_context       stack_ctx_;
-    StackAllocator      stack_alloc_;
-
-    static void deallocate_( obj_t * obj)
-    {
-        stack_context stack_ctx( obj->stack_ctx_);
-        StackAllocator stack_alloc( obj->stack_alloc_);
-        obj->unwind_stack();
-        obj->~obj_t();
-        stack_alloc.deallocate( stack_ctx);
-    }
-
-public:
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-    pull_coroutine_object( Fn fn, attributes const& attrs,
-                           stack_context const& stack_ctx,
-                           stack_context const& internal_stack_ctx,
-                           StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        ctx_t( internal_stack_ctx, this),
-        base_t( & this->caller,
-                & this->callee,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-        fn_( fn),
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-#endif
-
-    pull_coroutine_object( BOOST_RV_REF( Fn) fn, attributes const& attrs,
-                           stack_context const& stack_ctx,
-                           stack_context const& internal_stack_ctx,
-                           StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        ctx_t( internal_stack_ctx, this),
-        base_t( & this->caller,
-                & this->callee,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-        fn_( fn),
-#else
-        fn_( autoboost::forward< Fn >( fn) ),
-#endif
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-
-    void run()
-    {
-        BOOST_ASSERT( ! base_t::unwind_requested() );
-
-        base_t::flags_ |= flag_started;
-        base_t::flags_ |= flag_running;
-
-        // create push_coroutine
-        typename PushCoro::synth_type b( & this->callee, & this->caller, false, base_t::preserve_fpu() );
-        PushCoro push_coro( synthesized_t::syntesized, b);
-        try
-        { fn_( push_coro); }
-        catch ( forced_unwind const&)
-        {}
-        catch (...)
-        { base_t::except_ = current_exception(); }
-
-        base_t::flags_ |= flag_complete;
-        base_t::flags_ &= ~flag_running;
-        typename base_t::param_type to;
-        this->callee.jump(
-            this->caller,
-            reinterpret_cast< intptr_t >( & to),
-            base_t::preserve_fpu() );
-        BOOST_ASSERT_MSG( false, "pull_coroutine is complete");
-    }
-
-    void destroy()
-    { deallocate_( this); }
-};
-
-template< typename PushCoro, typename Fn, typename StackAllocator >
-class pull_coroutine_object< PushCoro, void, Fn, StackAllocator > : private pull_coroutine_context,
-                                                                    public pull_coroutine_impl< void >
-{
-private:
-    typedef pull_coroutine_context                                      ctx_t;
-    typedef pull_coroutine_impl< void >                                 base_t;
-    typedef pull_coroutine_object< PushCoro, void, Fn, StackAllocator > obj_t;
-
-    Fn                  fn_;
-    stack_context       stack_ctx_;
-    StackAllocator      stack_alloc_;
-
-    static void deallocate_( obj_t * obj)
-    {
-        stack_context stack_ctx( obj->stack_ctx_);
-        StackAllocator stack_alloc( obj->stack_alloc_);
-        obj->unwind_stack();
-        obj->~obj_t();
-        stack_alloc.deallocate( stack_ctx);
-    }
-
-public:
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-    pull_coroutine_object( Fn fn, attributes const& attrs,
-                           stack_context const& stack_ctx,
-                           stack_context const& internal_stack_ctx,
-                           StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        ctx_t( internal_stack_ctx, this),
-        base_t( & this->caller,
-                & this->callee,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-        fn_( fn),
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-#endif
-
-    pull_coroutine_object( BOOST_RV_REF( Fn) fn, attributes const& attrs,
-                           stack_context const& stack_ctx,
-                           stack_context const& internal_stack_ctx,
-                           StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        ctx_t( internal_stack_ctx, this),
-        base_t( & this->caller,
-                & this->callee,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-        fn_( fn),
-#else
-        fn_( autoboost::forward< Fn >( fn) ),
-#endif
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-
-    void run()
-    {
-        BOOST_ASSERT( ! base_t::unwind_requested() );
-
-        base_t::flags_ |= flag_started;
-        base_t::flags_ |= flag_running;
-
-        // create push_coroutine
-        typename PushCoro::synth_type b( & this->callee, & this->caller, false, base_t::preserve_fpu() );
-        PushCoro push_coro( synthesized_t::syntesized, b);
-        try
-        { fn_( push_coro); }
-        catch ( forced_unwind const&)
-        {}
-        catch (...)
-        { base_t::except_ = current_exception(); }
-
-        base_t::flags_ |= flag_complete;
-        base_t::flags_ &= ~flag_running;
-        typename base_t::param_type to;
-        this->callee.jump(
-            this->caller,
-            reinterpret_cast< intptr_t >( & to),
-            base_t::preserve_fpu() );
-        BOOST_ASSERT_MSG( false, "pull_coroutine is complete");
-    }
-
-    void destroy()
-    { deallocate_( this); }
-};
-
-}}}
-
-#if defined(BOOST_MSVC)
-# pragma warning(pop)
-#endif
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_PULL_COROUTINE_OBJECT_H
diff --git a/contrib/autoboost/boost/coroutine/detail/pull_coroutine_synthesized.hpp b/contrib/autoboost/boost/coroutine/detail/pull_coroutine_synthesized.hpp
deleted file mode 100644
index 9fb5d323b..000000000
--- a/contrib/autoboost/boost/coroutine/detail/pull_coroutine_synthesized.hpp
+++ /dev/null
@@ -1,80 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_PULL_COROUTINE_SYNTHESIZED_H
-#define BOOST_COROUTINES_DETAIL_PULL_COROUTINE_SYNTHESIZED_H
-
-#include <boost/config.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/detail/coroutine_context.hpp>
-#include <boost/coroutine/detail/pull_coroutine_impl.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-namespace detail {
-
-template< typename R >
-class pull_coroutine_synthesized : public pull_coroutine_impl< R >
-{
-private:
-    typedef pull_coroutine_impl< R >                                    impl_t;
-
-public:
-    pull_coroutine_synthesized( coroutine_context * caller,
-                                coroutine_context * callee,
-                                bool unwind, bool preserve_fpu,
-                                R * result) :
-        impl_t( caller, callee, unwind, preserve_fpu, result)
-    {}
-
-    void destroy() {}
-};
-
-template< typename R >
-class pull_coroutine_synthesized< R & > : public pull_coroutine_impl< R & >
-{
-private:
-    typedef pull_coroutine_impl< R & >                                    impl_t;
-
-public:
-    pull_coroutine_synthesized( coroutine_context * caller,
-                                coroutine_context * callee,
-                                bool unwind, bool preserve_fpu,
-                                R * result) :
-        impl_t( caller, callee, unwind, preserve_fpu, result)
-    {}
-
-    void destroy() {}
-};
-
-template<>
-class pull_coroutine_synthesized< void > : public pull_coroutine_impl< void >
-{
-private:
-    typedef pull_coroutine_impl< void >                                    impl_t;
-
-public:
-    pull_coroutine_synthesized( coroutine_context * caller,
-                                coroutine_context * callee,
-                                bool unwind, bool preserve_fpu) :
-        impl_t( caller, callee, unwind, preserve_fpu)
-    {}
-
-    inline void destroy() {}
-};
-
-}}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_PULL_COROUTINE_SYNTHESIZED_H
diff --git a/contrib/autoboost/boost/coroutine/detail/push_coroutine_impl.hpp b/contrib/autoboost/boost/coroutine/detail/push_coroutine_impl.hpp
deleted file mode 100644
index 2cf31f889..000000000
--- a/contrib/autoboost/boost/coroutine/detail/push_coroutine_impl.hpp
+++ /dev/null
@@ -1,295 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_PUSH_COROUTINE_IMPL_H
-#define BOOST_COROUTINES_DETAIL_PUSH_COROUTINE_IMPL_H
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/exception_ptr.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/utility.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/detail/coroutine_context.hpp>
-#include <boost/coroutine/detail/flags.hpp>
-#include <boost/coroutine/detail/parameters.hpp>
-#include <boost/coroutine/detail/trampoline_push.hpp>
-#include <boost/coroutine/exceptions.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-
-struct stack_context;
-
-namespace detail {
-
-template< typename Arg >
-class push_coroutine_impl : private noncopyable
-{
-protected:
-    int                     flags_;
-    exception_ptr           except_;
-    coroutine_context   *   caller_;
-    coroutine_context   *   callee_;
-
-public:
-    typedef parameters< Arg >                           param_type;
-
-    push_coroutine_impl( coroutine_context * caller,
-                         coroutine_context * callee,
-                         bool unwind, bool preserve_fpu) :
-        flags_( 0),
-        except_(),
-        caller_( caller),
-        callee_( callee)
-    {
-        if ( unwind) flags_ |= flag_force_unwind;
-        if ( preserve_fpu) flags_ |= flag_preserve_fpu;
-    }
-
-    bool force_unwind() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_force_unwind); }
-
-    bool unwind_requested() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_unwind_stack); }
-
-    bool preserve_fpu() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_preserve_fpu); }
-
-    bool is_started() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_started); }
-
-    bool is_running() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_running); }
-
-    bool is_complete() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_complete); }
-
-    void unwind_stack() BOOST_NOEXCEPT
-    {
-        if ( is_started() && ! is_complete() && force_unwind() )
-        {
-            flags_ |= flag_unwind_stack;
-            param_type to( unwind_t::force_unwind);
-            caller_->jump(
-                * callee_,
-                reinterpret_cast< intptr_t >( & to),
-                preserve_fpu() );
-            flags_ &= ~flag_unwind_stack;
-
-            BOOST_ASSERT( is_complete() );
-        }
-    }
-
-    void push( Arg const& arg)
-    {
-        BOOST_ASSERT( ! is_running() );
-        BOOST_ASSERT( ! is_complete() );
-
-        flags_ |= flag_running;
-        param_type to( const_cast< Arg * >( & arg), this);
-        param_type * from(
-            reinterpret_cast< param_type * >(
-                caller_->jump(
-                    * callee_,
-                    reinterpret_cast< intptr_t >( & to),
-                    preserve_fpu() ) ) );
-        flags_ &= ~flag_running;
-        if ( from->do_unwind) throw forced_unwind();
-        if ( except_) rethrow_exception( except_);
-    }
-
-    void push( BOOST_RV_REF( Arg) arg)
-    {
-        BOOST_ASSERT( ! is_running() );
-        BOOST_ASSERT( ! is_complete() );
-
-        flags_ |= flag_running;
-        param_type to( const_cast< Arg * >( & arg), this);
-        param_type * from(
-            reinterpret_cast< param_type * >(
-                caller_->jump(
-                    * callee_,
-                    reinterpret_cast< intptr_t >( & to),
-                    preserve_fpu() ) ) );
-        flags_ &= ~flag_running;
-        if ( from->do_unwind) throw forced_unwind();
-        if ( except_) rethrow_exception( except_);
-    }
-
-    virtual void destroy() = 0;
-};
-
-template< typename Arg >
-class push_coroutine_impl< Arg & > : private noncopyable
-{
-protected:
-    int                     flags_;
-    exception_ptr           except_;
-    coroutine_context   *   caller_;
-    coroutine_context   *   callee_;
-
-public:
-    typedef parameters< Arg & >                         param_type;
-
-    push_coroutine_impl( coroutine_context * caller,
-                         coroutine_context * callee,
-                         bool unwind, bool preserve_fpu) :
-        flags_( 0),
-        except_(),
-        caller_( caller),
-        callee_( callee)
-    {
-        if ( unwind) flags_ |= flag_force_unwind;
-        if ( preserve_fpu) flags_ |= flag_preserve_fpu;
-    }
-
-    bool force_unwind() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_force_unwind); }
-
-    bool unwind_requested() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_unwind_stack); }
-
-    bool preserve_fpu() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_preserve_fpu); }
-
-    bool is_started() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_started); }
-
-    bool is_running() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_running); }
-
-    bool is_complete() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_complete); }
-
-    void unwind_stack() BOOST_NOEXCEPT
-    {
-        if ( is_started() && ! is_complete() && force_unwind() )
-        {
-            flags_ |= flag_unwind_stack;
-            param_type to( unwind_t::force_unwind);
-            caller_->jump(
-                * callee_,
-                reinterpret_cast< intptr_t >( & to),
-                preserve_fpu() );
-            flags_ &= ~flag_unwind_stack;
-
-            BOOST_ASSERT( is_complete() );
-        }
-    }
-
-    void push( Arg & arg)
-    {
-        BOOST_ASSERT( ! is_running() );
-        BOOST_ASSERT( ! is_complete() );
-
-        flags_ |= flag_running;
-        param_type to( & arg, this);
-        param_type * from(
-            reinterpret_cast< param_type * >(
-                caller_->jump(
-                    * callee_,
-                    reinterpret_cast< intptr_t >( & to),
-                    preserve_fpu() ) ) );
-        flags_ &= ~flag_running;
-        if ( from->do_unwind) throw forced_unwind();
-        if ( except_) rethrow_exception( except_);
-    }
-
-    virtual void destroy() = 0;
-};
-
-template<>
-class push_coroutine_impl< void > : private noncopyable
-{
-protected:
-    int                     flags_;
-    exception_ptr           except_;
-    coroutine_context   *   caller_;
-    coroutine_context   *   callee_;
-
-public:
-    typedef parameters< void >                          param_type;
-
-    push_coroutine_impl( coroutine_context * caller,
-                         coroutine_context * callee,
-                         bool unwind, bool preserve_fpu) :
-        flags_( 0),
-        except_(),
-        caller_( caller),
-        callee_( callee)
-    {
-        if ( unwind) flags_ |= flag_force_unwind;
-        if ( preserve_fpu) flags_ |= flag_preserve_fpu;
-    }
-
-    inline bool force_unwind() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_force_unwind); }
-
-    inline bool unwind_requested() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_unwind_stack); }
-
-    inline bool preserve_fpu() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_preserve_fpu); }
-
-    inline bool is_started() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_started); }
-
-    inline bool is_running() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_running); }
-
-    inline bool is_complete() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_complete); }
-
-    inline void unwind_stack() BOOST_NOEXCEPT
-    {
-        if ( is_started() && ! is_complete() && force_unwind() )
-        {
-            flags_ |= flag_unwind_stack;
-            param_type to( unwind_t::force_unwind);
-            caller_->jump(
-                * callee_,
-                reinterpret_cast< intptr_t >( & to),
-                preserve_fpu() );
-            flags_ &= ~flag_unwind_stack;
-
-            BOOST_ASSERT( is_complete() );
-        }
-    }
-
-    inline void push()
-    {
-        BOOST_ASSERT( ! is_running() );
-        BOOST_ASSERT( ! is_complete() );
-
-        flags_ |= flag_running;
-        param_type to( this);
-        param_type * from(
-            reinterpret_cast< param_type * >(
-                caller_->jump(
-                    * callee_,
-                    reinterpret_cast< intptr_t >( & to),
-                    preserve_fpu() ) ) );
-        flags_ &= ~flag_running;
-        if ( from->do_unwind) throw forced_unwind();
-        if ( except_) rethrow_exception( except_);
-    }
-
-    virtual void destroy() = 0;
-};
-
-}}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_PUSH_COROUTINE_IMPL_H
diff --git a/contrib/autoboost/boost/coroutine/detail/push_coroutine_object.hpp b/contrib/autoboost/boost/coroutine/detail/push_coroutine_object.hpp
deleted file mode 100644
index c23645182..000000000
--- a/contrib/autoboost/boost/coroutine/detail/push_coroutine_object.hpp
+++ /dev/null
@@ -1,336 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_PUSH_COROUTINE_OBJECT_H
-#define BOOST_COROUTINES_DETAIL_PUSH_COROUTINE_OBJECT_H
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/exception_ptr.hpp>
-#include <boost/move/move.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/detail/coroutine_context.hpp>
-#include <boost/coroutine/detail/flags.hpp>
-#include <boost/coroutine/detail/push_coroutine_impl.hpp>
-#include <boost/coroutine/detail/trampoline_push.hpp>
-#include <boost/coroutine/exceptions.hpp>
-#include <boost/coroutine/flags.hpp>
-#include <boost/coroutine/stack_context.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-#if defined(BOOST_MSVC)
-# pragma warning(push)
-# pragma warning(disable:4355)
-#endif
-
-namespace autoboost {
-namespace coroutines {
-namespace detail {
-
-struct push_coroutine_context
-{
-    coroutine_context   caller;
-    coroutine_context   callee;
-
-    template< typename Coro >
-    push_coroutine_context( stack_context const& stack_ctx, Coro *) :
-        caller(),
-        callee( trampoline_push< Coro >, stack_ctx)
-    {}
-};
-
-struct push_coroutine_context_void
-{
-    coroutine_context   caller;
-    coroutine_context   callee;
-
-    template< typename Coro >
-    push_coroutine_context_void( stack_context const& stack_ctx, Coro *) :
-        caller(),
-        callee( trampoline_push_void< Coro >, stack_ctx)
-    {}
-};
-
-template< typename PullCoro, typename R, typename Fn, typename StackAllocator >
-class push_coroutine_object : private push_coroutine_context,
-                              public push_coroutine_impl< R >
-{
-private:
-    typedef push_coroutine_context                                      ctx_t;
-    typedef push_coroutine_impl< R >                                    base_t;
-    typedef push_coroutine_object< PullCoro, R, Fn, StackAllocator >    obj_t;
-
-    Fn                  fn_;
-    stack_context       stack_ctx_;
-    StackAllocator      stack_alloc_;
-
-    static void deallocate_( obj_t * obj)
-    {
-        stack_context stack_ctx( obj->stack_ctx_);
-        StackAllocator stack_alloc( obj->stack_alloc_);
-        obj->unwind_stack();
-        obj->~obj_t();
-        stack_alloc.deallocate( stack_ctx);
-    }
-
-public:
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-    push_coroutine_object( Fn fn, attributes const& attrs,
-                           stack_context const& stack_ctx,
-                           stack_context const& internal_stack_ctx,
-                           StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        ctx_t( internal_stack_ctx, this),
-        base_t( & this->caller,
-                & this->callee,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-        fn_( fn),
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-#endif
-
-    push_coroutine_object( BOOST_RV_REF( Fn) fn, attributes const& attrs,
-                           stack_context const& stack_ctx,
-                           stack_context const& internal_stack_ctx,
-                           StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        ctx_t( internal_stack_ctx, this),
-        base_t( & this->caller,
-                & this->callee,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-        fn_( fn),
-#else
-        fn_( autoboost::forward< Fn >( fn) ),
-#endif
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-
-    void run( R * result)
-    {
-        BOOST_ASSERT( ! base_t::unwind_requested() );
-
-        base_t::flags_ |= flag_started;
-        base_t::flags_ |= flag_running;
-
-        // create push_coroutine
-        typename PullCoro::synth_type b( & this->callee, & this->caller, false, base_t::preserve_fpu(), result);
-        PullCoro pull_coro( synthesized_t::syntesized, b);
-        try
-        { fn_( pull_coro); }
-        catch ( forced_unwind const&)
-        {}
-        catch (...)
-        { base_t::except_ = current_exception(); }
-
-        base_t::flags_ |= flag_complete;
-        base_t::flags_ &= ~flag_running;
-        typename base_t::param_type to;
-        this->callee.jump(
-            this->caller,
-            reinterpret_cast< intptr_t >( & to),
-            base_t::preserve_fpu() );
-        BOOST_ASSERT_MSG( false, "pull_coroutine is complete");
-    }
-
-    void destroy()
-    { deallocate_( this); }
-};
-
-template< typename PullCoro, typename R, typename Fn, typename StackAllocator >
-class push_coroutine_object< PullCoro, R &, Fn, StackAllocator > : private push_coroutine_context,
-                                                                   public push_coroutine_impl< R & >
-{
-private:
-    typedef push_coroutine_context                                          ctx_t;
-    typedef push_coroutine_impl< R & >                                      base_t;
-    typedef push_coroutine_object< PullCoro, R &, Fn, StackAllocator >      obj_t;
-
-    Fn                  fn_;
-    stack_context       stack_ctx_;
-    StackAllocator      stack_alloc_;
-
-    static void deallocate_( obj_t * obj)
-    {
-        stack_context stack_ctx( obj->stack_ctx_);
-        StackAllocator stack_alloc( obj->stack_alloc_);
-        obj->unwind_stack();
-        obj->~obj_t();
-        stack_alloc.deallocate( stack_ctx);
-    }
-
-public:
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-    push_coroutine_object( Fn fn, attributes const& attrs,
-                           stack_context const& stack_ctx,
-                           stack_context const& internal_stack_ctx,
-                           StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        ctx_t( internal_stack_ctx, this),
-        base_t( & this->caller,
-                & this->callee,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-        fn_( fn),
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-#endif
-
-    push_coroutine_object( BOOST_RV_REF( Fn) fn, attributes const& attrs,
-                           stack_context const& stack_ctx,
-                           stack_context const& internal_stack_ctx,
-                           StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        ctx_t( internal_stack_ctx, this),
-        base_t( & this->caller,
-                & this->callee,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-        fn_( fn),
-#else
-        fn_( autoboost::forward< Fn >( fn) ),
-#endif
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-
-    void run( R * result)
-    {
-        BOOST_ASSERT( ! base_t::unwind_requested() );
-
-        base_t::flags_ |= flag_started;
-        base_t::flags_ |= flag_running;
-
-        // create push_coroutine
-        typename PullCoro::synth_type b( & this->callee, & this->caller, false, base_t::preserve_fpu(), result);
-        PullCoro push_coro( synthesized_t::syntesized, b);
-        try
-        { fn_( push_coro); }
-        catch ( forced_unwind const&)
-        {}
-        catch (...)
-        { base_t::except_ = current_exception(); }
-
-        base_t::flags_ |= flag_complete;
-        base_t::flags_ &= ~flag_running;
-        typename base_t::param_type to;
-        this->callee.jump(
-            this->caller,
-            reinterpret_cast< intptr_t >( & to),
-            base_t::preserve_fpu() );
-        BOOST_ASSERT_MSG( false, "pull_coroutine is complete");
-    }
-
-    void destroy()
-    { deallocate_( this); }
-};
-
-template< typename PullCoro, typename Fn, typename StackAllocator >
-class push_coroutine_object< PullCoro, void, Fn, StackAllocator > : private push_coroutine_context_void,
-                                                                    public push_coroutine_impl< void >
-{
-private:
-    typedef push_coroutine_context_void                                     ctx_t;
-    typedef push_coroutine_impl< void >                                     base_t;
-    typedef push_coroutine_object< PullCoro, void, Fn, StackAllocator >     obj_t;
-
-    Fn                  fn_;
-    stack_context       stack_ctx_;
-    StackAllocator      stack_alloc_;
-
-    static void deallocate_( obj_t * obj)
-    {
-        stack_context stack_ctx( obj->stack_ctx_);
-        StackAllocator stack_alloc( obj->stack_alloc_);
-        obj->unwind_stack();
-        obj->~obj_t();
-        stack_alloc.deallocate( stack_ctx);
-    }
-
-public:
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-    push_coroutine_object( Fn fn, attributes const& attrs,
-                           stack_context const& stack_ctx,
-                           stack_context const& internal_stack_ctx,
-                           StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        ctx_t( internal_stack_ctx, this),
-        base_t( & this->caller,
-                & this->callee,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-        fn_( fn),
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-#endif
-
-    push_coroutine_object( BOOST_RV_REF( Fn) fn, attributes const& attrs,
-                           stack_context const& stack_ctx,
-                           stack_context const& internal_stack_ctx,
-                           StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        ctx_t( internal_stack_ctx, this),
-        base_t( & this->caller,
-                & this->callee,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-        fn_( fn),
-#else
-        fn_( autoboost::forward< Fn >( fn) ),
-#endif
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-
-    void run()
-    {
-        BOOST_ASSERT( ! base_t::unwind_requested() );
-
-        base_t::flags_ |= flag_started;
-        base_t::flags_ |= flag_running;
-
-        // create push_coroutine
-        typename PullCoro::synth_type b( & this->callee, & this->caller, false, base_t::preserve_fpu() );
-        PullCoro push_coro( synthesized_t::syntesized, b);
-        try
-        { fn_( push_coro); }
-        catch ( forced_unwind const&)
-        {}
-        catch (...)
-        { base_t::except_ = current_exception(); }
-
-        base_t::flags_ |= flag_complete;
-        base_t::flags_ &= ~flag_running;
-        typename base_t::param_type to;
-        this->callee.jump(
-            this->caller,
-            reinterpret_cast< intptr_t >( & to),
-            base_t::preserve_fpu() );
-        BOOST_ASSERT_MSG( false, "pull_coroutine is complete");
-    }
-
-    void destroy()
-    { deallocate_( this); }
-};
-
-}}}
-
-#if defined(BOOST_MSVC)
-# pragma warning(pop)
-#endif
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_PUSH_COROUTINE_OBJECT_H
diff --git a/contrib/autoboost/boost/coroutine/detail/push_coroutine_synthesized.hpp b/contrib/autoboost/boost/coroutine/detail/push_coroutine_synthesized.hpp
deleted file mode 100644
index e9415af68..000000000
--- a/contrib/autoboost/boost/coroutine/detail/push_coroutine_synthesized.hpp
+++ /dev/null
@@ -1,78 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_PUSH_COROUTINE_SYNTHESIZED_H
-#define BOOST_COROUTINES_DETAIL_PUSH_COROUTINE_SYNTHESIZED_H
-
-#include <boost/config.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/detail/coroutine_context.hpp>
-#include <boost/coroutine/detail/push_coroutine_impl.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-namespace detail {
-
-template< typename R >
-class push_coroutine_synthesized : public push_coroutine_impl< R >
-{
-private:
-    typedef push_coroutine_impl< R >                                    impl_t;
-
-public:
-    push_coroutine_synthesized( coroutine_context * caller,
-                                coroutine_context * callee,
-                                bool unwind, bool preserve_fpu) :
-        impl_t( caller, callee, unwind, preserve_fpu)
-    {}
-
-    void destroy() {}
-};
-
-template< typename R >
-class push_coroutine_synthesized< R & > : public push_coroutine_impl< R & >
-{
-private:
-    typedef push_coroutine_impl< R & >                                    impl_t;
-
-public:
-    push_coroutine_synthesized( coroutine_context * caller,
-                                coroutine_context * callee,
-                                bool unwind, bool preserve_fpu) :
-        impl_t( caller, callee, unwind, preserve_fpu)
-    {}
-
-    void destroy() {}
-};
-
-template<>
-class push_coroutine_synthesized< void > : public push_coroutine_impl< void >
-{
-private:
-    typedef push_coroutine_impl< void >                                    impl_t;
-
-public:
-    push_coroutine_synthesized( coroutine_context * caller,
-                                coroutine_context * callee,
-                                bool unwind, bool preserve_fpu) :
-        impl_t( caller, callee, unwind, preserve_fpu)
-    {}
-
-    inline void destroy() {}
-};
-
-}}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_PUSH_COROUTINE_SYNTHESIZED_H
diff --git a/contrib/autoboost/boost/coroutine/detail/setup.hpp b/contrib/autoboost/boost/coroutine/detail/setup.hpp
deleted file mode 100644
index 04a65bbc0..000000000
--- a/contrib/autoboost/boost/coroutine/detail/setup.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_SETUP_H
-#define BOOST_COROUTINES_DETAIL_SETUP_H
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/move/move.hpp>
-#include <boost/type_traits/decay.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_same.hpp>
-
-#include <boost/coroutine/attributes.hpp>
-#include <boost/coroutine/detail/coroutine_context.hpp>
-#include <boost/coroutine/detail/flags.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-namespace detail {
-
-template< typename Fn >
-struct setup
-{
-    struct dummy {};
-
-    Fn                      fn;
-    coroutine_context   *   caller;
-    coroutine_context   *   callee;
-    attributes              attr;
-
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-    setup( Fn fn_,
-           coroutine_context * caller_,
-           coroutine_context * callee_,
-           attributes const& attr_) :
-        fn( autoboost::forward< Fn >( fn_) ),
-        caller( caller_),
-        callee( callee_),
-        attr( attr_)
-    {}
-#endif
-    setup( BOOST_RV_REF( Fn) fn_,
-           coroutine_context * caller_,
-           coroutine_context * callee_,
-           attributes const& attr_,
-           typename disable_if<
-               is_same< typename decay< Fn >::type, setup >,
-               dummy*
-           >::type = 0) :
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-        fn( fn_),
-#else
-        fn( autoboost::forward< Fn >( fn_) ),
-#endif
-        caller( caller_),
-        callee( callee_),
-        attr( attr_)
-    {}
-};
-
-}}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_SETUP_H
diff --git a/contrib/autoboost/boost/coroutine/detail/symmetric_coroutine_call.hpp b/contrib/autoboost/boost/coroutine/detail/symmetric_coroutine_call.hpp
deleted file mode 100644
index c7042f5a2..000000000
--- a/contrib/autoboost/boost/coroutine/detail/symmetric_coroutine_call.hpp
+++ /dev/null
@@ -1,822 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_CALL_H
-#define BOOST_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_CALL_H
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/move/move.hpp>
-#include <boost/utility/explicit_operator_bool.hpp>
-
-#include <boost/coroutine/attributes.hpp>
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/detail/symmetric_coroutine_impl.hpp>
-#include <boost/coroutine/detail/symmetric_coroutine_object.hpp>
-#include <boost/coroutine/detail/symmetric_coroutine_yield.hpp>
-#include <boost/coroutine/stack_allocator.hpp>
-#include <boost/coroutine/stack_context.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-namespace detail {
-
-template< typename Arg >
-class symmetric_coroutine_call
-{
-private:
-    template< typename X >
-    friend class symmetric_coroutine_yield;
-
-    typedef symmetric_coroutine_impl< Arg >   impl_type;
-
-    BOOST_MOVABLE_BUT_NOT_COPYABLE( symmetric_coroutine_call)
-
-    struct dummy {};
-
-    impl_type       *   impl_;
-
-public:
-    typedef Arg                                value_type;
-    typedef symmetric_coroutine_yield< Arg >   yield_type;
-
-    symmetric_coroutine_call() BOOST_NOEXCEPT :
-        impl_( 0)
-    {}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-# ifdef BOOST_MSVC
-    typedef void ( * coroutine_fn)( yield_type &);
-
-    explicit symmetric_coroutine_call( coroutine_fn fn,
-                                       attributes const& attrs = attributes(),
-                                       stack_allocator stack_alloc = stack_allocator() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg, coroutine_fn, stack_allocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-
-    template< typename StackAllocator >
-    explicit symmetric_coroutine_call( coroutine_fn fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg, coroutine_fn, StackAllocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-# endif
-    template< typename Fn >
-    explicit symmetric_coroutine_call( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs = attributes(),
-                                       stack_allocator stack_alloc = stack_allocator() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg, Fn, stack_allocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit symmetric_coroutine_call( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg, Fn, StackAllocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-#else
-    template< typename Fn >
-    explicit symmetric_coroutine_call( Fn fn,
-                                       attributes const& attrs = attributes(),
-                                       stack_allocator stack_alloc = stack_allocator() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg, Fn, stack_allocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t( fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit symmetric_coroutine_call( Fn fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg, Fn, StackAllocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t( fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-
-    template< typename Fn >
-    explicit symmetric_coroutine_call( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs = attributes(),
-                                       stack_allocator stack_alloc = stack_allocator() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg, Fn, stack_allocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t( fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit symmetric_coroutine_call( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg, Fn, StackAllocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t( fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-#endif
-
-    ~symmetric_coroutine_call()
-    {
-        if ( 0 != impl_)
-        {
-            impl_->destroy();
-            impl_ = 0;
-        }
-    }
-
-    symmetric_coroutine_call( BOOST_RV_REF( symmetric_coroutine_call) other) BOOST_NOEXCEPT :
-        impl_( 0)
-    { swap( other); }
-
-    symmetric_coroutine_call & operator=( BOOST_RV_REF( symmetric_coroutine_call) other) BOOST_NOEXCEPT
-    {
-        symmetric_coroutine_call tmp( autoboost::move( other) );
-        swap( tmp);
-        return * this;
-    }
-
-    BOOST_EXPLICIT_OPERATOR_BOOL();
-
-    bool operator!() const BOOST_NOEXCEPT
-    { return 0 == impl_ || impl_->is_complete() || impl_->is_running(); }
-
-    void swap( symmetric_coroutine_call & other) BOOST_NOEXCEPT
-    { std::swap( impl_, other.impl_); }
-
-    symmetric_coroutine_call & operator()( Arg arg) BOOST_NOEXCEPT
-    {
-        BOOST_ASSERT( * this);
-
-        impl_->resume( arg);
-        return * this;
-    }
-};
-
-template< typename Arg >
-class symmetric_coroutine_call< Arg & >
-{
-private:
-    template< typename X >
-    friend class symmetric_coroutine_yield;
-
-    typedef symmetric_coroutine_impl< Arg & >     impl_type;
-
-    BOOST_MOVABLE_BUT_NOT_COPYABLE( symmetric_coroutine_call)
-
-    struct dummy {};
-
-    impl_type       *   impl_;
-
-public:
-    typedef Arg                                    value_type;
-    typedef symmetric_coroutine_yield< Arg & >     yield_type;
-
-    symmetric_coroutine_call() BOOST_NOEXCEPT :
-        impl_( 0)
-    {}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-# ifdef BOOST_MSVC
-    typedef void ( * coroutine_fn)( yield_type &);
-
-    explicit symmetric_coroutine_call( coroutine_fn fn,
-                                       attributes const& attrs = attributes(),
-                                       stack_allocator stack_alloc = stack_allocator() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg &, coroutine_fn, stack_allocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-
-    template< typename StackAllocator >
-    explicit symmetric_coroutine_call( coroutine_fn fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg &, coroutine_fn, StackAllocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-# endif
-    template< typename Fn >
-    explicit symmetric_coroutine_call( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs = attributes(),
-                                       stack_allocator stack_alloc = stack_allocator() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg &, Fn, stack_allocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit symmetric_coroutine_call( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg &, Fn, StackAllocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-#else
-    template< typename Fn >
-    explicit symmetric_coroutine_call( Fn fn,
-                                       attributes const& attrs = attributes(),
-                                       stack_allocator stack_alloc = stack_allocator() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg &, Fn, stack_allocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t( fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit symmetric_coroutine_call( Fn fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg &, Fn, StackAllocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t( fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-
-    template< typename Fn >
-    explicit symmetric_coroutine_call( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs = attributes(),
-                                       stack_allocator stack_alloc = stack_allocator() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg &, Fn, stack_allocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t( fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit symmetric_coroutine_call( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< Arg &, Fn, StackAllocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t( fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-#endif
-
-    ~symmetric_coroutine_call()
-    {
-        if ( 0 != impl_)
-        {
-            impl_->destroy();
-            impl_ = 0;
-        }
-    }
-
-    symmetric_coroutine_call( BOOST_RV_REF( symmetric_coroutine_call) other) BOOST_NOEXCEPT :
-        impl_( 0)
-    { swap( other); }
-
-    symmetric_coroutine_call & operator=( BOOST_RV_REF( symmetric_coroutine_call) other) BOOST_NOEXCEPT
-    {
-        symmetric_coroutine_call tmp( autoboost::move( other) );
-        swap( tmp);
-        return * this;
-    }
-
-    BOOST_EXPLICIT_OPERATOR_BOOL();
-
-    bool operator!() const BOOST_NOEXCEPT
-    { return 0 == impl_ || impl_->is_complete() || impl_->is_running(); }
-
-    void swap( symmetric_coroutine_call & other) BOOST_NOEXCEPT
-    { std::swap( impl_, other.impl_); }
-
-    symmetric_coroutine_call & operator()( Arg & arg) BOOST_NOEXCEPT
-    {
-        BOOST_ASSERT( * this);
-
-        impl_->resume( arg);
-        return * this;
-    }
-};
-
-template<>
-class symmetric_coroutine_call< void >
-{
-private:
-    template< typename X >
-    friend class symmetric_coroutine_yield;
-
-    typedef symmetric_coroutine_impl< void >        impl_type;
-
-    BOOST_MOVABLE_BUT_NOT_COPYABLE( symmetric_coroutine_call)
-
-    struct dummy {};
-
-    impl_type       *   impl_;
-
-public:
-    typedef void                                     value_type;
-    typedef symmetric_coroutine_yield< void >        yield_type;
-
-    symmetric_coroutine_call() BOOST_NOEXCEPT :
-        impl_( 0)
-    {}
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-# ifdef BOOST_MSVC
-    typedef void ( * coroutine_fn)( yield_type &);
-
-    explicit symmetric_coroutine_call( coroutine_fn fn,
-                                       attributes const& attrs = attributes(),
-                                       stack_allocator stack_alloc = stack_allocator() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< void, coroutine_fn, stack_allocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-
-    template< typename StackAllocator >
-    explicit symmetric_coroutine_call( coroutine_fn fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< void, coroutine_fn, StackAllocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< coroutine_fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-# endif
-    template< typename Fn >
-    explicit symmetric_coroutine_call( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs = attributes(),
-                                       stack_allocator stack_alloc = stack_allocator() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< void, Fn, stack_allocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit symmetric_coroutine_call( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< void, Fn, StackAllocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t(
-                    autoboost::forward< Fn >( fn), attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-#else
-    template< typename Fn >
-    explicit symmetric_coroutine_call( Fn fn,
-                                       attributes const& attrs = attributes(),
-                                       stack_allocator stack_alloc = stack_allocator() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< void, Fn, stack_allocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t( fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit symmetric_coroutine_call( Fn fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< void, Fn, StackAllocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t( fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-
-    template< typename Fn >
-    explicit symmetric_coroutine_call( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs = attributes(),
-                                       stack_allocator stack_alloc = stack_allocator() ) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< void, Fn, stack_allocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t( fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-
-    template< typename Fn, typename StackAllocator >
-    explicit symmetric_coroutine_call( BOOST_RV_REF( Fn) fn,
-                                       attributes const& attrs,
-                                       StackAllocator stack_alloc) :
-        impl_( 0)
-    {
-        // create a stack-context
-        stack_context stack_ctx;
-        // allocate the coroutine-stack
-        stack_alloc.allocate( stack_ctx, attrs.size);
-        BOOST_ASSERT( 0 < stack_ctx.sp);
-        // typedef of internal coroutine-type
-        typedef symmetric_coroutine_object< void, Fn, StackAllocator > object_t;
-        // reserve space on top of coroutine-stack for internal coroutine-type
-        stack_context internal_stack_ctx;
-        internal_stack_ctx.sp = static_cast< char * >( stack_ctx.sp) - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.sp);
-        internal_stack_ctx.size = stack_ctx.size - sizeof( object_t);
-        BOOST_ASSERT( 0 < internal_stack_ctx.size);
-        // placement new for internal coroutine
-        impl_ = new ( internal_stack_ctx.sp) object_t( fn, attrs, stack_ctx, internal_stack_ctx, stack_alloc); 
-        BOOST_ASSERT( impl_);
-    }
-#endif
-
-    ~symmetric_coroutine_call()
-    {
-        if ( 0 != impl_)
-        {
-            impl_->destroy();
-            impl_ = 0;
-        }
-    }
-
-    inline symmetric_coroutine_call( BOOST_RV_REF( symmetric_coroutine_call) other) BOOST_NOEXCEPT :
-        impl_( 0)
-    { swap( other); }
-
-    inline symmetric_coroutine_call & operator=( BOOST_RV_REF( symmetric_coroutine_call) other) BOOST_NOEXCEPT
-    {
-        symmetric_coroutine_call tmp( autoboost::move( other) );
-        swap( tmp);
-        return * this;
-    }
-
-    BOOST_EXPLICIT_OPERATOR_BOOL();
-
-    inline bool operator!() const BOOST_NOEXCEPT
-    { return 0 == impl_ || impl_->is_complete() || impl_->is_running(); }
-
-    inline void swap( symmetric_coroutine_call & other) BOOST_NOEXCEPT
-    { std::swap( impl_, other.impl_); }
-
-    inline symmetric_coroutine_call & operator()() BOOST_NOEXCEPT
-    {
-        BOOST_ASSERT( * this);
-
-        impl_->resume();
-        return * this;
-    }
-};
-
-template< typename Arg >
-void swap( symmetric_coroutine_call< Arg > & l,
-           symmetric_coroutine_call< Arg > & r)
-{ l.swap( r); }
-
-}}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_CALL_H
diff --git a/contrib/autoboost/boost/coroutine/detail/symmetric_coroutine_impl.hpp b/contrib/autoboost/boost/coroutine/detail/symmetric_coroutine_impl.hpp
deleted file mode 100644
index e869fb63e..000000000
--- a/contrib/autoboost/boost/coroutine/detail/symmetric_coroutine_impl.hpp
+++ /dev/null
@@ -1,472 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_IMPL_H
-#define BOOST_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_IMPL_H
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/utility.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/detail/coroutine_context.hpp>
-#include <boost/coroutine/detail/flags.hpp>
-#include <boost/coroutine/detail/parameters.hpp>
-#include <boost/coroutine/detail/trampoline.hpp>
-#include <boost/coroutine/exceptions.hpp>
-#include <boost/coroutine/stack_context.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-namespace detail {
-
-template< typename R >
-class symmetric_coroutine_impl : private noncopyable
-{
-public:
-    typedef parameters< R >                           param_type;
-
-    symmetric_coroutine_impl( stack_context const& stack_ctx,
-                              bool unwind, bool preserve_fpu) BOOST_NOEXCEPT :
-        flags_( 0),
-        caller_(),
-        callee_( trampoline< symmetric_coroutine_impl< R > >, stack_ctx)
-    {
-        if ( unwind) flags_ |= flag_force_unwind;
-        if ( preserve_fpu) flags_ |= flag_preserve_fpu;
-    }
-
-    virtual ~symmetric_coroutine_impl() {}
-
-    bool force_unwind() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_force_unwind); }
-
-    bool unwind_requested() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_unwind_stack); }
-
-    bool preserve_fpu() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_preserve_fpu); }
-
-    bool is_started() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_started); }
-
-    bool is_running() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_running); }
-
-    bool is_complete() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_complete); }
-
-    void unwind_stack() BOOST_NOEXCEPT
-    {
-        if ( is_started() && ! is_complete() && force_unwind() )
-        {
-            flags_ |= flag_unwind_stack;
-            flags_ |= flag_running;
-            param_type to( unwind_t::force_unwind);
-            caller_.jump(
-                callee_,
-                reinterpret_cast< intptr_t >( & to),
-                preserve_fpu() );
-            flags_ &= ~flag_running;
-            flags_ &= ~flag_unwind_stack;
-
-            BOOST_ASSERT( is_complete() );
-        }
-    }
-
-    void resume( R r) BOOST_NOEXCEPT
-    {
-        param_type to( const_cast< R * >( & r), this);
-        resume_( & to);
-    }
-
-    R * yield()
-    {
-        BOOST_ASSERT( is_running() );
-        BOOST_ASSERT( ! is_complete() );
-
-        flags_ &= ~flag_running;
-        param_type to;
-        param_type * from(
-            reinterpret_cast< param_type * >(
-                callee_.jump(
-                    caller_,
-                    reinterpret_cast< intptr_t >( & to),
-                    preserve_fpu() ) ) );
-        flags_ |= flag_running;
-        if ( from->do_unwind) throw forced_unwind();
-        BOOST_ASSERT( from->data);
-        return from->data;
-    }
-
-    template< typename X >
-    R * yield_to( symmetric_coroutine_impl< X > * other, X x)
-    {
-        typename symmetric_coroutine_impl< X >::param_type to( & x, other);
-        return yield_to_( other, & to);
-    }
-
-    template< typename X >
-    R * yield_to( symmetric_coroutine_impl< X & > * other, X & x)
-    {
-        typename symmetric_coroutine_impl< X & >::param_type to( & x, other);
-        return yield_to_( other, & to);
-    }
-
-    template< typename X >
-    R * yield_to( symmetric_coroutine_impl< X > * other)
-    {
-        typename symmetric_coroutine_impl< X >::param_type to( other);
-        return yield_to_( other, & to);
-    }
-
-    virtual void run( R *) BOOST_NOEXCEPT = 0;
-
-    virtual void destroy() = 0;
-
-protected:
-    template< typename X >
-    friend class symmetric_coroutine_impl;
-
-    int                 flags_;
-    coroutine_context   caller_;
-    coroutine_context   callee_;
-
-    void resume_( param_type * to) BOOST_NOEXCEPT
-    {
-        BOOST_ASSERT( ! is_running() );
-        BOOST_ASSERT( ! is_complete() );
-
-        flags_ |= flag_running;
-        caller_.jump(
-            callee_,
-            reinterpret_cast< intptr_t >( to),
-            preserve_fpu() );
-        flags_ &= ~flag_running;
-    }
-
-    template< typename Other >
-    R * yield_to_( Other * other, typename Other::param_type * to)
-    {
-        BOOST_ASSERT( is_running() );
-        BOOST_ASSERT( ! is_complete() );
-        BOOST_ASSERT( ! other->is_running() );
-        BOOST_ASSERT( ! other->is_complete() );
-
-        other->caller_ = caller_;
-        flags_ &= ~flag_running;
-        param_type * from(
-            reinterpret_cast< param_type * >(
-                callee_.jump(
-                    other->callee_,
-                    reinterpret_cast< intptr_t >( to),
-                    preserve_fpu() ) ) );
-        flags_ |= flag_running;
-        if ( from->do_unwind) throw forced_unwind();
-        BOOST_ASSERT( from->data);
-        return from->data;
-    }
-};
-
-template< typename R >
-class symmetric_coroutine_impl< R & > : private noncopyable
-{
-public:
-    typedef parameters< R & >                         param_type;
-
-    symmetric_coroutine_impl( stack_context const& stack_ctx,
-                              bool unwind, bool preserve_fpu) BOOST_NOEXCEPT :
-        flags_( 0),
-        caller_(),
-        callee_( trampoline< symmetric_coroutine_impl< R > >, stack_ctx)
-    {
-        if ( unwind) flags_ |= flag_force_unwind;
-        if ( preserve_fpu) flags_ |= flag_preserve_fpu;
-    }
-
-    virtual ~symmetric_coroutine_impl() {}
-
-    bool force_unwind() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_force_unwind); }
-
-    bool unwind_requested() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_unwind_stack); }
-
-    bool preserve_fpu() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_preserve_fpu); }
-
-    bool is_started() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_started); }
-
-    bool is_running() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_running); }
-
-    bool is_complete() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_complete); }
-
-    void unwind_stack() BOOST_NOEXCEPT
-    {
-        if ( is_started() && ! is_complete() && force_unwind() )
-        {
-            flags_ |= flag_unwind_stack;
-            flags_ |= flag_running;
-            param_type to( unwind_t::force_unwind);
-            caller_.jump(
-                callee_,
-                reinterpret_cast< intptr_t >( & to),
-                preserve_fpu() );
-            flags_ &= ~flag_running;
-            flags_ &= ~flag_unwind_stack;
-
-            BOOST_ASSERT( is_complete() );
-        }
-    }
-
-    void resume( R & arg) BOOST_NOEXCEPT
-    {
-        param_type to( & arg, this);
-        resume_( & to);
-    }
-
-    R * yield()
-    {
-        BOOST_ASSERT( is_running() );
-        BOOST_ASSERT( ! is_complete() );
-
-        flags_ &= ~flag_running;
-        param_type to;
-        param_type * from(
-            reinterpret_cast< param_type * >(
-                callee_.jump(
-                    caller_,
-                    reinterpret_cast< intptr_t >( & to),
-                    preserve_fpu() ) ) );
-        flags_ |= flag_running;
-        if ( from->do_unwind) throw forced_unwind();
-        BOOST_ASSERT( from->data);
-        return from->data;
-    }
-
-    template< typename X >
-    R * yield_to( symmetric_coroutine_impl< X > * other, X x)
-    {
-        typename symmetric_coroutine_impl< X >::param_type to( & x, other);
-        return yield_to_( other, & to);
-    }
-
-    template< typename X >
-    R * yield_to( symmetric_coroutine_impl< X & > * other, X & x)
-    {
-        typename symmetric_coroutine_impl< X & >::param_type to( & x, other);
-        return yield_to_( other, & to);
-    }
-
-    template< typename X >
-    R * yield_to( symmetric_coroutine_impl< X > * other)
-    {
-        typename symmetric_coroutine_impl< X >::param_type to( other);
-        return yield_to_( other, & to);
-    }
-
-    virtual void run( R *) BOOST_NOEXCEPT = 0;
-
-    virtual void destroy() = 0;
-
-protected:
-    template< typename X >
-    friend class symmetric_coroutine_impl;
-
-    int                 flags_;
-    coroutine_context   caller_;
-    coroutine_context   callee_;
-
-    void resume_( param_type * to) BOOST_NOEXCEPT
-    {
-        BOOST_ASSERT( ! is_running() );
-        BOOST_ASSERT( ! is_complete() );
-
-        flags_ |= flag_running;
-        caller_.jump(
-            callee_,
-            reinterpret_cast< intptr_t >( to),
-            preserve_fpu() );
-        flags_ &= ~flag_running;
-    }
-
-    template< typename Other >
-    R * yield_to_( Other * other, typename Other::param_type * to)
-    {
-        BOOST_ASSERT( is_running() );
-        BOOST_ASSERT( ! is_complete() );
-        BOOST_ASSERT( ! other->is_running() );
-        BOOST_ASSERT( ! other->is_complete() );
-
-        other->caller_ = caller_;
-        flags_ &= ~flag_running;
-        param_type * from(
-            reinterpret_cast< param_type * >(
-                callee_.jump(
-                    other->callee_,
-                    reinterpret_cast< intptr_t >( to),
-                    preserve_fpu() ) ) );
-        flags_ |= flag_running;
-        if ( from->do_unwind) throw forced_unwind();
-        BOOST_ASSERT( from->data);
-        return from->data;
-    }
-};
-
-template<>
-class symmetric_coroutine_impl< void > : private noncopyable
-{
-public:
-    typedef parameters< void >                          param_type;
-
-    symmetric_coroutine_impl( stack_context const& stack_ctx,
-                              bool unwind, bool preserve_fpu) BOOST_NOEXCEPT :
-        flags_( 0),
-        caller_(),
-        callee_( trampoline_void< symmetric_coroutine_impl< void > >, stack_ctx)
-    {
-        if ( unwind) flags_ |= flag_force_unwind;
-        if ( preserve_fpu) flags_ |= flag_preserve_fpu;
-    }
-
-    virtual ~symmetric_coroutine_impl() {}
-
-    inline bool force_unwind() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_force_unwind); }
-
-    inline bool unwind_requested() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_unwind_stack); }
-
-    inline bool preserve_fpu() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_preserve_fpu); }
-
-    inline bool is_started() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_started); }
-
-    inline bool is_running() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_running); }
-
-    inline bool is_complete() const BOOST_NOEXCEPT
-    { return 0 != ( flags_ & flag_complete); }
-
-    inline void unwind_stack() BOOST_NOEXCEPT
-    {
-        if ( is_started() && ! is_complete() && force_unwind() )
-        {
-            flags_ |= flag_unwind_stack;
-            flags_ |= flag_running;
-            param_type to( unwind_t::force_unwind);
-            caller_.jump(
-                callee_,
-                reinterpret_cast< intptr_t >( & to),
-                preserve_fpu() );
-            flags_ &= ~flag_running;
-            flags_ &= ~flag_unwind_stack;
-
-            BOOST_ASSERT( is_complete() );
-        }
-    }
-
-    inline void resume() BOOST_NOEXCEPT
-    {
-        BOOST_ASSERT( ! is_running() );
-        BOOST_ASSERT( ! is_complete() );
-
-        param_type to( this);
-        flags_ |= flag_running;
-        caller_.jump(
-            callee_,
-            reinterpret_cast< intptr_t >( & to),
-            preserve_fpu() );
-        flags_ &= ~flag_running;
-    }
-
-    inline void yield() BOOST_NOEXCEPT
-    {
-        BOOST_ASSERT( is_running() );
-        BOOST_ASSERT( ! is_complete() );
-
-        flags_ &= ~flag_running;
-        param_type to;
-        param_type * from(
-            reinterpret_cast< param_type * >(
-                callee_.jump(
-                     caller_,
-                    reinterpret_cast< intptr_t >( & to),
-                    preserve_fpu() ) ) );
-        flags_ |= flag_running;
-        if ( from->do_unwind) throw forced_unwind();
-    }
-
-    template< typename X >
-    void yield_to( symmetric_coroutine_impl< X > * other, X x)
-    {
-        typename symmetric_coroutine_impl< X >::param_type to( & x, other);
-        yield_to_( other, & to);
-    }
-
-    template< typename X >
-    void yield_to( symmetric_coroutine_impl< X & > * other, X & x)
-    {
-        typename symmetric_coroutine_impl< X & >::param_type to( & x, other);
-        yield_to_( other, & to);
-    }
-
-    template< typename X >
-    void yield_to( symmetric_coroutine_impl< X > * other)
-    {
-        typename symmetric_coroutine_impl< X >::param_type to( other);
-        yield_to_( other, & to);
-    }
-
-    virtual void run() BOOST_NOEXCEPT = 0;
-
-    virtual void destroy() = 0;
-
-protected:
-    template< typename X >
-    friend class symmetric_coroutine_impl;
-
-    int                 flags_;
-    coroutine_context   caller_;
-    coroutine_context   callee_;
-
-    template< typename Other >
-    void yield_to_( Other * other, typename Other::param_type * to)
-    {
-        BOOST_ASSERT( is_running() );
-        BOOST_ASSERT( ! is_complete() );
-        BOOST_ASSERT( ! other->is_running() );
-        BOOST_ASSERT( ! other->is_complete() );
-
-        other->caller_ = caller_;
-        flags_ &= ~flag_running;
-        param_type * from(
-            reinterpret_cast< param_type * >(
-                callee_.jump(
-                    other->callee_,
-                    reinterpret_cast< intptr_t >( to),
-                    preserve_fpu() ) ) );
-        flags_ |= flag_running;
-        if ( from->do_unwind) throw forced_unwind();
-    }
-};
-
-}}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_IMPL_H
diff --git a/contrib/autoboost/boost/coroutine/detail/symmetric_coroutine_object.hpp b/contrib/autoboost/boost/coroutine/detail/symmetric_coroutine_object.hpp
deleted file mode 100644
index afa3e62ba..000000000
--- a/contrib/autoboost/boost/coroutine/detail/symmetric_coroutine_object.hpp
+++ /dev/null
@@ -1,281 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_OBJECT_H
-#define BOOST_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_OBJECT_H
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/move/move.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/detail/flags.hpp>
-#include <boost/coroutine/detail/symmetric_coroutine_impl.hpp>
-#include <boost/coroutine/detail/symmetric_coroutine_yield.hpp>
-#include <boost/coroutine/exceptions.hpp>
-#include <boost/coroutine/stack_context.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-
-struct stack_context;
-
-namespace detail {
-
-template< typename R, typename Fn, typename StackAllocator >
-class symmetric_coroutine_object : public symmetric_coroutine_impl< R >
-{
-private:
-    typedef symmetric_coroutine_impl< R >                       impl_t;
-    typedef symmetric_coroutine_object< R, Fn, StackAllocator > obj_t;
-
-    Fn                  fn_;
-    stack_context       stack_ctx_;
-    StackAllocator      stack_alloc_;
-
-    static void deallocate_( obj_t * obj)
-    {
-        stack_context stack_ctx( obj->stack_ctx_);
-        StackAllocator stack_alloc( obj->stack_alloc_);
-        obj->unwind_stack();
-        obj->~obj_t();
-        stack_alloc.deallocate( stack_ctx);
-    }
-
-public:
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-    symmetric_coroutine_object( Fn fn, attributes const& attrs,
-                                stack_context const& stack_ctx,
-                                stack_context const& internal_stack_ctx,
-                                StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        impl_t( internal_stack_ctx,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-        fn_( fn),
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-#endif
-
-    symmetric_coroutine_object( BOOST_RV_REF( Fn) fn, attributes const& attrs,
-                                stack_context const& stack_ctx,
-                                stack_context const& internal_stack_ctx,
-                                StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        impl_t( internal_stack_ctx,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-        fn_( fn),
-#else
-        fn_( autoboost::forward< Fn >( fn) ),
-#endif
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-
-    void run( R * r) BOOST_NOEXCEPT
-    {
-        BOOST_ASSERT( ! impl_t::unwind_requested() );
-
-        impl_t::flags_ |= flag_started;
-        impl_t::flags_ |= flag_running;
-        try
-        {
-            symmetric_coroutine_yield< R > yc( this, r);
-            fn_( yc);
-        }
-        catch ( forced_unwind const&)
-        {}
-        catch (...)
-        { std::terminate(); }
-
-        impl_t::flags_ |= flag_complete;
-        impl_t::flags_ &= ~flag_running;
-        typename impl_t::param_type to;
-        impl_t::callee_.jump(
-            impl_t::caller_, 
-            reinterpret_cast< intptr_t >( & to),
-            impl_t::preserve_fpu() );
-        BOOST_ASSERT_MSG( false, "coroutine is complete");
-    }
-
-    void destroy()
-    { deallocate_( this); }
-};
-
-template< typename R, typename Fn, typename StackAllocator >
-class symmetric_coroutine_object< R &, Fn, StackAllocator > : public symmetric_coroutine_impl< R & >
-{
-private:
-    typedef symmetric_coroutine_impl< R & >                         impl_t;
-    typedef symmetric_coroutine_object< R &, Fn, StackAllocator >   obj_t;
-
-    Fn                  fn_;
-    stack_context       stack_ctx_;
-    StackAllocator      stack_alloc_;
-
-    static void deallocate_( obj_t * obj)
-    {
-        stack_context stack_ctx( obj->stack_ctx_);
-        StackAllocator stack_alloc( obj->stack_alloc_);
-        obj->unwind_stack();
-        obj->~obj_t();
-        stack_alloc.deallocate( stack_ctx);
-    }
-
-public:
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-    symmetric_coroutine_object( Fn fn, attributes const& attrs,
-                                stack_context const& stack_ctx,
-                                stack_context const& internal_stack_ctx,
-                                StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        impl_t( internal_stack_ctx,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-        fn_( fn),
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-#endif
-
-    symmetric_coroutine_object( BOOST_RV_REF( Fn) fn, attributes const& attrs,
-                                stack_context const& stack_ctx,
-                                stack_context const& internal_stack_ctx,
-                                StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        impl_t( internal_stack_ctx,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-        fn_( fn),
-#else
-        fn_( autoboost::forward< Fn >( fn) ),
-#endif
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-
-    void run( R * r) BOOST_NOEXCEPT
-    {
-        BOOST_ASSERT( ! impl_t::unwind_requested() );
-
-        impl_t::flags_ |= flag_started;
-        impl_t::flags_ |= flag_running;
-        try
-        {
-            symmetric_coroutine_yield< R & > yc( this, r);
-            fn_( yc);
-        }
-        catch ( forced_unwind const&)
-        {}
-        catch (...)
-        { std::terminate(); }
-
-        impl_t::flags_ |= flag_complete;
-        impl_t::flags_ &= ~flag_running;
-        typename impl_t::param_type to;
-        impl_t::callee_.jump(
-            impl_t::caller_, 
-            reinterpret_cast< intptr_t >( & to),
-            impl_t::preserve_fpu() );
-        BOOST_ASSERT_MSG( false, "coroutine is complete");
-    }
-
-    void destroy()
-    { deallocate_( this); }
-};
-
-template< typename Fn, typename StackAllocator >
-class symmetric_coroutine_object< void, Fn, StackAllocator > : public symmetric_coroutine_impl< void >
-{
-private:
-    typedef symmetric_coroutine_impl< void >                        impl_t;
-    typedef symmetric_coroutine_object< void, Fn, StackAllocator >  obj_t;
-
-    Fn                  fn_;
-    stack_context       stack_ctx_;
-    StackAllocator      stack_alloc_;
-
-    static void deallocate_( obj_t * obj)
-    {
-        stack_context stack_ctx( obj->stack_ctx_);
-        StackAllocator stack_alloc( obj->stack_alloc_);
-        obj->unwind_stack();
-        obj->~obj_t();
-        stack_alloc.deallocate( stack_ctx);
-    }
-
-public:
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-    symmetric_coroutine_object( Fn fn, attributes const& attrs,
-                                stack_context const& stack_ctx,
-                                stack_context const& internal_stack_ctx,
-                                StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        impl_t( internal_stack_ctx,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-        fn_( fn),
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-#endif
-
-    symmetric_coroutine_object( BOOST_RV_REF( Fn) fn, attributes const& attrs,
-                                stack_context const& stack_ctx,
-                                stack_context const& internal_stack_ctx,
-                                StackAllocator const& stack_alloc) BOOST_NOEXCEPT :
-        impl_t( internal_stack_ctx,
-                stack_unwind == attrs.do_unwind,
-                fpu_preserved == attrs.preserve_fpu),
-#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
-        fn_( fn),
-#else
-        fn_( autoboost::forward< Fn >( fn) ),
-#endif
-        stack_ctx_( stack_ctx),
-        stack_alloc_( stack_alloc)
-    {}
-
-    void run() BOOST_NOEXCEPT
-    {
-        BOOST_ASSERT( ! impl_t::unwind_requested() );
-
-        impl_t::flags_ |= flag_started;
-        impl_t::flags_ |= flag_running;
-        try
-        {
-            symmetric_coroutine_yield< void > yc( this);
-            fn_( yc);
-        }
-        catch ( forced_unwind const&)
-        {}
-        catch (...)
-        { std::terminate(); }
-
-        impl_t::flags_ |= flag_complete;
-        impl_t::flags_ &= ~flag_running;
-        typename impl_t::param_type to;
-        impl_t::callee_.jump(
-            impl_t::caller_, 
-            reinterpret_cast< intptr_t >( & to),
-            impl_t::preserve_fpu() );
-        BOOST_ASSERT_MSG( false, "coroutine is complete");
-    }
-
-    void destroy()
-    { deallocate_( this); }
-};
-
-}}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_OBJECT_H
diff --git a/contrib/autoboost/boost/coroutine/detail/symmetric_coroutine_yield.hpp b/contrib/autoboost/boost/coroutine/detail/symmetric_coroutine_yield.hpp
deleted file mode 100644
index 6a573babb..000000000
--- a/contrib/autoboost/boost/coroutine/detail/symmetric_coroutine_yield.hpp
+++ /dev/null
@@ -1,307 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_YIELD_H
-#define BOOST_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_YIELD_H
-
-#include <algorithm>
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/move/move.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/utility/explicit_operator_bool.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/exceptions.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-namespace detail {
-
-template< typename R >
-class symmetric_coroutine_yield
-{
-private:
-    template< typename X, typename Y, typename Z >
-    friend class symmetric_coroutine_object;
-
-    typedef symmetric_coroutine_impl< R >       impl_type;
-
-    struct dummy {};
-
-    BOOST_MOVABLE_BUT_NOT_COPYABLE( symmetric_coroutine_yield)
-
-    impl_type   *   impl_;
-    R           *   result_;
-
-    symmetric_coroutine_yield( impl_type * impl, R * result) BOOST_NOEXCEPT :
-        impl_( impl),
-        result_( result)
-    {
-        BOOST_ASSERT( 0 != impl_);
-        BOOST_ASSERT( 0 != result_);
-    }
-
-public:
-    symmetric_coroutine_yield() BOOST_NOEXCEPT :
-        impl_( 0),
-        result_( 0)
-    {}
-
-    symmetric_coroutine_yield( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT :
-        impl_( 0),
-        result_( 0)
-    { swap( other); }
-
-    symmetric_coroutine_yield & operator=( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT
-    {
-        symmetric_coroutine_yield tmp( autoboost::move( other) );
-        swap( tmp);
-        return * this;
-    }
-
-    BOOST_EXPLICIT_OPERATOR_BOOL();
-
-    bool operator!() const BOOST_NOEXCEPT
-    { return 0 == impl_; }
-
-    void swap( symmetric_coroutine_yield & other) BOOST_NOEXCEPT
-    {
-        std::swap( impl_, other.impl_);
-        std::swap( result_, other.result_);
-    }
-
-    symmetric_coroutine_yield & operator()()
-    {
-        result_ = impl_->yield();
-        return * this;
-    }
-
-    template< typename Coro >
-    symmetric_coroutine_yield & operator()( Coro & other, typename Coro::value_type x,
-                                            typename disable_if<
-                                                is_same< typename Coro::value_type, void >,
-                                                dummy*
-                                            >::type = 0)
-    {
-        BOOST_ASSERT( other);
-
-        result_ = impl_->yield_to( other.impl_, x);
-        return * this;
-    }
-
-    template< typename Coro >
-    symmetric_coroutine_yield & operator()( Coro & other,
-                                            typename enable_if<
-                                                is_same< typename Coro::value_type, void >,
-                                                dummy*
-                                            >::type = 0)
-    {
-        BOOST_ASSERT( other);
-
-        result_ = impl_->yield_to( other.impl_);
-        return * this;
-    }
-
-    R get() const
-    {
-        if ( 0 == result_)
-            autoboost::throw_exception(
-                invalid_result() );
-
-        return * result_; 
-    }
-};
-
-template< typename R >
-class symmetric_coroutine_yield< R & >
-{
-private:
-    template< typename X, typename Y, typename Z >
-    friend class symmetric_coroutine_object;
-
-    typedef symmetric_coroutine_impl< R & >     impl_type;
-
-    struct dummy {};
-
-    BOOST_MOVABLE_BUT_NOT_COPYABLE( symmetric_coroutine_yield)
-
-    impl_type   *   impl_;
-    R           *   result_;
-
-    symmetric_coroutine_yield( impl_type * impl, R * result) BOOST_NOEXCEPT :
-        impl_( impl),
-        result_( result)
-    {
-        BOOST_ASSERT( 0 != impl_);
-        BOOST_ASSERT( 0 != result_);
-    }
-
-public:
-    symmetric_coroutine_yield() BOOST_NOEXCEPT :
-        impl_( 0),
-        result_( 0)
-    {}
-
-    symmetric_coroutine_yield( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT :
-        impl_( 0),
-        result_( 0)
-    { swap( other); }
-
-    symmetric_coroutine_yield & operator=( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT
-    {
-        symmetric_coroutine_yield tmp( autoboost::move( other) );
-        swap( tmp);
-        return * this;
-    }
-
-    BOOST_EXPLICIT_OPERATOR_BOOL();
-
-    bool operator!() const BOOST_NOEXCEPT
-    { return 0 == impl_; }
-
-    void swap( symmetric_coroutine_yield & other) BOOST_NOEXCEPT
-    {
-        std::swap( impl_, other.impl_);
-        std::swap( result_, other.result_);
-    }
-
-    symmetric_coroutine_yield & operator()()
-    {
-        result_ = impl_->yield();
-        return * this;
-    }
-
-    template< typename Coro >
-    symmetric_coroutine_yield & operator()( Coro & other, typename Coro::value_type & x,
-                                            typename disable_if<
-                                                is_same< typename Coro::value_type, void >,
-                                                dummy*
-                                            >::type = 0)
-    {
-        BOOST_ASSERT( other);
-
-        result_ = impl_->yield_to( other.impl_, x);
-        return * this;
-    }
-
-    template< typename Coro >
-    symmetric_coroutine_yield & operator()( Coro & other,
-                                            typename enable_if<
-                                                is_same< typename Coro::value_type, void >,
-                                                dummy*
-                                            >::type = 0)
-    {
-        BOOST_ASSERT( other);
-
-        result_ = impl_->yield_to( other.impl_);
-        return * this;
-    }
-
-    R & get() const
-    {
-        if ( 0 == result_)
-            autoboost::throw_exception(
-                invalid_result() );
-
-        return * result_; 
-    }
-};
-
-template<>
-class symmetric_coroutine_yield< void >
-{
-private:
-    template< typename X, typename Y, typename Z >
-    friend class symmetric_coroutine_object;
-
-    typedef symmetric_coroutine_impl< void >    impl_type;
-
-    struct dummy {};
-
-    BOOST_MOVABLE_BUT_NOT_COPYABLE( symmetric_coroutine_yield)
-
-    impl_type   *   impl_;
-
-    symmetric_coroutine_yield( impl_type * impl) BOOST_NOEXCEPT :
-        impl_( impl)
-    { BOOST_ASSERT( 0 != impl_); }
-
-public:
-    symmetric_coroutine_yield() BOOST_NOEXCEPT :
-        impl_( 0)
-    {}
-
-    symmetric_coroutine_yield( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT :
-        impl_( 0)
-    { swap( other); }
-
-    symmetric_coroutine_yield & operator=( BOOST_RV_REF( symmetric_coroutine_yield) other) BOOST_NOEXCEPT
-    {
-        symmetric_coroutine_yield tmp( autoboost::move( other) );
-        swap( tmp);
-        return * this;
-    }
-
-    BOOST_EXPLICIT_OPERATOR_BOOL();
-
-    inline bool operator!() const BOOST_NOEXCEPT
-    { return 0 == impl_; }
-
-    inline void swap( symmetric_coroutine_yield & other) BOOST_NOEXCEPT
-    { std::swap( impl_, other.impl_); }
-
-    inline symmetric_coroutine_yield & operator()()
-    {
-        impl_->yield();
-        return * this;
-    }
-
-    template< typename Coro >
-    symmetric_coroutine_yield & operator()( Coro & other, typename Coro::value_type & x,
-                                            typename disable_if<
-                                                is_same< typename Coro::value_type, void >,
-                                                dummy*
-                                            >::type = 0)
-    {
-        BOOST_ASSERT( other);
-
-        impl_->yield_to( other.impl_, x);
-        return * this;
-    }
-
-    template< typename Coro >
-    symmetric_coroutine_yield & operator()( Coro & other,
-                                            typename enable_if<
-                                                is_same< typename Coro::value_type, void >,
-                                                dummy*
-                                            >::type = 0)
-    {
-        BOOST_ASSERT( other);
-
-        impl_->yield_to( other.impl_);
-        return * this;
-    }
-};
-
-template< typename R >
-void swap( symmetric_coroutine_yield< R > & l, symmetric_coroutine_yield< R > & r)
-{ l.swap( r); }
-
-}}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_SYMMETRIC_COROUTINE_YIELD_H
diff --git a/contrib/autoboost/boost/coroutine/detail/trampoline.hpp b/contrib/autoboost/boost/coroutine/detail/trampoline.hpp
deleted file mode 100644
index 7e35c6629..000000000
--- a/contrib/autoboost/boost/coroutine/detail/trampoline.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_TRAMPOLINE_H
-#define BOOST_COROUTINES_DETAIL_TRAMPOLINE_H
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-namespace detail {
-
-template< typename Coro >
-void trampoline( intptr_t vp)
-{
-    typedef typename Coro::param_type   param_type;
-
-    BOOST_ASSERT( 0 != vp);
-
-    param_type * param(
-        reinterpret_cast< param_type * >( vp) );
-    BOOST_ASSERT( 0 != param);
-    BOOST_ASSERT( 0 != param->data);
-
-    Coro * coro(
-        reinterpret_cast< Coro * >( param->coro) );
-    BOOST_ASSERT( 0 != coro);
-
-    coro->run( param->data);
-}
-
-template< typename Coro >
-void trampoline_void( intptr_t vp)
-{
-    typedef typename Coro::param_type   param_type;
-
-    BOOST_ASSERT( 0 != vp);
-
-    param_type * param(
-        reinterpret_cast< param_type * >( vp) );
-    BOOST_ASSERT( 0 != param);
-
-    Coro * coro(
-        reinterpret_cast< Coro * >( param->coro) );
-    BOOST_ASSERT( 0 != coro);
-    
-    coro->run();
-}
-
-}}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_TRAMPOLINE_H
diff --git a/contrib/autoboost/boost/coroutine/detail/trampoline_pull.hpp b/contrib/autoboost/boost/coroutine/detail/trampoline_pull.hpp
deleted file mode 100644
index f0b85e07a..000000000
--- a/contrib/autoboost/boost/coroutine/detail/trampoline_pull.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_TRAMPOLINE_PULL_H
-#define BOOST_COROUTINES_DETAIL_TRAMPOLINE_PULL_H
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-namespace detail {
-
-template< typename Coro >
-void trampoline_pull( intptr_t vp)
-{
-    typedef typename Coro::param_type   param_type;
-
-    BOOST_ASSERT( 0 != vp);
-
-    param_type * param(
-        reinterpret_cast< param_type * >( vp) );
-    BOOST_ASSERT( 0 != param);
-
-    Coro * coro(
-        reinterpret_cast< Coro * >( param->coro) );
-    BOOST_ASSERT( 0 != coro);
-
-    coro->run();
-}
-
-}}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_TRAMPOLINE_PULL_H
diff --git a/contrib/autoboost/boost/coroutine/detail/trampoline_push.hpp b/contrib/autoboost/boost/coroutine/detail/trampoline_push.hpp
deleted file mode 100644
index ded1cccd7..000000000
--- a/contrib/autoboost/boost/coroutine/detail/trampoline_push.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_DETAIL_TRAMPOLINE_PUSH_H
-#define BOOST_COROUTINES_DETAIL_TRAMPOLINE_PUSH_H
-
-#include <cstddef>
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/exception_ptr.hpp>
-#include <boost/move/move.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/detail/flags.hpp>
-#include <boost/coroutine/detail/parameters.hpp>
-#include <boost/coroutine/detail/setup.hpp>
-#include <boost/coroutine/detail/setup.hpp>
-#include <boost/coroutine/exceptions.hpp>
-#include <boost/coroutine/flags.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-namespace detail {
-
-template< typename Coro >
-void trampoline_push( intptr_t vp)
-{
-    typedef typename Coro::param_type   param_type;
-
-    BOOST_ASSERT( vp);
-
-    param_type * param(
-        reinterpret_cast< param_type * >( vp) );
-    BOOST_ASSERT( 0 != param);
-    BOOST_ASSERT( 0 != param->data);
-
-    Coro * coro(
-        reinterpret_cast< Coro * >( param->coro) );
-    BOOST_ASSERT( 0 != coro);
-
-    coro->run( param->data);
-}
-
-template< typename Coro >
-void trampoline_push_void( intptr_t vp)
-{
-    typedef typename Coro::param_type   param_type;
-
-    BOOST_ASSERT( vp);
-
-    param_type * param(
-        reinterpret_cast< param_type * >( vp) );
-    BOOST_ASSERT( 0 != param);
-
-    Coro * coro(
-        reinterpret_cast< Coro * >( param->coro) );
-    BOOST_ASSERT( 0 != coro);
-
-    coro->run();
-}
-
-}}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_DETAIL_TRAMPOLINE_PUSH_H
diff --git a/contrib/autoboost/boost/coroutine/exceptions.hpp b/contrib/autoboost/boost/coroutine/exceptions.hpp
deleted file mode 100644
index eacabfe79..000000000
--- a/contrib/autoboost/boost/coroutine/exceptions.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_EXCEPTIONS_H
-#define BOOST_COROUTINES_EXCEPTIONS_H
-
-#include <stdexcept>
-#include <string>
-
-#include <boost/config.hpp>
-#include <boost/detail/scoped_enum_emulation.hpp>
-#include <boost/system/error_code.hpp>
-#include <boost/system/system_error.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-namespace detail {
-
-struct forced_unwind {};
-
-}
-
-BOOST_SCOPED_ENUM_DECLARE_BEGIN(coroutine_errc)
-{
-  no_data = 1
-}
-BOOST_SCOPED_ENUM_DECLARE_END(coroutine_errc)
-
-BOOST_COROUTINES_DECL system::error_category const& coroutine_category() BOOST_NOEXCEPT;
-
-}
-
-namespace system {
-
-template<>
-struct is_error_code_enum< coroutines::coroutine_errc > : public true_type
-{};
-
-#ifdef BOOST_NO_CXX11_SCOPED_ENUMS
-template<>
-struct is_error_code_enum< coroutines::coroutine_errc::enum_type > : public true_type
-{};
-#endif
-
-inline
-error_code make_error_code( coroutines::coroutine_errc e) //BOOST_NOEXCEPT
-{
-    return error_code( underlying_cast< int >( e), coroutines::coroutine_category() );
-}
-
-inline
-error_condition make_error_condition( coroutines::coroutine_errc e) //BOOST_NOEXCEPT
-{
-    return error_condition( underlying_cast< int >( e), coroutines::coroutine_category() );
-}
-
-}
-
-namespace coroutines {
-
-class coroutine_error : public std::logic_error
-{
-private:
-    system::error_code  ec_;
-
-public:
-    coroutine_error( system::error_code ec) :
-        logic_error( ec.message() ),
-        ec_( ec)
-    {}
-
-    system::error_code const& code() const BOOST_NOEXCEPT
-    { return ec_; }
-
-    const char* what() const throw()
-    { return code().message().c_str(); }
-};
-
-class invalid_result : public coroutine_error
-{
-public:
-    invalid_result() :
-        coroutine_error(
-            system::make_error_code(
-                coroutine_errc::no_data) )
-    {}
-};
-
-}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_EXCEPTIONS_H
diff --git a/contrib/autoboost/boost/coroutine/flags.hpp b/contrib/autoboost/boost/coroutine/flags.hpp
deleted file mode 100644
index 43a4c15e5..000000000
--- a/contrib/autoboost/boost/coroutine/flags.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_FLAGS_H
-#define BOOST_COROUTINES_FLAGS_H
-
-namespace autoboost {
-namespace coroutines {
-
-enum flag_unwind_t
-{
-    stack_unwind = 0,
-    no_stack_unwind
-};
-
-enum flag_fpu_t
-{
-    fpu_preserved = 0,
-    fpu_not_preserved
-};
-
-}}
-
-#endif // BOOST_COROUTINES_FLAGS_H
diff --git a/contrib/autoboost/boost/coroutine/posix/protected_stack_allocator.hpp b/contrib/autoboost/boost/coroutine/posix/protected_stack_allocator.hpp
deleted file mode 100644
index 4afecd6fb..000000000
--- a/contrib/autoboost/boost/coroutine/posix/protected_stack_allocator.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_PROTECTED_STACK_ALLOCATOR_H
-#define BOOST_COROUTINES_PROTECTED_STACK_ALLOCATOR_H
-
-extern "C" {
-#include <fcntl.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <unistd.h>
-}
-
-#if defined(BOOST_USE_VALGRIND)
-#include <valgrind/valgrind.h>
-#endif
-
-#include <cmath>
-#include <cstddef>
-#include <new>
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/stack_context.hpp>
-#include <boost/coroutine/stack_traits.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-
-template< typename traitsT >
-struct basic_protected_stack_allocator
-{
-    typedef traitsT traits_type;
-
-    void allocate( stack_context & ctx, std::size_t size = traits_type::minimum_size() )
-    {
-        BOOST_ASSERT( traits_type::minimum_size() <= size);
-        BOOST_ASSERT( traits_type::is_unbounded() || ( traits_type::maximum_size() >= size) );
-
-        // page at bottom will be used as guard-page
-        const std::size_t pages(
-            static_cast< std::size_t >( 
-                std::floor(
-                    static_cast< float >( size) / traits_type::page_size() ) ) );
-        BOOST_ASSERT_MSG( 2 <= pages, "at least two pages must fit into stack (one page is guard-page)");
-        const std::size_t size_( pages * traits_type::page_size() );
-        BOOST_ASSERT( 0 < size && 0 < size_);
-        BOOST_ASSERT( size_ <= size);
-
-        // conform to POSIX.4 (POSIX.1b-1993, _POSIX_C_SOURCE=199309L)
-#if defined(MAP_ANON)
-        void * limit = ::mmap( 0, size_, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
-#else
-        void * limit = ::mmap( 0, size_, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
-#endif
-        if ( MAP_FAILED == limit) throw std::bad_alloc();
-
-        // conforming to POSIX.1-2001
-#if defined(BOOST_DISABLE_ASSERTS)
-        ::mprotect( limit, traits_type::page_size(), PROT_NONE);
-#else
-        const int result( ::mprotect( limit, traits_type::page_size(), PROT_NONE) );
-        BOOST_ASSERT( 0 == result);
-#endif
-
-        ctx.size = size_;
-        ctx.sp = static_cast< char * >( limit) + ctx.size;
-#if defined(BOOST_USE_VALGRIND)
-        ctx.valgrind_stack_id = VALGRIND_STACK_REGISTER( ctx.sp, limit);
-#endif
-    }
-
-    void deallocate( stack_context & ctx)
-    {
-        BOOST_ASSERT( ctx.sp);
-        BOOST_ASSERT( traits_type::minimum_size() <= ctx.size);
-        BOOST_ASSERT( traits_type::is_unbounded() || ( traits_type::maximum_size() >= ctx.size) );
-
-#if defined(BOOST_USE_VALGRIND)
-        VALGRIND_STACK_DEREGISTER( ctx.valgrind_stack_id);
-#endif
-        void * limit = static_cast< char * >( ctx.sp) - ctx.size;
-        // conform to POSIX.4 (POSIX.1b-1993, _POSIX_C_SOURCE=199309L)
-        ::munmap( limit, ctx.size);
-    }
-};
-
-typedef basic_protected_stack_allocator< stack_traits > protected_stack_allocator;
-
-}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_PROTECTED_STACK_ALLOCATOR_H
diff --git a/contrib/autoboost/boost/coroutine/posix/segmented_stack_allocator.hpp b/contrib/autoboost/boost/coroutine/posix/segmented_stack_allocator.hpp
deleted file mode 100644
index e9280ff52..000000000
--- a/contrib/autoboost/boost/coroutine/posix/segmented_stack_allocator.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_SEGMENTED_STACK_ALLOCATOR_H
-#define BOOST_COROUTINES_SEGMENTED_STACK_ALLOCATOR_H
-
-#include <cstddef>
-#include <new>
-
-#include <boost/config.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/stack_context.hpp>
-#include <boost/coroutine/stack_traits.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-// forward declaration for splitstack-functions defined in libgcc
-extern "C" {
-void *__splitstack_makecontext( std::size_t,
-                                void * [BOOST_COROUTINES_SEGMENTS],
-                                std::size_t *);
-
-void __splitstack_releasecontext( void * [BOOST_COROUTINES_SEGMENTS]);
-
-void __splitstack_resetcontext( void * [BOOST_COROUTINES_SEGMENTS]);
-
-void __splitstack_block_signals_context( void * [BOOST_COROUTINES_SEGMENTS],
-                                         int * new_value, int * old_value);
-}
-
-namespace autoboost {
-namespace coroutines {
-
-template< typename traitsT >
-struct basic_segmented_stack_allocator
-{
-    typedef traitsT traits_type;
-
-    void allocate( stack_context & ctx, std::size_t size = traits_type::minimum_size() )
-    {
-        void * limit = __splitstack_makecontext( size, ctx.segments_ctx, & ctx.size);
-        if ( ! limit) throw std::bad_alloc();
-
-        // ctx.size is already filled by __splitstack_makecontext
-        ctx.sp = static_cast< char * >( limit) + ctx.size;
-
-        int off = 0;
-        __splitstack_block_signals_context( ctx.segments_ctx, & off, 0);
-    }
-
-    void deallocate( stack_context & ctx)
-    { __splitstack_releasecontext( ctx.segments_ctx); }
-};
-
-typedef basic_segmented_stack_allocator< stack_traits > segmented_stack_allocator;
-
-}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_SEGMENTED_STACK_ALLOCATOR_H
diff --git a/contrib/autoboost/boost/coroutine/protected_stack_allocator.hpp b/contrib/autoboost/boost/coroutine/protected_stack_allocator.hpp
deleted file mode 100644
index 268786fec..000000000
--- a/contrib/autoboost/boost/coroutine/protected_stack_allocator.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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)
-
-#include <boost/config.hpp>
-
-#if defined(BOOST_WINDOWS)
-# include <boost/coroutine/windows/protected_stack_allocator.hpp>
-#else
-# include <boost/coroutine/posix/protected_stack_allocator.hpp>
-#endif
diff --git a/contrib/autoboost/boost/coroutine/segmented_stack_allocator.hpp b/contrib/autoboost/boost/coroutine/segmented_stack_allocator.hpp
deleted file mode 100644
index f9525a1a5..000000000
--- a/contrib/autoboost/boost/coroutine/segmented_stack_allocator.hpp
+++ /dev/null
@@ -1,15 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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)
-
-#include <boost/config.hpp>
-
-#if defined(BOOST_USE_SEGMENTED_STACKS)
-# if defined(BOOST_WINDOWS)
-#  error "segmented stacks are not supported by Windows"
-# else
-#  include <boost/coroutine/posix/segmented_stack_allocator.hpp>
-# endif
-#endif
diff --git a/contrib/autoboost/boost/coroutine/stack_allocator.hpp b/contrib/autoboost/boost/coroutine/stack_allocator.hpp
deleted file mode 100644
index c740e112c..000000000
--- a/contrib/autoboost/boost/coroutine/stack_allocator.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_STACK_ALLOCATOR_H
-#define BOOST_COROUTINES_STACK_ALLOCATOR_H
-
-#include <cstddef>
-
-#include <boost/config.hpp>
-
-#include <boost/context/detail/config.hpp>
-#include <boost/coroutine/segmented_stack_allocator.hpp>
-#include <boost/coroutine/standard_stack_allocator.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-
-#if defined(BOOST_USE_SEGMENTED_STACKS)
-typedef segmented_stack_allocator   stack_allocator;
-#else
-typedef standard_stack_allocator    stack_allocator;
-#endif
-
-}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_STACK_ALLOCATOR_H
diff --git a/contrib/autoboost/boost/coroutine/stack_context.hpp b/contrib/autoboost/boost/coroutine/stack_context.hpp
deleted file mode 100644
index ff93bf276..000000000
--- a/contrib/autoboost/boost/coroutine/stack_context.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_STACK_CONTEXT_H
-#define BOOST_COROUTINES_STACK_CONTEXT_H
-
-#include <cstddef>
-
-#include <boost/config.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-
-#if defined(BOOST_USE_SEGMENTED_STACKS)
-struct stack_context
-{
-    typedef void *  segments_context[BOOST_COROUTINES_SEGMENTS];
-
-    std::size_t             size;
-    void                *   sp;
-    segments_context        segments_ctx;
-#if defined(BOOST_USE_VALGRIND)
-    unsigned                valgrind_stack_id;
-#endif
-
-    stack_context() :
-        size( 0), sp( 0), segments_ctx()
-#if defined(BOOST_USE_VALGRIND)
-        , valgrind_stack_id( 0)
-#endif
-    {}
-};
-#else
-struct stack_context
-{
-    std::size_t             size;
-    void                *   sp;
-#if defined(BOOST_USE_VALGRIND)
-    unsigned                valgrind_stack_id;
-#endif
-
-    stack_context() :
-        size( 0), sp( 0)
-#if defined(BOOST_USE_VALGRIND)
-        , valgrind_stack_id( 0)
-#endif
-    {}
-};
-#endif
-
-}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_STACK_CONTEXT_H
diff --git a/contrib/autoboost/boost/coroutine/stack_traits.hpp b/contrib/autoboost/boost/coroutine/stack_traits.hpp
deleted file mode 100644
index f96cc9687..000000000
--- a/contrib/autoboost/boost/coroutine/stack_traits.hpp
+++ /dev/null
@@ -1,42 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_STACK_TRAITS_H
-#define BOOST_COROUTINES_STACK_TRAITS_H
-
-#include <cstddef>
-
-#include <boost/config.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-
-struct BOOST_COROUTINES_DECL stack_traits
-{
-    static bool is_unbounded() BOOST_NOEXCEPT;
-
-    static std::size_t page_size() BOOST_NOEXCEPT;
-
-    static std::size_t default_size() BOOST_NOEXCEPT;
-
-    static std::size_t minimum_size() BOOST_NOEXCEPT;
-
-    static std::size_t maximum_size() BOOST_NOEXCEPT;
-};
-
-}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_STACK_TRAITS_H
diff --git a/contrib/autoboost/boost/coroutine/standard_stack_allocator.hpp b/contrib/autoboost/boost/coroutine/standard_stack_allocator.hpp
deleted file mode 100644
index 3b387d1cf..000000000
--- a/contrib/autoboost/boost/coroutine/standard_stack_allocator.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_STANDARD_STACK_ALLOCATOR_H
-#define BOOST_COROUTINES_STANDARD_STACK_ALLOCATOR_H
-
-#if defined(BOOST_USE_VALGRIND)
-#include <valgrind/valgrind.h>
-#endif
-
-#include <cstddef>
-#include <cstdlib>
-#include <new>
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/stack_context.hpp>
-#include <boost/coroutine/stack_traits.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-
-template< typename traitsT >
-struct basic_standard_stack_allocator
-{
-    typedef traitsT traits_type;
-
-    void allocate( stack_context & ctx, std::size_t size = traits_type::minimum_size() )
-    {
-        BOOST_ASSERT( traits_type::minimum_size() <= size);
-        BOOST_ASSERT( traits_type::is_unbounded() || ( traits_type::maximum_size() >= size) );
-
-        void * limit = std::malloc( size);
-        if ( ! limit) throw std::bad_alloc();
-
-        ctx.size = size;
-        ctx.sp = static_cast< char * >( limit) + ctx.size;
-#if defined(BOOST_USE_VALGRIND)
-        ctx.valgrind_stack_id = VALGRIND_STACK_REGISTER( ctx.sp, limit);
-#endif
-    }
-
-    void deallocate( stack_context & ctx)
-    {
-        BOOST_ASSERT( ctx.sp);
-        BOOST_ASSERT( traits_type::minimum_size() <= ctx.size);
-        BOOST_ASSERT( traits_type::is_unbounded() || ( traits_type::maximum_size() >= ctx.size) );
-
-#if defined(BOOST_USE_VALGRIND)
-        VALGRIND_STACK_DEREGISTER( ctx.valgrind_stack_id);
-#endif
-
-        void * limit = static_cast< char * >( ctx.sp) - ctx.size;
-        std::free( limit);
-    }
-};
-
-typedef basic_standard_stack_allocator< stack_traits >  standard_stack_allocator;
-
-}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_STANDARD_STACK_ALLOCATOR_H
diff --git a/contrib/autoboost/boost/coroutine/symmetric_coroutine.hpp b/contrib/autoboost/boost/coroutine/symmetric_coroutine.hpp
deleted file mode 100644
index 53d779b8a..000000000
--- a/contrib/autoboost/boost/coroutine/symmetric_coroutine.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_SYMMETRIC_COROUTINE_H
-#define BOOST_COROUTINES_SYMMETRIC_COROUTINE_H
-
-#include <boost/config.hpp>
-
-#include <boost/coroutine/detail/symmetric_coroutine_call.hpp>
-#include <boost/coroutine/detail/symmetric_coroutine_yield.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-
-template< typename T >
-struct symmetric_coroutine
-{
-    typedef detail::symmetric_coroutine_call< T >   call_type;
-    typedef detail::symmetric_coroutine_yield< T >  yield_type;
-};
-
-}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_SYMMETRIC_COROUTINE_H
diff --git a/contrib/autoboost/boost/coroutine/windows/protected_stack_allocator.hpp b/contrib/autoboost/boost/coroutine/windows/protected_stack_allocator.hpp
deleted file mode 100644
index a3f1d17b6..000000000
--- a/contrib/autoboost/boost/coroutine/windows/protected_stack_allocator.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-
-//          Copyright Oliver Kowalke 2009.
-// 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_COROUTINES_PROTECTED_STACK_ALLOCATOR_H
-#define BOOST_COROUTINES_PROTECTED_STACK_ALLOCATOR_H
-
-extern "C" {
-#include <windows.h>
-}
-
-#include <cmath>
-#include <cstddef>
-#include <new>
-
-#include <boost/config.hpp>
-
-#include <boost/coroutine/detail/config.hpp>
-#include <boost/coroutine/stack_traits.hpp>
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_PREFIX
-#endif
-
-namespace autoboost {
-namespace coroutines {
-
-struct stack_context;
-
-template< typename traitsT >
-struct basic_protected_stack_allocator
-{
-    typedef traitsT traits_type;
-
-    void allocate( stack_context & ctx, std::size_t size)
-    {
-        BOOST_ASSERT( traits_type::minimum_size() <= size);
-        BOOST_ASSERT( traits_type::is_unbounded() || ( traits_type::maximum_size() >= size) );
-
-        // page at bottom will be used as guard-page
-        const std::size_t pages(
-            static_cast< std::size_t >( 
-                std::floor(
-                    static_cast< float >( size) / traits_type::page_size() ) ) );
-        BOOST_ASSERT_MSG( 2 <= pages, "at least two pages must fit into stack (one page is guard-page)");
-        const std::size_t size_ = pages * traits_type::page_size();
-        BOOST_ASSERT( 0 < size && 0 < size_);
-
-        void * limit = ::VirtualAlloc( 0, size_, MEM_COMMIT, PAGE_READWRITE);
-        if ( ! limit) throw std::bad_alloc();
-
-        DWORD old_options;
-#if defined(BOOST_DISABLE_ASSERTS)
-        ::VirtualProtect(
-            limit, traits_type::page_size(), PAGE_READWRITE | PAGE_GUARD /*PAGE_NOACCESS*/, & old_options);
-#else
-        const BOOL result = ::VirtualProtect(
-            limit, traits_type::page_size(), PAGE_READWRITE | PAGE_GUARD /*PAGE_NOACCESS*/, & old_options);
-        BOOST_ASSERT( FALSE != result);
-#endif
-
-        ctx.size = size_;
-        ctx.sp = static_cast< char * >( limit) + ctx.size;
-    }
-
-    void deallocate( stack_context & ctx)
-    {
-        BOOST_ASSERT( ctx.sp);
-        BOOST_ASSERT( traits_type::minimum_size() <= ctx.size);
-        BOOST_ASSERT( traits_type::is_unbounded() || ( traits_type::maximum_size() >= ctx.size) );
-
-        void * limit = static_cast< char * >( ctx.sp) - ctx.size;
-        ::VirtualFree( limit, 0, MEM_RELEASE);
-    }
-};
-
-typedef basic_protected_stack_allocator< stack_traits > protected_stack_allocator;
-
-}}
-
-#ifdef BOOST_HAS_ABI_HEADERS
-#  include BOOST_ABI_SUFFIX
-#endif
-
-#endif // BOOST_COROUTINES_PROTECTED_STACK_ALLOCATOR_H
diff --git a/contrib/autoboost/boost/serialization/config.hpp b/contrib/autoboost/boost/serialization/config.hpp
index bf025a0b8..0d596d403 100644
--- a/contrib/autoboost/boost/serialization/config.hpp
+++ b/contrib/autoboost/boost/serialization/config.hpp
@@ -59,27 +59,4 @@
     #define BOOST_SERIALIZATION_DECL(T) T
 #endif
 
-//  enable automatic library variant selection  ------------------------------// 
-
-#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \
-&&  !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE)  \
-&&  !defined(BOOST_SERIALIZATION_SOURCE)
-    //
-    // Set the name of our library, this will get undef'ed by auto_link.hpp
-    // once it's done with it:
-    //
-    #define BOOST_LIB_NAME autoboost_serialization
-    //
-    // If we're importing code from a dll, then tell auto_link.hpp about it:
-    //
-    #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
-    #  define BOOST_DYN_LINK
-    #endif
-    //
-    // And include the header that does the work:
-    //
-    #include <boost/config/auto_link.hpp>
-
-#endif  
-
 #endif // BOOST_SERIALIZATION_CONFIG_HPP
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/assert.hpp b/contrib/autoboost/boost/spirit/home/classic/core/assert.hpp
deleted file mode 100644
index ac57f5813..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/assert.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Joel de Guzman
-    Copyright (c) 2002-2003 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_ASSERT_HPP)
-#define BOOST_SPIRIT_ASSERT_HPP
-
-#include <boost/config.hpp>
-#include <boost/throw_exception.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  BOOST_SPIRIT_ASSERT is used throughout the framework.  It can be
-//  overridden by the user. If BOOST_SPIRIT_ASSERT_EXCEPTION is defined,
-//  then that will be thrown, otherwise, BOOST_SPIRIT_ASSERT simply turns
-//  into a plain BOOST_ASSERT()
-//
-///////////////////////////////////////////////////////////////////////////////
-#if !defined(BOOST_SPIRIT_ASSERT)
-#if defined(NDEBUG)
-    #define BOOST_SPIRIT_ASSERT(x)
-#elif defined (BOOST_SPIRIT_ASSERT_EXCEPTION)
-    #define BOOST_SPIRIT_ASSERT_AUX(f, l, x) BOOST_SPIRIT_ASSERT_AUX2(f, l, x)
-    #define BOOST_SPIRIT_ASSERT_AUX2(f, l, x)                                   \
-    do{ if (!(x)) autoboost::throw_exception(                                       \
-        BOOST_SPIRIT_ASSERT_EXCEPTION(f "(" #l "): " #x)); } while(0)
-    #define BOOST_SPIRIT_ASSERT(x) BOOST_SPIRIT_ASSERT_AUX(__FILE__, __LINE__, x)
-#else
-    #include <boost/assert.hpp>
-    #define BOOST_SPIRIT_ASSERT(x) BOOST_ASSERT(x)
-#endif
-#endif // !defined(BOOST_SPIRIT_ASSERT)
-
-#endif // BOOST_SPIRIT_ASSERT_HPP
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/actions.hpp b/contrib/autoboost/boost/spirit/home/classic/core/composite/actions.hpp
deleted file mode 100644
index 9d091e8bd..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/actions.hpp
+++ /dev/null
@@ -1,136 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-  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_SPIRIT_ACTIONS_HPP
-#define BOOST_SPIRIT_ACTIONS_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/composite/composite.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  action class
-    //
-    //      The action class binds a parser with a user defined semantic
-    //      action. Instances of action are never created manually. Instead,
-    //      action objects are typically created indirectly through
-    //      expression templates of the form:
-    //
-    //          p[f]
-    //
-    //      where p is a parser and f is a function or functor. The semantic
-    //      action may be a function or a functor. When the parser is
-    //      successful, the actor calls the scanner's action_policy policy
-    //      (see scanner.hpp):
-    //
-    //          scan.do_action(actor, attribute, first, last);
-    //
-    //      passing in these information:
-    //
-    //          actor:        The action's function or functor
-    //          attribute:    The match (returned by the parser) object's
-    //                        attribute (see match.hpp)
-    //          first:        Iterator pointing to the start of the matching
-    //                        portion of the input
-    //          last:         Iterator pointing to one past the end of the
-    //                        matching portion of the input
-    //
-    //      It is the responsibility of the scanner's action_policy policy to
-    //      dispatch the function or functor as it sees fit. The expected
-    //      function or functor signature depends on the parser being
-    //      wrapped. In general, if the attribute type of the parser being
-    //      wrapped is a nil_t, the function or functor expect the signature:
-    //
-    //          void func(Iterator first, Iterator last); // functions
-    //
-    //          struct ftor // functors
-    //          {
-    //              void func(Iterator first, Iterator last) const;
-    //          };
-    //
-    //      where Iterator is the type of the iterator that is being used and
-    //      first and last are the iterators pointing to the matching portion
-    //      of the input.
-    //
-    //      If the attribute type of the parser being wrapped is not a nil_t,
-    //      the function or functor usually expect the signature:
-    //
-    //          void func(T val); // functions
-    //
-    //          struct ftor // functors
-    //          {
-    //              void func(T val) const;
-    //          };
-    //
-    //      where T is the attribute type and val is the attribute value
-    //      returned by the parser being wrapped.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename ParserT, typename ActionT>
-    class action : public unary<ParserT, parser<action<ParserT, ActionT> > >
-    {
-    public:
-
-        typedef action<ParserT, ActionT>        self_t;
-        typedef action_parser_category          parser_category_t;
-        typedef unary<ParserT, parser<self_t> > base_t;
-        typedef ActionT                         predicate_t;
-
-        template <typename ScannerT>
-        struct result
-        {
-            typedef typename parser_result<ParserT, ScannerT>::type type;
-        };
-
-        action(ParserT const& p, ActionT const& a)
-        : base_t(p)
-        , actor(a) {}
-
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename ScannerT::iterator_t iterator_t;
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-
-            scan.at_end(); // allow skipper to take effect
-            iterator_t save = scan.first;
-            result_t hit = this->subject().parse(scan);
-            if (hit)
-            {
-                typename result_t::return_t val = hit.value();
-                scan.do_action(actor, val, save, scan.first);
-            }
-            return hit;
-        }
-
-        ActionT const& predicate() const { return actor; }
-
-    private:
-
-        ActionT actor;
-    };
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/alternative.hpp b/contrib/autoboost/boost/spirit/home/classic/core/composite/alternative.hpp
deleted file mode 100644
index 174a8dd13..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/alternative.hpp
+++ /dev/null
@@ -1,147 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_ALTERNATIVE_HPP)
-#define BOOST_SPIRIT_ALTERNATIVE_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
-#include <boost/spirit/home/classic/core/composite/composite.hpp>
-#include <boost/spirit/home/classic/meta/as_parser.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  alternative class
-    //
-    //      Handles expressions of the form:
-    //
-    //          a | b
-    //
-    //      where a and b are parsers. The expression returns a composite
-    //      parser that matches a or b. One (not both) of the operands may
-    //      be a literal char, wchar_t or a primitive string char const*,
-    //      wchar_t const*.
-    //
-    //      The expression is short circuit evaluated. b is never touched
-    //      when a is returns a successful match.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct alternative_parser_gen;
-    
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-
-    template <typename A, typename B>
-    struct alternative
-    :   public binary<A, B, parser<alternative<A, B> > >
-    {
-        typedef alternative<A, B>               self_t;
-        typedef binary_parser_category          parser_category_t;
-        typedef alternative_parser_gen          parser_generator_t;
-        typedef binary<A, B, parser<self_t> >   base_t;
-    
-        alternative(A const& a, B const& b)
-        : base_t(a, b) {}
-    
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            typedef typename ScannerT::iterator_t iterator_t;
-            { // scope for save
-                iterator_t save = scan.first;
-                if (result_t hit = this->left().parse(scan))
-                    return hit;
-                scan.first = save;
-            }
-            return this->right().parse(scan);
-        }
-    };
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-    
-    struct alternative_parser_gen
-    {
-        template <typename A, typename B>
-        struct result 
-        {
-            typedef 
-                alternative<
-                    typename as_parser<A>::type
-                  , typename as_parser<B>::type
-                > 
-            type;
-        };
-    
-        template <typename A, typename B>
-        static alternative<
-            typename as_parser<A>::type
-          , typename as_parser<B>::type
-        >
-        generate(A const& a, B const& b)
-        {
-            return alternative<BOOST_DEDUCED_TYPENAME as_parser<A>::type,
-                BOOST_DEDUCED_TYPENAME as_parser<B>::type>
-                    (as_parser<A>::convert(a), as_parser<B>::convert(b));
-        }
-    };
-    
-    template <typename A, typename B>
-    alternative<A, B>
-    operator|(parser<A> const& a, parser<B> const& b);
-    
-    template <typename A>
-    alternative<A, chlit<char> >
-    operator|(parser<A> const& a, char b);
-    
-    template <typename B>
-    alternative<chlit<char>, B>
-    operator|(char a, parser<B> const& b);
-    
-    template <typename A>
-    alternative<A, strlit<char const*> >
-    operator|(parser<A> const& a, char const* b);
-    
-    template <typename B>
-    alternative<strlit<char const*>, B>
-    operator|(char const* a, parser<B> const& b);
-    
-    template <typename A>
-    alternative<A, chlit<wchar_t> >
-    operator|(parser<A> const& a, wchar_t b);
-    
-    template <typename B>
-    alternative<chlit<wchar_t>, B>
-    operator|(wchar_t a, parser<B> const& b);
-    
-    template <typename A>
-    alternative<A, strlit<wchar_t const*> >
-    operator|(parser<A> const& a, wchar_t const* b);
-    
-    template <typename B>
-    alternative<strlit<wchar_t const*>, B>
-    operator|(wchar_t const* a, parser<B> const& b);
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
-#include <boost/spirit/home/classic/core/composite/impl/alternative.ipp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/composite.hpp b/contrib/autoboost/boost/spirit/home/classic/core/composite/composite.hpp
deleted file mode 100644
index e5bee9a3a..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/composite.hpp
+++ /dev/null
@@ -1,151 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_COMPOSITE_HPP)
-#define BOOST_SPIRIT_COMPOSITE_HPP
-
-///////////////////////////////////////////////////////////////////////////////
-#include <boost/compressed_pair.hpp>
-#include <boost/spirit/home/classic/namespace.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  unary class.
-    //
-    //      Composite class composed of a single subject. This template class
-    //      is parameterized by the subject type S and a base class to
-    //      inherit from, BaseT. The unary class is meant to be a base class
-    //      to inherit from. The inheritance structure, given the BaseT
-    //      template parameter places the unary class in the middle of a
-    //      linear, single parent hierarchy. For instance, given a class S
-    //      and a base class B, a class D can derive from unary:
-    //
-    //          struct D : public unary<S, B> {...};
-    //
-    //      The inheritance structure is thus:
-    //
-    //            B
-    //            |
-    //          unary (has S)
-    //            |
-    //            D
-    //
-    //      The subject can be accessed from the derived class D as:
-    //      this->subject();
-    //
-    //      Typically, the subject S is specified as typename S::embed_t.
-    //      embed_t specifies how the subject is embedded in the composite
-    //      (See parser.hpp for details).
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename S, typename BaseT>
-    class unary : public BaseT
-    {
-    public:
-
-        typedef BaseT                                           base_t;
-        typedef typename autoboost::call_traits<S>::param_type      param_t;
-        typedef typename autoboost::call_traits<S>::const_reference return_t;
-        typedef S                                               subject_t;
-        typedef typename S::embed_t                             subject_embed_t;
-
-        unary(param_t subj_)
-        : base_t(), subj(subj_) {}
-
-        unary(BaseT const& base, param_t subj_)
-        : base_t(base), subj(subj_) {}
-
-        return_t
-        subject() const
-        { return subj; }
-
-    private:
-
-        subject_embed_t subj;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  binary class.
-    //
-    //      Composite class composed of a pair (left and right). This
-    //      template class is parameterized by the left and right subject
-    //      types A and B and a base class to inherit from, BaseT. The binary
-    //      class is meant to be a base class to inherit from. The
-    //      inheritance structure, given the BaseT template parameter places
-    //      the binary class in the middle of a linear, single parent
-    //      hierarchy. For instance, given classes X and Y and a base class
-    //      B, a class D can derive from binary:
-    //
-    //          struct D : public binary<X, Y, B> {...};
-    //
-    //      The inheritance structure is thus:
-    //
-    //            B
-    //            |
-    //          binary (has X and Y)
-    //            |
-    //            D
-    //
-    //      The left and right subjects can be accessed from the derived
-    //      class D as: this->left(); and this->right();
-    //
-    //      Typically, the pairs X and Y are specified as typename X::embed_t
-    //      and typename Y::embed_t. embed_t specifies how the subject is
-    //      embedded in the composite (See parser.hpp for details).
-    //
-    ///////////////////////////////////////////////////////////////////////////////
-    template <typename A, typename B, typename BaseT>
-    class binary : public BaseT
-    {
-    public:
-
-        typedef BaseT                                           base_t;
-        typedef typename autoboost::call_traits<A>::param_type      left_param_t;
-        typedef typename autoboost::call_traits<A>::const_reference left_return_t;
-        typedef typename autoboost::call_traits<B>::param_type      right_param_t;
-        typedef typename autoboost::call_traits<B>::const_reference right_return_t;
-        typedef A                                               left_t;
-        typedef typename A::embed_t                             left_embed_t;
-        typedef B                                               right_t;
-        typedef typename B::embed_t                             right_embed_t;
-
-        binary(left_param_t a, right_param_t b)
-        : base_t(), subj(a, b) {}
-
-        left_return_t
-        left() const
-        { return subj.first(); }
-
-        right_return_t
-        right() const
-        { return subj.second(); }
-
-    private:
-
-        autoboost::compressed_pair<left_embed_t, right_embed_t> subj;
-    };
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/difference.hpp b/contrib/autoboost/boost/spirit/home/classic/core/composite/difference.hpp
deleted file mode 100644
index 4e986717a..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/difference.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_DIFFERENCE_HPP)
-#define BOOST_SPIRIT_DIFFERENCE_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
-#include <boost/spirit/home/classic/core/composite/composite.hpp>
-#include <boost/spirit/home/classic/meta/as_parser.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  difference: a - b; Matches a but not b
-    //
-    //      Handles expressions of the form:
-    //
-    //          a - b
-    //
-    //      where a and b are parsers. The expression returns a composite
-    //      parser that matches a but not b. One (not both) of the operands
-    //      may be a literal char, wchar_t or a primitive string char const*,
-    //      wchar_t const*.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct difference_parser_gen;
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-
-    template <typename A, typename B>
-    struct difference
-    :   public binary<A, B, parser<difference<A, B> > >
-    {
-        typedef difference<A, B>                self_t;
-        typedef binary_parser_category          parser_category_t;
-        typedef difference_parser_gen           parser_generator_t;
-        typedef binary<A, B, parser<self_t> >   base_t;
-    
-        difference(A const& a, B const& b)
-        : base_t(a, b) {}
-    
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            typedef typename ScannerT::iterator_t iterator_t;
-            iterator_t save = scan.first;
-            if (result_t hl = this->left().parse(scan))
-            {
-                std::swap(save, scan.first);
-                result_t hr = this->right().parse(scan);
-                if (!hr || (hr.length() < hl.length()))
-                {
-                    scan.first = save;
-                    return hl;
-                }
-            }
-    
-            return scan.no_match();
-        }
-    };
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-    
-    struct difference_parser_gen
-    {
-        template <typename A, typename B>
-        struct result 
-        {
-            typedef 
-                difference<
-                    typename as_parser<A>::type
-                  , typename as_parser<B>::type
-                > 
-            type;
-        };
-    
-        template <typename A, typename B>
-        static difference<
-            typename as_parser<A>::type
-          , typename as_parser<B>::type
-        >
-        generate(A const& a, B const& b)
-        {
-            return difference<BOOST_DEDUCED_TYPENAME as_parser<A>::type,
-                BOOST_DEDUCED_TYPENAME as_parser<B>::type>
-                    (as_parser<A>::convert(a), as_parser<B>::convert(b));
-        }
-    };
-    
-    template <typename A, typename B>
-    difference<A, B>
-    operator-(parser<A> const& a, parser<B> const& b);
-    
-    template <typename A>
-    difference<A, chlit<char> >
-    operator-(parser<A> const& a, char b);
-    
-    template <typename B>
-    difference<chlit<char>, B>
-    operator-(char a, parser<B> const& b);
-    
-    template <typename A>
-    difference<A, strlit<char const*> >
-    operator-(parser<A> const& a, char const* b);
-    
-    template <typename B>
-    difference<strlit<char const*>, B>
-    operator-(char const* a, parser<B> const& b);
-    
-    template <typename A>
-    difference<A, chlit<wchar_t> >
-    operator-(parser<A> const& a, wchar_t b);
-    
-    template <typename B>
-    difference<chlit<wchar_t>, B>
-    operator-(wchar_t a, parser<B> const& b);
-    
-    template <typename A>
-    difference<A, strlit<wchar_t const*> >
-    operator-(parser<A> const& a, wchar_t const* b);
-    
-    template <typename B>
-    difference<strlit<wchar_t const*>, B>
-    operator-(wchar_t const* a, parser<B> const& b);
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
-#include <boost/spirit/home/classic/core/composite/impl/difference.ipp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/directives.hpp b/contrib/autoboost/boost/spirit/home/classic/core/composite/directives.hpp
deleted file mode 100644
index a8fcedc38..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/directives.hpp
+++ /dev/null
@@ -1,607 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_DIRECTIVES_HPP)
-#define BOOST_SPIRIT_DIRECTIVES_HPP
-
-///////////////////////////////////////////////////////////////////////////////
-#include <algorithm>
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/scanner/skipper.hpp> 
-#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
-#include <boost/spirit/home/classic/core/composite/composite.hpp>
-#include <boost/spirit/home/classic/core/composite/impl/directives.ipp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  contiguous class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct lexeme_parser_gen;
-
-    template <typename ParserT>
-    struct contiguous
-    :   public unary<ParserT, parser<contiguous<ParserT> > >
-    {
-        typedef contiguous<ParserT>             self_t;
-        typedef unary_parser_category           parser_category_t;
-        typedef lexeme_parser_gen               parser_generator_t;
-        typedef unary<ParserT, parser<self_t> > base_t;
-
-        template <typename ScannerT>
-        struct result
-        {
-            typedef typename parser_result<ParserT, ScannerT>::type type;
-        };
-
-        contiguous(ParserT const& p)
-        : base_t(p) {}
-
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            return impl::contiguous_parser_parse<result_t>
-                (this->subject(), scan, scan);
-        }
-    };
-
-    struct lexeme_parser_gen
-    {
-        template <typename ParserT>
-        struct result {
-
-            typedef contiguous<ParserT> type;
-        };
-
-        template <typename ParserT>
-        static contiguous<ParserT>
-        generate(parser<ParserT> const& subject)
-        {
-            return contiguous<ParserT>(subject.derived());
-        }
-
-        template <typename ParserT>
-        contiguous<ParserT>
-        operator[](parser<ParserT> const& subject) const
-        {
-            return contiguous<ParserT>(subject.derived());
-        }
-    };
-
-    //////////////////////////////////
-    const lexeme_parser_gen lexeme_d = lexeme_parser_gen();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  lexeme_scanner
-    //
-    //      Given a Scanner, return the correct scanner type that
-    //      the lexeme_d uses. Scanner is assumed to be a phrase
-    //      level scanner (see skipper.hpp)
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename ScannerT>
-    struct lexeme_scanner
-    {
-        typedef scanner_policies<
-            no_skipper_iteration_policy<
-                typename ScannerT::iteration_policy_t>,
-            typename ScannerT::match_policy_t,
-            typename ScannerT::action_policy_t
-        > policies_t;
-
-        typedef typename
-            rebind_scanner_policies<ScannerT, policies_t>::type type;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  inhibit_case_iteration_policy class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename BaseT>
-    struct inhibit_case_iteration_policy : public BaseT
-    {
-        typedef BaseT base_t;
-
-        inhibit_case_iteration_policy()
-        : BaseT() {}
-
-        template <typename PolicyT>
-        inhibit_case_iteration_policy(PolicyT const& other)
-        : BaseT(other) {}
-
-        template <typename CharT>
-        CharT filter(CharT ch) const
-        { return impl::tolower_(ch); }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  inhibit_case class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct inhibit_case_parser_gen;
-
-    template <typename ParserT>
-    struct inhibit_case
-    :   public unary<ParserT, parser<inhibit_case<ParserT> > >
-    {
-        typedef inhibit_case<ParserT>           self_t;
-        typedef unary_parser_category           parser_category_t;
-        typedef inhibit_case_parser_gen         parser_generator_t;
-        typedef unary<ParserT, parser<self_t> > base_t;
-
-        template <typename ScannerT>
-        struct result
-        {
-            typedef typename parser_result<ParserT, ScannerT>::type type;
-        };
-
-        inhibit_case(ParserT const& p)
-        : base_t(p) {}
-
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            return impl::inhibit_case_parser_parse<result_t>
-                (this->subject(), scan, scan);
-        }
-    };
-
-    template <int N>
-    struct inhibit_case_parser_gen_base
-    {
-        //  This hack is needed to make borland happy.
-        //  If these member operators were defined in the
-        //  inhibit_case_parser_gen class, or if this class
-        //  is non-templated, borland ICEs.
-
-        static inhibit_case<strlit<char const*> >
-        generate(char const* str)
-        { return inhibit_case<strlit<char const*> >(str); }
-
-        static inhibit_case<strlit<wchar_t const*> >
-        generate(wchar_t const* str)
-        { return inhibit_case<strlit<wchar_t const*> >(str); }
-
-        static inhibit_case<chlit<char> >
-        generate(char ch)
-        { return inhibit_case<chlit<char> >(ch); }
-
-        static inhibit_case<chlit<wchar_t> >
-        generate(wchar_t ch)
-        { return inhibit_case<chlit<wchar_t> >(ch); }
-
-        template <typename ParserT>
-        static inhibit_case<ParserT>
-        generate(parser<ParserT> const& subject)
-        { return inhibit_case<ParserT>(subject.derived()); }
-
-        inhibit_case<strlit<char const*> >
-        operator[](char const* str) const
-        { return inhibit_case<strlit<char const*> >(str); }
-
-        inhibit_case<strlit<wchar_t const*> >
-        operator[](wchar_t const* str) const
-        { return inhibit_case<strlit<wchar_t const*> >(str); }
-
-        inhibit_case<chlit<char> >
-        operator[](char ch) const
-        { return inhibit_case<chlit<char> >(ch); }
-
-        inhibit_case<chlit<wchar_t> >
-        operator[](wchar_t ch) const
-        { return inhibit_case<chlit<wchar_t> >(ch); }
-
-        template <typename ParserT>
-        inhibit_case<ParserT>
-        operator[](parser<ParserT> const& subject) const
-        { return inhibit_case<ParserT>(subject.derived()); }
-    };
-
-    //////////////////////////////////
-    struct inhibit_case_parser_gen : public inhibit_case_parser_gen_base<0>
-    {
-        inhibit_case_parser_gen() {}
-    };
-
-    //////////////////////////////////
-    //  Depracated
-    const inhibit_case_parser_gen nocase_d = inhibit_case_parser_gen();
-
-    //  Preferred syntax
-    const inhibit_case_parser_gen as_lower_d = inhibit_case_parser_gen();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  as_lower_scanner
-    //
-    //      Given a Scanner, return the correct scanner type that
-    //      the as_lower_d uses. Scanner is assumed to be a scanner
-    //      with an inhibit_case_iteration_policy.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename ScannerT>
-    struct as_lower_scanner
-    {
-        typedef scanner_policies<
-            inhibit_case_iteration_policy<
-                typename ScannerT::iteration_policy_t>,
-            typename ScannerT::match_policy_t,
-            typename ScannerT::action_policy_t
-        > policies_t;
-
-        typedef typename
-            rebind_scanner_policies<ScannerT, policies_t>::type type;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  longest_alternative class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct longest_parser_gen;
-
-    template <typename A, typename B>
-    struct longest_alternative
-    :   public binary<A, B, parser<longest_alternative<A, B> > >
-    {
-        typedef longest_alternative<A, B>       self_t;
-        typedef binary_parser_category          parser_category_t;
-        typedef longest_parser_gen              parser_generator_t;
-        typedef binary<A, B, parser<self_t> >   base_t;
-
-        longest_alternative(A const& a, B const& b)
-        : base_t(a, b) {}
-
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            typename ScannerT::iterator_t save = scan.first;
-            result_t l = this->left().parse(scan);
-            std::swap(scan.first, save);
-            result_t r = this->right().parse(scan);
-
-            if (l || r)
-            {
-                if (l.length() > r.length())
-                {
-                    scan.first = save;
-                    return l;
-                }
-                return r;
-            }
-
-            return scan.no_match();
-        }
-    };
-
-    struct longest_parser_gen
-    {
-        template <typename A, typename B>
-        struct result {
-
-            typedef typename
-                impl::to_longest_alternative<alternative<A, B> >::result_t
-            type;
-        };
-
-        template <typename A, typename B>
-        static typename
-        impl::to_longest_alternative<alternative<A, B> >::result_t
-        generate(alternative<A, B> const& alt)
-        {
-            return impl::to_longest_alternative<alternative<A, B> >::
-                convert(alt);
-        }
-
-        //'generate' for binary composite
-        template <typename A, typename B>
-        static
-        longest_alternative<A, B>
-        generate(A const &left, B const &right)
-        {
-            return longest_alternative<A, B>(left, right);
-        }
-
-        template <typename A, typename B>
-        typename impl::to_longest_alternative<alternative<A, B> >::result_t
-        operator[](alternative<A, B> const& alt) const
-        {
-            return impl::to_longest_alternative<alternative<A, B> >::
-                convert(alt);
-        }
-    };
-
-    const longest_parser_gen longest_d = longest_parser_gen();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  shortest_alternative class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct shortest_parser_gen;
-
-    template <typename A, typename B>
-    struct shortest_alternative
-    :   public binary<A, B, parser<shortest_alternative<A, B> > >
-    {
-        typedef shortest_alternative<A, B>      self_t;
-        typedef binary_parser_category          parser_category_t;
-        typedef shortest_parser_gen             parser_generator_t;
-        typedef binary<A, B, parser<self_t> >   base_t;
-
-        shortest_alternative(A const& a, B const& b)
-        : base_t(a, b) {}
-
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            typename ScannerT::iterator_t save = scan.first;
-            result_t l = this->left().parse(scan);
-            std::swap(scan.first, save);
-            result_t r = this->right().parse(scan);
-
-            if (l || r)
-            {
-                if ((l.length() < r.length() && l) || !r)
-                {
-                    scan.first = save;
-                    return l;
-                }
-                return r;
-            }
-
-            return scan.no_match();
-        }
-    };
-
-    struct shortest_parser_gen
-    {
-        template <typename A, typename B>
-        struct result {
-
-            typedef typename
-                impl::to_shortest_alternative<alternative<A, B> >::result_t
-            type;
-        };
-
-        template <typename A, typename B>
-        static typename
-        impl::to_shortest_alternative<alternative<A, B> >::result_t
-        generate(alternative<A, B> const& alt)
-        {
-            return impl::to_shortest_alternative<alternative<A, B> >::
-                convert(alt);
-        }
-
-        //'generate' for binary composite
-        template <typename A, typename B>
-        static
-        shortest_alternative<A, B>
-        generate(A const &left, B const &right)
-        {
-            return shortest_alternative<A, B>(left, right);
-        }
-
-        template <typename A, typename B>
-        typename impl::to_shortest_alternative<alternative<A, B> >::result_t
-        operator[](alternative<A, B> const& alt) const
-        {
-            return impl::to_shortest_alternative<alternative<A, B> >::
-                convert(alt);
-        }
-    };
-
-    const shortest_parser_gen shortest_d = shortest_parser_gen();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  min_bounded class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename BoundsT>
-    struct min_bounded_gen;
-
-    template <typename ParserT, typename BoundsT>
-    struct min_bounded
-    :   public unary<ParserT, parser<min_bounded<ParserT, BoundsT> > >
-    {
-        typedef min_bounded<ParserT, BoundsT>   self_t;
-        typedef unary_parser_category           parser_category_t;
-        typedef min_bounded_gen<BoundsT>        parser_generator_t;
-        typedef unary<ParserT, parser<self_t> > base_t;
-
-        template <typename ScannerT>
-        struct result
-        {
-            typedef typename parser_result<ParserT, ScannerT>::type type;
-        };
-
-        min_bounded(ParserT const& p, BoundsT const& min__)
-        : base_t(p)
-        , min_(min__) {}
-
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            result_t hit = this->subject().parse(scan);
-            if (hit.has_valid_attribute() && hit.value() < min_)
-                return scan.no_match();
-            return hit;
-        }
-
-        BoundsT min_;
-    };
-
-    template <typename BoundsT>
-    struct min_bounded_gen
-    {
-        min_bounded_gen(BoundsT const& min__)
-        : min_(min__) {}
-
-        template <typename DerivedT>
-        min_bounded<DerivedT, BoundsT>
-        operator[](parser<DerivedT> const& p) const
-        { return min_bounded<DerivedT, BoundsT>(p.derived(), min_); }
-
-        BoundsT min_;
-    };
-
-    template <typename BoundsT>
-    inline min_bounded_gen<BoundsT>
-    min_limit_d(BoundsT const& min_)
-    { return min_bounded_gen<BoundsT>(min_); }
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  max_bounded class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename BoundsT>
-    struct max_bounded_gen;
-
-    template <typename ParserT, typename BoundsT>
-    struct max_bounded
-    :   public unary<ParserT, parser<max_bounded<ParserT, BoundsT> > >
-    {
-        typedef max_bounded<ParserT, BoundsT>   self_t;
-        typedef unary_parser_category           parser_category_t;
-        typedef max_bounded_gen<BoundsT>        parser_generator_t;
-        typedef unary<ParserT, parser<self_t> > base_t;
-
-        template <typename ScannerT>
-        struct result
-        {
-            typedef typename parser_result<ParserT, ScannerT>::type type;
-        };
-
-        max_bounded(ParserT const& p, BoundsT const& max__)
-        : base_t(p)
-        , max_(max__) {}
-
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            result_t hit = this->subject().parse(scan);
-            if (hit.has_valid_attribute() && hit.value() > max_)
-                return scan.no_match();
-            return hit;
-        }
-
-        BoundsT max_;
-    };
-
-    template <typename BoundsT>
-    struct max_bounded_gen
-    {
-        max_bounded_gen(BoundsT const& max__)
-        : max_(max__) {}
-
-        template <typename DerivedT>
-        max_bounded<DerivedT, BoundsT>
-        operator[](parser<DerivedT> const& p) const
-        { return max_bounded<DerivedT, BoundsT>(p.derived(), max_); }
-
-        BoundsT max_;
-    };
-
-    //////////////////////////////////
-    template <typename BoundsT>
-    inline max_bounded_gen<BoundsT>
-    max_limit_d(BoundsT const& max_)
-    { return max_bounded_gen<BoundsT>(max_); }
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  bounded class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename BoundsT>
-    struct bounded_gen;
-
-    template <typename ParserT, typename BoundsT>
-    struct bounded
-    :   public unary<ParserT, parser<bounded<ParserT, BoundsT> > >
-    {
-        typedef bounded<ParserT, BoundsT>       self_t;
-        typedef unary_parser_category           parser_category_t;
-        typedef bounded_gen<BoundsT>            parser_generator_t;
-        typedef unary<ParserT, parser<self_t> > base_t;
-
-        template <typename ScannerT>
-        struct result
-        {
-            typedef typename parser_result<ParserT, ScannerT>::type type;
-        };
-
-        bounded(ParserT const& p, BoundsT const& min__, BoundsT const& max__)
-        : base_t(p)
-        , min_(min__)
-        , max_(max__) {}
-
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            result_t hit = this->subject().parse(scan);
-            if (hit.has_valid_attribute() &&
-                (hit.value() < min_ || hit.value() > max_))
-                    return scan.no_match();
-            return hit;
-        }
-
-        BoundsT min_, max_;
-    };
-
-    template <typename BoundsT>
-    struct bounded_gen
-    {
-        bounded_gen(BoundsT const& min__, BoundsT const& max__)
-        : min_(min__)
-        , max_(max__) {}
-
-        template <typename DerivedT>
-        bounded<DerivedT, BoundsT>
-        operator[](parser<DerivedT> const& p) const
-        { return bounded<DerivedT, BoundsT>(p.derived(), min_, max_); }
-
-        BoundsT min_, max_;
-    };
-
-    template <typename BoundsT>
-    inline bounded_gen<BoundsT>
-    limit_d(BoundsT const& min_, BoundsT const& max_)
-    { return bounded_gen<BoundsT>(min_, max_); }
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/exclusive_or.hpp b/contrib/autoboost/boost/spirit/home/classic/core/composite/exclusive_or.hpp
deleted file mode 100644
index 8810d12c4..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/exclusive_or.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_EXCLUSIVE_OR_HPP)
-#define BOOST_SPIRIT_EXCLUSIVE_OR_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
-#include <boost/spirit/home/classic/core/composite/composite.hpp>
-#include <boost/spirit/home/classic/meta/as_parser.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  exclusive_or class
-    //
-    //      Handles expressions of the form:
-    //
-    //          a ^ b
-    //
-    //      where a and b are parsers. The expression returns a composite
-    //      parser that matches a or b but not both. One (not both) of the
-    //      operands may be a literal char, wchar_t or a primitive string
-    //      char const*, wchar_t const*.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct exclusive_or_parser_gen;
-
-    template <typename A, typename B>
-    struct exclusive_or
-    :   public binary<A, B, parser<exclusive_or<A, B> > >
-    {
-        typedef exclusive_or<A, B>              self_t;
-        typedef binary_parser_category          parser_category_t;
-        typedef exclusive_or_parser_gen         parser_generator_t;
-        typedef binary<A, B, parser<self_t> >   base_t;
-
-        exclusive_or(A const& a, B const& b)
-        : base_t(a, b) {}
-
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            typedef typename ScannerT::iterator_t iterator_t;
-
-            iterator_t save = scan.first;
-            result_t l = this->left().parse(scan);
-            std::swap(save, scan.first);
-            result_t r = this->right().parse(scan);
-
-            if (l ? !bool(r) : bool(r))
-            {
-                if (l)
-                    scan.first = save;
-                return l ? l : r;
-            }
-
-            return scan.no_match();
-        }
-    };
-
-    struct exclusive_or_parser_gen
-    {
-        template <typename A, typename B>
-        struct result
-        {
-            typedef
-                exclusive_or<
-                    typename as_parser<A>::type
-                  , typename as_parser<B>::type
-                >
-            type;
-        };
-
-        template <typename A, typename B>
-        static exclusive_or<
-            typename as_parser<A>::type
-          , typename as_parser<B>::type
-        >
-        generate(A const& a, B const& b)
-        {
-            return exclusive_or<BOOST_DEDUCED_TYPENAME as_parser<A>::type,
-                BOOST_DEDUCED_TYPENAME as_parser<B>::type>
-                    (as_parser<A>::convert(a), as_parser<B>::convert(b));
-        }
-    };
-
-    template <typename A, typename B>
-    exclusive_or<A, B>
-    operator^(parser<A> const& a, parser<B> const& b);
-
-    template <typename A>
-    exclusive_or<A, chlit<char> >
-    operator^(parser<A> const& a, char b);
-
-    template <typename B>
-    exclusive_or<chlit<char>, B>
-    operator^(char a, parser<B> const& b);
-
-    template <typename A>
-    exclusive_or<A, strlit<char const*> >
-    operator^(parser<A> const& a, char const* b);
-
-    template <typename B>
-    exclusive_or<strlit<char const*>, B>
-    operator^(char const* a, parser<B> const& b);
-
-    template <typename A>
-    exclusive_or<A, chlit<wchar_t> >
-    operator^(parser<A> const& a, wchar_t b);
-
-    template <typename B>
-    exclusive_or<chlit<wchar_t>, B>
-    operator^(wchar_t a, parser<B> const& b);
-
-    template <typename A>
-    exclusive_or<A, strlit<wchar_t const*> >
-    operator^(parser<A> const& a, wchar_t const* b);
-
-    template <typename B>
-    exclusive_or<strlit<wchar_t const*>, B>
-    operator^(wchar_t const* a, parser<B> const& b);
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
-#include <boost/spirit/home/classic/core/composite/impl/exclusive_or.ipp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/alternative.ipp b/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/alternative.ipp
deleted file mode 100644
index cffa46c4f..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/alternative.ipp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_ALTERNATIVE_IPP)
-#define BOOST_SPIRIT_ALTERNATIVE_IPP
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  alternative class implementation
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename A, typename B>
-    inline alternative<A, B>
-    operator|(parser<A> const& a, parser<B> const& b)
-    {
-        return alternative<A, B>(a.derived(), b.derived());
-    }
-    
-    template <typename A>
-    inline alternative<A, chlit<char> >
-    operator|(parser<A> const& a, char b)
-    {
-        return alternative<A, chlit<char> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline alternative<chlit<char>, B>
-    operator|(char a, parser<B> const& b)
-    {
-        return alternative<chlit<char>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline alternative<A, strlit<char const*> >
-    operator|(parser<A> const& a, char const* b)
-    {
-        return alternative<A, strlit<char const*> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline alternative<strlit<char const*>, B>
-    operator|(char const* a, parser<B> const& b)
-    {
-        return alternative<strlit<char const*>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline alternative<A, chlit<wchar_t> >
-    operator|(parser<A> const& a, wchar_t b)
-    {
-        return alternative<A, chlit<wchar_t> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline alternative<chlit<wchar_t>, B>
-    operator|(wchar_t a, parser<B> const& b)
-    {
-        return alternative<chlit<wchar_t>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline alternative<A, strlit<wchar_t const*> >
-    operator|(parser<A> const& a, wchar_t const* b)
-    {
-        return alternative<A, strlit<wchar_t const*> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline alternative<strlit<wchar_t const*>, B>
-    operator|(wchar_t const* a, parser<B> const& b)
-    {
-        return alternative<strlit<wchar_t const*>, B>(a, b.derived());
-    }
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/difference.ipp b/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/difference.ipp
deleted file mode 100644
index f37c912d4..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/difference.ipp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_DIFFERENCE_IPP)
-#define BOOST_SPIRIT_DIFFERENCE_IPP
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  difference class implementation
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename A, typename B>
-    inline difference<A, B>
-    operator-(parser<A> const& a, parser<B> const& b)
-    {
-        return difference<A, B>(a.derived(), b.derived());
-    }
-    
-    template <typename A>
-    inline difference<A, chlit<char> >
-    operator-(parser<A> const& a, char b)
-    {
-        return difference<A, chlit<char> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline difference<chlit<char>, B>
-    operator-(char a, parser<B> const& b)
-    {
-        return difference<chlit<char>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline difference<A, strlit<char const*> >
-    operator-(parser<A> const& a, char const* b)
-    {
-        return difference<A, strlit<char const*> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline difference<strlit<char const*>, B>
-    operator-(char const* a, parser<B> const& b)
-    {
-        return difference<strlit<char const*>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline difference<A, chlit<wchar_t> >
-    operator-(parser<A> const& a, wchar_t b)
-    {
-        return difference<A, chlit<wchar_t> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline difference<chlit<wchar_t>, B>
-    operator-(wchar_t a, parser<B> const& b)
-    {
-        return difference<chlit<wchar_t>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline difference<A, strlit<wchar_t const*> >
-    operator-(parser<A> const& a, wchar_t const* b)
-    {
-        return difference<A, strlit<wchar_t const*> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline difference<strlit<wchar_t const*>, B>
-    operator-(wchar_t const* a, parser<B> const& b)
-    {
-        return difference<strlit<wchar_t const*>, B>(a, b.derived());
-    }
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/directives.ipp b/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/directives.ipp
deleted file mode 100644
index 64af4389e..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/directives.ipp
+++ /dev/null
@@ -1,210 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2001 Bruce Florman
-    Copyright (c) 2002 Raghavendra Satish
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_DIRECTIVES_IPP)
-#define BOOST_SPIRIT_DIRECTIVES_IPP
-
-///////////////////////////////////////////////////////////////////////////////
-#include <boost/spirit/home/classic/core/scanner/skipper.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    template <typename BaseT>
-    struct no_skipper_iteration_policy;
-
-    template <typename BaseT>
-    struct inhibit_case_iteration_policy;
-
-    template <typename A, typename B>
-    struct alternative;
-
-    template <typename A, typename B>
-    struct longest_alternative;
-
-    template <typename A, typename B>
-    struct shortest_alternative;
-
-    namespace impl
-    {
-        template <typename RT, typename ST, typename ScannerT, typename BaseT>
-        inline RT
-        contiguous_parser_parse(
-            ST const& s,
-            ScannerT const& scan,
-            skipper_iteration_policy<BaseT> const&)
-        {
-            typedef scanner_policies<
-                no_skipper_iteration_policy<
-                    BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>,
-                BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t,
-                BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t
-            > policies_t;
-
-            scan.skip(scan);
-            RT hit = s.parse(scan.change_policies(policies_t(scan)));
-            // We will not do a post skip!!!
-            return hit;
-        }
-
-        template <typename RT, typename ST, typename ScannerT, typename BaseT>
-        inline RT
-        contiguous_parser_parse(
-            ST const& s,
-            ScannerT const& scan,
-            no_skipper_iteration_policy<BaseT> const&)
-        {
-            return s.parse(scan);
-        }
-
-        template <typename RT, typename ST, typename ScannerT>
-        inline RT
-        contiguous_parser_parse(
-            ST const& s,
-            ScannerT const& scan,
-            iteration_policy const&)
-        {
-            return s.parse(scan);
-        }
-
-        template <
-            typename RT,
-            typename ParserT,
-            typename ScannerT,
-            typename BaseT>
-        inline RT
-        implicit_lexeme_parse(
-            ParserT const& p,
-            ScannerT const& scan,
-            skipper_iteration_policy<BaseT> const&)
-        {
-            typedef scanner_policies<
-                no_skipper_iteration_policy<
-                    BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>,
-                BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t,
-                BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t
-            > policies_t;
-
-            scan.skip(scan);
-            RT hit = p.parse_main(scan.change_policies(policies_t(scan)));
-            // We will not do a post skip!!!
-            return hit;
-        }
-
-        template <
-            typename RT,
-            typename ParserT,
-            typename ScannerT,
-            typename BaseT>
-        inline RT
-        implicit_lexeme_parse(
-            ParserT const& p,
-            ScannerT const& scan,
-            no_skipper_iteration_policy<BaseT> const&)
-        {
-            return p.parse_main(scan);
-        }
-
-        template <typename RT, typename ParserT, typename ScannerT>
-        inline RT
-        implicit_lexeme_parse(
-            ParserT const& p,
-            ScannerT const& scan,
-            iteration_policy const&)
-        {
-            return p.parse_main(scan);
-        }
-
-        template <typename RT, typename ST, typename ScannerT>
-        inline RT
-        inhibit_case_parser_parse(
-            ST const& s,
-            ScannerT const& scan,
-            iteration_policy const&)
-        {
-            typedef scanner_policies<
-                inhibit_case_iteration_policy<
-                    BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>,
-                BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t,
-                BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t
-            > policies_t;
-
-            return s.parse(scan.change_policies(policies_t(scan)));
-        }
-
-        template <typename RT, typename ST, typename ScannerT, typename BaseT>
-        inline RT
-        inhibit_case_parser_parse(
-            ST const& s,
-            ScannerT const& scan,
-            inhibit_case_iteration_policy<BaseT> const&)
-        {
-            return s.parse(scan);
-        }
-
-        template <typename T>
-        struct to_longest_alternative
-        {
-            typedef T result_t;
-            static result_t const&
-            convert(T const& a)  //  Special (end) case
-            { return a; }
-        };
-
-        template <typename A, typename B>
-        struct to_longest_alternative<alternative<A, B> >
-        {
-            typedef typename to_longest_alternative<A>::result_t    a_t;
-            typedef typename to_longest_alternative<B>::result_t    b_t;
-            typedef longest_alternative<a_t, b_t>                   result_t;
-
-            static result_t
-            convert(alternative<A, B> const& alt) // Recursive case
-            {
-                return result_t(
-                    to_longest_alternative<A>::convert(alt.left()),
-                    to_longest_alternative<B>::convert(alt.right()));
-            }
-        };
-
-        template <typename T>
-        struct to_shortest_alternative
-        {
-            typedef T result_t;
-            static result_t const&
-            convert(T const& a) //  Special (end) case
-            { return a; }
-        };
-
-        template <typename A, typename B>
-        struct to_shortest_alternative<alternative<A, B> >
-        {
-            typedef typename to_shortest_alternative<A>::result_t   a_t;
-            typedef typename to_shortest_alternative<B>::result_t   b_t;
-            typedef shortest_alternative<a_t, b_t>                  result_t;
-
-            static result_t
-            convert(alternative<A, B> const& alt) //  Recursive case
-            {
-                return result_t(
-                    to_shortest_alternative<A>::convert(alt.left()),
-                    to_shortest_alternative<B>::convert(alt.right()));
-            }
-        };
-    }
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/exclusive_or.ipp b/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/exclusive_or.ipp
deleted file mode 100644
index 1abe2b561..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/exclusive_or.ipp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_EXCLUSIVE_OR_IPP)
-#define BOOST_SPIRIT_EXCLUSIVE_OR_IPP
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  exclusive_or class implementation
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename A, typename B>
-    inline exclusive_or<A, B>
-    operator^(parser<A> const& a, parser<B> const& b)
-    {
-        return exclusive_or<A, B>(a.derived(), b.derived());
-    }
-    
-    template <typename A>
-    inline exclusive_or<A, chlit<char> >
-    operator^(parser<A> const& a, char b)
-    {
-        return exclusive_or<A, chlit<char> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline exclusive_or<chlit<char>, B>
-    operator^(char a, parser<B> const& b)
-    {
-        return exclusive_or<chlit<char>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline exclusive_or<A, strlit<char const*> >
-    operator^(parser<A> const& a, char const* b)
-    {
-        return exclusive_or<A, strlit<char const*> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline exclusive_or<strlit<char const*>, B>
-    operator^(char const* a, parser<B> const& b)
-    {
-        return exclusive_or<strlit<char const*>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline exclusive_or<A, chlit<wchar_t> >
-    operator^(parser<A> const& a, wchar_t b)
-    {
-        return exclusive_or<A, chlit<wchar_t> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline exclusive_or<chlit<wchar_t>, B>
-    operator^(wchar_t a, parser<B> const& b)
-    {
-        return exclusive_or<chlit<wchar_t>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline exclusive_or<A, strlit<wchar_t const*> >
-    operator^(parser<A> const& a, wchar_t const* b)
-    {
-        return exclusive_or<A, strlit<wchar_t const*> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline exclusive_or<strlit<wchar_t const*>, B>
-    operator^(wchar_t const* a, parser<B> const& b)
-    {
-        return exclusive_or<strlit<wchar_t const*>, B>(a, b.derived());
-    }
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/intersection.ipp b/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/intersection.ipp
deleted file mode 100644
index c51f57379..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/intersection.ipp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_INTERSECTION_IPP)
-#define BOOST_SPIRIT_INTERSECTION_IPP
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  intersection class implementation
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename A, typename B>
-    inline intersection<A, B>
-    operator&(parser<A> const& a, parser<B> const& b)
-    {
-        return intersection<A, B>(a.derived(), b.derived());
-    }
-    
-    template <typename A>
-    inline intersection<A, chlit<char> >
-    operator&(parser<A> const& a, char b)
-    {
-        return intersection<A, chlit<char> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline intersection<chlit<char>, B>
-    operator&(char a, parser<B> const& b)
-    {
-        return intersection<chlit<char>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline intersection<A, strlit<char const*> >
-    operator&(parser<A> const& a, char const* b)
-    {
-        return intersection<A, strlit<char const*> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline intersection<strlit<char const*>, B>
-    operator&(char const* a, parser<B> const& b)
-    {
-        return intersection<strlit<char const*>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline intersection<A, chlit<wchar_t> >
-    operator&(parser<A> const& a, wchar_t b)
-    {
-        return intersection<A, chlit<wchar_t> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline intersection<chlit<wchar_t>, B>
-    operator&(wchar_t a, parser<B> const& b)
-    {
-        return intersection<chlit<wchar_t>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline intersection<A, strlit<wchar_t const*> >
-    operator&(parser<A> const& a, wchar_t const* b)
-    {
-        return intersection<A, strlit<wchar_t const*> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline intersection<strlit<wchar_t const*>, B>
-    operator&(wchar_t const* a, parser<B> const& b)
-    {
-        return intersection<strlit<wchar_t const*>, B>(a, b.derived());
-    }
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/kleene_star.ipp b/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/kleene_star.ipp
deleted file mode 100644
index 421abe936..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/kleene_star.ipp
+++ /dev/null
@@ -1,34 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_KLEENE_STAR_IPP)
-#define BOOST_SPIRIT_KLEENE_STAR_IPP
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  kleene_star class implementation
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename S>
-    inline kleene_star<S>
-    operator*(parser<S> const& a)
-    {
-        return kleene_star<S>(a.derived());
-    }
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/list.ipp b/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/list.ipp
deleted file mode 100644
index 72467aa84..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/list.ipp
+++ /dev/null
@@ -1,93 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_LIST_IPP)
-#define BOOST_SPIRIT_LIST_IPP
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  operator% is defined as:
-    //  a % b ---> a >> *(b >> a)
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename A, typename B>
-    inline sequence<A, kleene_star<sequence<B, A> > >
-    operator%(parser<A> const& a, parser<B> const& b)
-    {
-        return a.derived() >> *(b.derived() >> a.derived());
-    }
-    
-    template <typename A>
-    inline sequence<A, kleene_star<sequence<chlit<char>, A> > >
-    operator%(parser<A> const& a, char b)
-    {
-        return a.derived() >> *(b >> a.derived());
-    }
-    
-    template <typename B>
-    inline sequence<chlit<char>, kleene_star<sequence<B, chlit<char> > > >
-    operator%(char a, parser<B> const& b)
-    {
-        return a >> *(b.derived() >> a);
-    }
-    
-    template <typename A>
-    inline sequence<A, kleene_star<sequence<strlit<char const*>, A> > >
-    operator%(parser<A> const& a, char const* b)
-    {
-        return a.derived() >> *(b >> a.derived());
-    }
-    
-    template <typename B>
-    inline sequence<strlit<char const*>,
-        kleene_star<sequence<B, strlit<char const*> > > >
-    operator%(char const* a, parser<B> const& b)
-    {
-        return a >> *(b.derived() >> a);
-    }
-    
-    template <typename A>
-    inline sequence<A, kleene_star<sequence<chlit<wchar_t>, A> > >
-    operator%(parser<A> const& a, wchar_t b)
-    {
-        return a.derived() >> *(b >> a.derived());
-    }
-    
-    template <typename B>
-    inline sequence<chlit<wchar_t>, kleene_star<sequence<B, chlit<wchar_t> > > >
-    operator%(wchar_t a, parser<B> const& b)
-    {
-        return a >> *(b.derived() >> a);
-    }
-    
-    template <typename A>
-    inline sequence<A, kleene_star<sequence<strlit<wchar_t const*>, A> > >
-    operator%(parser<A> const& a, wchar_t const* b)
-    {
-        return a.derived() >> *(b >> a.derived());
-    }
-    
-    template <typename B>
-    inline sequence<strlit<wchar_t const*>,
-        kleene_star<sequence<B, strlit<wchar_t const*> > > >
-    operator%(wchar_t const* a, parser<B> const& b)
-    {
-        return a >> *(b.derived() >> a);
-    }
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/optional.ipp b/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/optional.ipp
deleted file mode 100644
index cf235ec1a..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/optional.ipp
+++ /dev/null
@@ -1,34 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_OPTIONAL_IPP)
-#define BOOST_SPIRIT_OPTIONAL_IPP
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  optional class implementation
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename S>
-    optional<S>
-    operator!(parser<S> const& a)
-    {
-        return optional<S>(a.derived());
-    }
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/positive.ipp b/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/positive.ipp
deleted file mode 100644
index bcef0905b..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/positive.ipp
+++ /dev/null
@@ -1,34 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_POSITIVE_IPP)
-#define BOOST_SPIRIT_POSITIVE_IPP
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  positive class implementation
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename S>
-    inline positive<S>
-    operator+(parser<S> const& a)
-    {
-        return positive<S>(a.derived());
-    }
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/sequence.ipp b/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/sequence.ipp
deleted file mode 100644
index 5cc8fe1f0..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/sequence.ipp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_SEQUENCE_IPP)
-#define BOOST_SPIRIT_SEQUENCE_IPP
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  sequence class implementation
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename A, typename B>
-    inline sequence<A, B>
-    operator>>(parser<A> const& a, parser<B> const& b)
-    {
-        return sequence<A, B>(a.derived(), b.derived());
-    }
-    
-    template <typename A>
-    inline sequence<A, chlit<char> >
-    operator>>(parser<A> const& a, char b)
-    {
-        return sequence<A, chlit<char> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline sequence<chlit<char>, B>
-    operator>>(char a, parser<B> const& b)
-    {
-        return sequence<chlit<char>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline sequence<A, strlit<char const*> >
-    operator>>(parser<A> const& a, char const* b)
-    {
-        return sequence<A, strlit<char const*> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline sequence<strlit<char const*>, B>
-    operator>>(char const* a, parser<B> const& b)
-    {
-        return sequence<strlit<char const*>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline sequence<A, chlit<wchar_t> >
-    operator>>(parser<A> const& a, wchar_t b)
-    {
-        return sequence<A, chlit<wchar_t> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline sequence<chlit<wchar_t>, B>
-    operator>>(wchar_t a, parser<B> const& b)
-    {
-        return sequence<chlit<wchar_t>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline sequence<A, strlit<wchar_t const*> >
-    operator>>(parser<A> const& a, wchar_t const* b)
-    {
-        return sequence<A, strlit<wchar_t const*> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline sequence<strlit<wchar_t const*>, B>
-    operator>>(wchar_t const* a, parser<B> const& b)
-    {
-        return sequence<strlit<wchar_t const*>, B>(a, b.derived());
-    }
-    
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/sequential_and.ipp b/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/sequential_and.ipp
deleted file mode 100644
index 2cdcac8de..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/sequential_and.ipp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_SEQUENTIAL_AND_IPP)
-#define BOOST_SPIRIT_SEQUENTIAL_AND_IPP
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  sequential-and operators implementation
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename A, typename B>
-    inline sequence<A, B>
-    operator&&(parser<A> const& a, parser<B> const& b)
-    {
-        return sequence<A, B>(a.derived(), b.derived());
-    }
-    
-    template <typename A>
-    inline sequence<A, chlit<char> >
-    operator&&(parser<A> const& a, char b)
-    {
-        return sequence<A, chlit<char> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline sequence<chlit<char>, B>
-    operator&&(char a, parser<B> const& b)
-    {
-        return sequence<chlit<char>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline sequence<A, strlit<char const*> >
-    operator&&(parser<A> const& a, char const* b)
-    {
-        return sequence<A, strlit<char const*> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline sequence<strlit<char const*>, B>
-    operator&&(char const* a, parser<B> const& b)
-    {
-        return sequence<strlit<char const*>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline sequence<A, chlit<wchar_t> >
-    operator&&(parser<A> const& a, wchar_t b)
-    {
-        return sequence<A, chlit<wchar_t> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline sequence<chlit<wchar_t>, B>
-    operator&&(wchar_t a, parser<B> const& b)
-    {
-        return sequence<chlit<wchar_t>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline sequence<A, strlit<wchar_t const*> >
-    operator&&(parser<A> const& a, wchar_t const* b)
-    {
-        return sequence<A, strlit<wchar_t const*> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline sequence<strlit<wchar_t const*>, B>
-    operator&&(wchar_t const* a, parser<B> const& b)
-    {
-        return sequence<strlit<wchar_t const*>, B>(a, b.derived());
-    }
-    
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/sequential_or.ipp b/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/sequential_or.ipp
deleted file mode 100644
index 156db467b..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/impl/sequential_or.ipp
+++ /dev/null
@@ -1,90 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_SEQUENTIAL_OR_IPP)
-#define BOOST_SPIRIT_SEQUENTIAL_OR_IPP
-
-namespace autoboost { namespace spirit {
-
- BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-   ///////////////////////////////////////////////////////////////////////////
-    //
-    //  sequential-or class implementation
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename A, typename B>
-    inline sequential_or<A, B>
-    operator||(parser<A> const& a, parser<B> const& b)
-    {
-        return sequential_or<A, B>(a.derived(), b.derived());
-    }
-    
-    template <typename A>
-    inline sequential_or<A, chlit<char> >
-    operator||(parser<A> const& a, char b)
-    {
-        return sequential_or<A, chlit<char> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline sequential_or<chlit<char>, B>
-    operator||(char a, parser<B> const& b)
-    {
-        return sequential_or<chlit<char>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline sequential_or<A, strlit<char const*> >
-    operator||(parser<A> const& a, char const* b)
-    {
-        return sequential_or<A, strlit<char const*> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline sequential_or<strlit<char const*>, B>
-    operator||(char const* a, parser<B> const& b)
-    {
-        return sequential_or<strlit<char const*>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline sequential_or<A, chlit<wchar_t> >
-    operator||(parser<A> const& a, wchar_t b)
-    {
-        return sequential_or<A, chlit<wchar_t> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline sequential_or<chlit<wchar_t>, B>
-    operator||(wchar_t a, parser<B> const& b)
-    {
-        return sequential_or<chlit<wchar_t>, B>(a, b.derived());
-    }
-    
-    template <typename A>
-    inline sequential_or<A, strlit<wchar_t const*> >
-    operator||(parser<A> const& a, wchar_t const* b)
-    {
-        return sequential_or<A, strlit<wchar_t const*> >(a.derived(), b);
-    }
-    
-    template <typename B>
-    inline sequential_or<strlit<wchar_t const*>, B>
-    operator||(wchar_t const* a, parser<B> const& b)
-    {
-        return sequential_or<strlit<wchar_t const*>, B>(a, b.derived());
-    }
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/intersection.hpp b/contrib/autoboost/boost/spirit/home/classic/core/composite/intersection.hpp
deleted file mode 100644
index b912d87e2..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/intersection.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_INTERSECTION_HPP)
-#define BOOST_SPIRIT_INTERSECTION_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
-#include <boost/spirit/home/classic/core/composite/composite.hpp>
-#include <boost/spirit/home/classic/meta/as_parser.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  intersection class
-    //
-    //      Handles expressions of the form:
-    //
-    //          a & b
-    //
-    //      where a and b are parsers. The expression returns a composite
-    //      parser that matches a and b. One (not both) of the operands may
-    //      be a literal char, wchar_t or a primitive string char const*,
-    //      wchar_t const*.
-    //
-    //      The expression is short circuit evaluated. b is never touched
-    //      when a is returns a no-match.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct intersection_parser_gen;
-    
-    template <typename A, typename B>
-    struct intersection
-    :   public binary<A, B, parser<intersection<A, B> > >
-    {
-        typedef intersection<A, B>              self_t;
-        typedef binary_parser_category          parser_category_t;
-        typedef intersection_parser_gen         parser_generator_t;
-        typedef binary<A, B, parser<self_t> >   base_t;
-    
-        intersection(A const& a, B const& b)
-        : base_t(a, b) {}
-    
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            typedef typename ScannerT::iterator_t iterator_t;
-            iterator_t save = scan.first;
-            if (result_t hl = this->left().parse(scan))
-            {
-                ScannerT bscan(scan.first, scan.first, scan);
-                scan.first = save;
-                result_t hr = this->right().parse(bscan);
-                if (hl.length() == hr.length())
-                    return hl;
-            }
-    
-            return scan.no_match();
-        }
-    };
-    
-    struct intersection_parser_gen
-    {
-        template <typename A, typename B>
-        struct result 
-        {
-            typedef 
-                intersection<
-                    typename as_parser<A>::type
-                  , typename as_parser<B>::type
-                >
-            type;
-        };
-    
-        template <typename A, typename B>
-        static intersection<
-            typename as_parser<A>::type
-          , typename as_parser<B>::type
-        >
-        generate(A const& a, B const& b)
-        {
-            return intersection<BOOST_DEDUCED_TYPENAME as_parser<A>::type,
-                BOOST_DEDUCED_TYPENAME as_parser<B>::type>
-                    (as_parser<A>::convert(a), as_parser<B>::convert(b));
-        }
-    };
-    
-    template <typename A, typename B>
-    intersection<A, B>
-    operator&(parser<A> const& a, parser<B> const& b);
-    
-    template <typename A>
-    intersection<A, chlit<char> >
-    operator&(parser<A> const& a, char b);
-    
-    template <typename B>
-    intersection<chlit<char>, B>
-    operator&(char a, parser<B> const& b);
-    
-    template <typename A>
-    intersection<A, strlit<char const*> >
-    operator&(parser<A> const& a, char const* b);
-    
-    template <typename B>
-    intersection<strlit<char const*>, B>
-    operator&(char const* a, parser<B> const& b);
-    
-    template <typename A>
-    intersection<A, chlit<wchar_t> >
-    operator&(parser<A> const& a, wchar_t b);
-    
-    template <typename B>
-    intersection<chlit<wchar_t>, B>
-    operator&(wchar_t a, parser<B> const& b);
-    
-    template <typename A>
-    intersection<A, strlit<wchar_t const*> >
-    operator&(parser<A> const& a, wchar_t const* b);
-    
-    template <typename B>
-    intersection<strlit<wchar_t const*>, B>
-    operator&(wchar_t const* a, parser<B> const& b);
-    
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
-#include <boost/spirit/home/classic/core/composite/impl/intersection.ipp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/kleene_star.hpp b/contrib/autoboost/boost/spirit/home/classic/core/composite/kleene_star.hpp
deleted file mode 100644
index 85cc0fb3d..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/kleene_star.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_KLEENE_STAR_HPP)
-#define BOOST_SPIRIT_KLEENE_STAR_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
-#include <boost/spirit/home/classic/core/composite/composite.hpp>
-#include <boost/spirit/home/classic/meta/as_parser.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  kleene_star class
-    //
-    //      Handles expressions of the form:
-    //
-    //          *a
-    //
-    //      where a is a parser. The expression returns a composite
-    //      parser that matches its subject zero (0) or more times.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct kleene_star_parser_gen;
-    
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-
-    template <typename S>
-    struct kleene_star
-    :   public unary<S, parser<kleene_star<S> > >
-    {
-        typedef kleene_star<S>              self_t;
-        typedef unary_parser_category       parser_category_t;
-        typedef kleene_star_parser_gen      parser_generator_t;
-        typedef unary<S, parser<self_t> >   base_t;
-    
-        kleene_star(S const& a)
-        : base_t(a) {}
-    
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            typedef typename ScannerT::iterator_t iterator_t;
-            result_t hit = scan.empty_match();
-    
-            for (;;)
-            {
-                iterator_t save = scan.first;
-                if (result_t next = this->subject().parse(scan))
-                {
-                    scan.concat_match(hit, next);
-                }
-                else
-                {
-                    scan.first = save;
-                    return hit;
-                }
-            }
-        }
-    };
-    
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-
-    struct kleene_star_parser_gen
-    {
-        template <typename S>
-        struct result 
-        {
-            typedef kleene_star<S> type;
-        };
-    
-        template <typename S>
-        static kleene_star<S>
-        generate(parser<S> const& a)
-        {
-            return kleene_star<S>(a.derived());
-        }
-    };
-    
-    //////////////////////////////////
-    template <typename S>
-    kleene_star<S>
-    operator*(parser<S> const& a);
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
-#include <boost/spirit/home/classic/core/composite/impl/kleene_star.ipp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/list.hpp b/contrib/autoboost/boost/spirit/home/classic/core/composite/list.hpp
deleted file mode 100644
index b1b9cc0a6..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/list.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_LIST_HPP)
-#define BOOST_SPIRIT_LIST_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
-#include <boost/spirit/home/classic/core/composite/composite.hpp>
-#include <boost/spirit/home/classic/meta/as_parser.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  operator% is defined as:
-    //  a % b ---> a >> *(b >> a)
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename A, typename B>
-    sequence<A, kleene_star<sequence<B, A> > >
-    operator%(parser<A> const& a, parser<B> const& b);
-    
-    template <typename A>
-    sequence<A, kleene_star<sequence<chlit<char>, A> > >
-    operator%(parser<A> const& a, char b);
-    
-    template <typename B>
-    sequence<chlit<char>, kleene_star<sequence<B, chlit<char> > > >
-    operator%(char a, parser<B> const& b);
-    
-    template <typename A>
-    sequence<A, kleene_star<sequence<strlit<char const*>, A> > >
-    operator%(parser<A> const& a, char const* b);
-    
-    template <typename B>
-    sequence<strlit<char const*>,
-        kleene_star<sequence<B, strlit<char const*> > > >
-    operator%(char const* a, parser<B> const& b);
-    
-    template <typename A>
-    sequence<A, kleene_star<sequence<chlit<wchar_t>, A> > >
-    operator%(parser<A> const& a, wchar_t b);
-    
-    template <typename B>
-    sequence<chlit<wchar_t>, kleene_star<sequence<B, chlit<wchar_t> > > >
-    operator%(wchar_t a, parser<B> const& b);
-    
-    template <typename A>
-    sequence<A, kleene_star<sequence<strlit<wchar_t const*>, A> > >
-    operator%(parser<A> const& a, wchar_t const* b);
-    
-    template <typename B>
-    sequence<strlit<wchar_t const*>,
-        kleene_star<sequence<B, strlit<wchar_t const*> > > >
-    operator%(wchar_t const* a, parser<B> const& b);
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
-#include <boost/spirit/home/classic/core/composite/impl/list.ipp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/operators.hpp b/contrib/autoboost/boost/spirit/home/classic/core/composite/operators.hpp
deleted file mode 100644
index 5732ef9ae..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/operators.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_OPERATORS_HPP)
-#define BOOST_SPIRIT_OPERATORS_HPP
-
-#include <boost/spirit/home/classic/core/composite/sequence.hpp>
-#include <boost/spirit/home/classic/core/composite/sequential_and.hpp>
-#include <boost/spirit/home/classic/core/composite/sequential_or.hpp>
-#include <boost/spirit/home/classic/core/composite/alternative.hpp>
-#include <boost/spirit/home/classic/core/composite/difference.hpp>
-#include <boost/spirit/home/classic/core/composite/intersection.hpp>
-#include <boost/spirit/home/classic/core/composite/exclusive_or.hpp>
-#include <boost/spirit/home/classic/core/composite/kleene_star.hpp>
-#include <boost/spirit/home/classic/core/composite/positive.hpp>
-#include <boost/spirit/home/classic/core/composite/optional.hpp>
-#include <boost/spirit/home/classic/core/composite/list.hpp>
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/optional.hpp b/contrib/autoboost/boost/spirit/home/classic/core/composite/optional.hpp
deleted file mode 100644
index ef6c7f4fb..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/optional.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_OPTIONAL_HPP)
-#define BOOST_SPIRIT_OPTIONAL_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
-#include <boost/spirit/home/classic/core/composite/composite.hpp>
-#include <boost/spirit/home/classic/meta/as_parser.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  optional class
-    //
-    //      Handles expressions of the form:
-    //
-    //          !a
-    //
-    //      where a is a parser. The expression returns a composite
-    //      parser that matches its subject zero (0) or one (1) time.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct optional_parser_gen;
-    
-    template <typename S>
-    struct optional
-    :   public unary<S, parser<optional<S> > >
-    {
-        typedef optional<S>                 self_t;
-        typedef unary_parser_category       parser_category_t;
-        typedef optional_parser_gen         parser_generator_t;
-        typedef unary<S, parser<self_t> >   base_t;
-    
-        optional(S const& a)
-        : base_t(a) {}
-    
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            typedef typename ScannerT::iterator_t iterator_t;
-            iterator_t save = scan.first;
-            if (result_t r = this->subject().parse(scan))
-            {
-                return r;
-            }
-            else
-            {
-                scan.first = save;
-                return scan.empty_match();
-            }
-        }
-    };
-    
-    struct optional_parser_gen
-    {
-        template <typename S>
-        struct result 
-        {
-            typedef optional<S> type;
-        };
-    
-        template <typename S>
-        static optional<S>
-        generate(parser<S> const& a)
-        {
-            return optional<S>(a.derived());
-        }
-    };
-    
-    template <typename S>
-    optional<S>
-    operator!(parser<S> const& a);
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
-#include <boost/spirit/home/classic/core/composite/impl/optional.ipp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/positive.hpp b/contrib/autoboost/boost/spirit/home/classic/core/composite/positive.hpp
deleted file mode 100644
index 0b478bab6..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/positive.hpp
+++ /dev/null
@@ -1,112 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_POSITIVE_HPP)
-#define BOOST_SPIRIT_POSITIVE_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
-#include <boost/spirit/home/classic/core/composite/composite.hpp>
-#include <boost/spirit/home/classic/meta/as_parser.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  positive class
-    //
-    //      Handles expressions of the form:
-    //
-    //          +a
-    //
-    //      where a is a parser. The expression returns a composite
-    //      parser that matches its subject one (1) or more times.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct positive_parser_gen;
-    
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-
-    template <typename S>
-    struct positive
-    :   public unary<S, parser<positive<S> > >
-    {
-        typedef positive<S>                 self_t;
-        typedef unary_parser_category       parser_category_t;
-        typedef positive_parser_gen         parser_generator_t;
-        typedef unary<S, parser<self_t> >   base_t;
-    
-        positive(S const& a)
-        : base_t(a) {}
-    
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            typedef typename ScannerT::iterator_t iterator_t;
-            result_t hit = this->subject().parse(scan);
-    
-            if (hit)
-            {
-                for (;;)
-                {
-                    iterator_t save = scan.first;
-                    if (result_t next = this->subject().parse(scan))
-                    {
-                        scan.concat_match(hit, next);
-                    }
-                    else
-                    {
-                        scan.first = save;
-                        break;
-                    }
-                }
-            }
-            return hit;
-        }
-    };
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-    
-    struct positive_parser_gen
-    {
-        template <typename S>
-        struct result 
-        {
-            typedef positive<S> type;
-        };
-    
-        template <typename S>
-        static positive<S>
-        generate(parser<S> const& a)
-        {
-            return positive<S>(a.derived());
-        }
-    };
-    
-    template <typename S>
-    inline positive<S>
-    operator+(parser<S> const& a);
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
-#include <boost/spirit/home/classic/core/composite/impl/positive.ipp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/sequence.hpp b/contrib/autoboost/boost/spirit/home/classic/core/composite/sequence.hpp
deleted file mode 100644
index 13069381d..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/sequence.hpp
+++ /dev/null
@@ -1,142 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_SEQUENCE_HPP)
-#define BOOST_SPIRIT_SEQUENCE_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
-#include <boost/spirit/home/classic/core/composite/composite.hpp>
-#include <boost/spirit/home/classic/meta/as_parser.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  sequence class
-    //
-    //      Handles expressions of the form:
-    //
-    //          a >> b
-    //
-    //      where a and b are parsers. The expression returns a composite
-    //      parser that matches a and b in sequence. One (not both) of the
-    //      operands may be a literal char, wchar_t or a primitive string
-    //      char const*, wchar_t const*.
-    //
-    //////////////////////////////////////////////////////////////////////////
-    struct sequence_parser_gen;
-    
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-
-    template <typename A, typename B>
-    struct sequence : public binary<A, B, parser<sequence<A, B> > >
-    {
-        typedef sequence<A, B>                  self_t;
-        typedef binary_parser_category          parser_category_t;
-        typedef sequence_parser_gen             parser_generator_t;
-        typedef binary<A, B, parser<self_t> >   base_t;
-    
-        sequence(A const& a, B const& b)
-        : base_t(a, b) {}
-    
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            if (result_t ma = this->left().parse(scan))
-                if (result_t mb = this->right().parse(scan))
-                {
-                    scan.concat_match(ma, mb);
-                    return ma;
-                }
-            return scan.no_match();
-        }
-    };
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-    
-    struct sequence_parser_gen
-    {
-        template <typename A, typename B>
-        struct result 
-        {
-            typedef
-                sequence<
-                    typename as_parser<A>::type
-                  , typename as_parser<B>::type
-                >
-            type;
-        };
-    
-        template <typename A, typename B>
-        static sequence<
-            typename as_parser<A>::type
-          , typename as_parser<B>::type
-        >
-        generate(A const& a, B const& b)
-        {
-            return sequence<BOOST_DEDUCED_TYPENAME as_parser<A>::type,
-                BOOST_DEDUCED_TYPENAME as_parser<B>::type>
-                    (as_parser<A>::convert(a), as_parser<B>::convert(b));
-        }
-    };
-    
-    template <typename A, typename B>
-    sequence<A, B>
-    operator>>(parser<A> const& a, parser<B> const& b);
-    
-    template <typename A>
-    sequence<A, chlit<char> >
-    operator>>(parser<A> const& a, char b);
-    
-    template <typename B>
-    sequence<chlit<char>, B>
-    operator>>(char a, parser<B> const& b);
-    
-    template <typename A>
-    sequence<A, strlit<char const*> >
-    operator>>(parser<A> const& a, char const* b);
-    
-    template <typename B>
-    sequence<strlit<char const*>, B>
-    operator>>(char const* a, parser<B> const& b);
-    
-    template <typename A>
-    sequence<A, chlit<wchar_t> >
-    operator>>(parser<A> const& a, wchar_t b);
-    
-    template <typename B>
-    sequence<chlit<wchar_t>, B>
-    operator>>(wchar_t a, parser<B> const& b);
-    
-    template <typename A>
-    sequence<A, strlit<wchar_t const*> >
-    operator>>(parser<A> const& a, wchar_t const* b);
-    
-    template <typename B>
-    sequence<strlit<wchar_t const*>, B>
-    operator>>(wchar_t const* a, parser<B> const& b);
-    
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
-#include <boost/spirit/home/classic/core/composite/impl/sequence.ipp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/sequential_and.hpp b/contrib/autoboost/boost/spirit/home/classic/core/composite/sequential_and.hpp
deleted file mode 100644
index da9b80319..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/sequential_and.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_SEQUENTIAL_AND_HPP)
-#define BOOST_SPIRIT_SEQUENTIAL_AND_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
-#include <boost/spirit/home/classic/core/composite/composite.hpp>
-#include <boost/spirit/home/classic/meta/as_parser.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  sequential-and operators
-    //
-    //      Handles expressions of the form:
-    //
-    //          a && b
-    //
-    //      Same as a >> b.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename A, typename B>
-    sequence<A, B>
-    operator&&(parser<A> const& a, parser<B> const& b);
-    
-    template <typename A>
-    sequence<A, chlit<char> >
-    operator&&(parser<A> const& a, char b);
-    
-    template <typename B>
-    sequence<chlit<char>, B>
-    operator&&(char a, parser<B> const& b);
-    
-    template <typename A>
-    sequence<A, strlit<char const*> >
-    operator&&(parser<A> const& a, char const* b);
-    
-    template <typename B>
-    sequence<strlit<char const*>, B>
-    operator&&(char const* a, parser<B> const& b);
-    
-    template <typename A>
-    sequence<A, chlit<wchar_t> >
-    operator&&(parser<A> const& a, wchar_t b);
-    
-    template <typename B>
-    sequence<chlit<wchar_t>, B>
-    operator&&(wchar_t a, parser<B> const& b);
-    
-    template <typename A>
-    sequence<A, strlit<wchar_t const*> >
-    operator&&(parser<A> const& a, wchar_t const* b);
-    
-    template <typename B>
-    sequence<strlit<wchar_t const*>, B>
-    operator&&(wchar_t const* a, parser<B> const& b);
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
-#include <boost/spirit/home/classic/core/composite/impl/sequential_and.ipp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/composite/sequential_or.hpp b/contrib/autoboost/boost/spirit/home/classic/core/composite/sequential_or.hpp
deleted file mode 100644
index e04afcf6c..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/composite/sequential_or.hpp
+++ /dev/null
@@ -1,154 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    Copyright (c) 2002 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_SEQUENTIAL_OR_HPP)
-#define BOOST_SPIRIT_SEQUENTIAL_OR_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
-#include <boost/spirit/home/classic/core/composite/composite.hpp>
-#include <boost/spirit/home/classic/meta/as_parser.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  sequential-or class
-    //
-    //      Handles expressions of the form:
-    //
-    //          a || b
-    //
-    //      Equivalent to
-    //
-    //          a | b | a >> b;
-    //
-    //      where a and b are parsers. The expression returns a composite
-    //      parser that matches matches a or b in sequence. One (not both) of
-    //      the operands may be a literal char, wchar_t or a primitive string
-    //      char const*, wchar_t const*.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct sequential_or_parser_gen;
-    
-    template <typename A, typename B>
-    struct sequential_or : public binary<A, B, parser<sequential_or<A, B> > >
-    {
-        typedef sequential_or<A, B>             self_t;
-        typedef binary_parser_category          parser_category_t;
-        typedef sequential_or_parser_gen        parser_generator_t;
-        typedef binary<A, B, parser<self_t> >   base_t;
-    
-        sequential_or(A const& a, B const& b)
-        : base_t(a, b) {}
-    
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            typedef typename ScannerT::iterator_t iterator_t;
-            { // scope for save
-                iterator_t save = scan.first;
-                if (result_t ma = this->left().parse(scan))
-                {
-                    save = scan.first;
-                    if (result_t mb = this->right().parse(scan))
-                    {
-                        // matched a b
-                        scan.concat_match(ma, mb);
-                        return ma;
-                    }
-                    else
-                    {
-                        // matched a
-                        scan.first = save;
-                        return ma;
-                    }
-                }
-                scan.first = save;
-            }
-    
-            // matched b
-            return this->right().parse(scan);
-        }
-    };
-    
-    struct sequential_or_parser_gen
-    {
-        template <typename A, typename B>
-        struct result 
-        {
-            typedef 
-                sequential_or<
-                    typename as_parser<A>::type
-                  , typename as_parser<B>::type
-                > 
-            type;
-        };
-    
-        template <typename A, typename B>
-        static sequential_or<
-            typename as_parser<A>::type
-          , typename as_parser<B>::type
-        >
-        generate(A const& a, B const& b)
-        {
-            return sequential_or<BOOST_DEDUCED_TYPENAME as_parser<A>::type,
-                BOOST_DEDUCED_TYPENAME as_parser<B>::type>
-                    (as_parser<A>::convert(a), as_parser<B>::convert(b));
-        }
-    };
-    
-    template <typename A, typename B>
-    sequential_or<A, B>
-    operator||(parser<A> const& a, parser<B> const& b);
-    
-    template <typename A>
-    sequential_or<A, chlit<char> >
-    operator||(parser<A> const& a, char b);
-    
-    template <typename B>
-    sequential_or<chlit<char>, B>
-    operator||(char a, parser<B> const& b);
-    
-    template <typename A>
-    sequential_or<A, strlit<char const*> >
-    operator||(parser<A> const& a, char const* b);
-    
-    template <typename B>
-    sequential_or<strlit<char const*>, B>
-    operator||(char const* a, parser<B> const& b);
-
-    template <typename A>
-    sequential_or<A, chlit<wchar_t> >
-    operator||(parser<A> const& a, wchar_t b);
-    
-    template <typename B>
-    sequential_or<chlit<wchar_t>, B>
-    operator||(wchar_t a, parser<B> const& b);
-    
-    template <typename A>
-    sequential_or<A, strlit<wchar_t const*> >
-    operator||(parser<A> const& a, wchar_t const* b);
-    
-    template <typename B>
-    sequential_or<strlit<wchar_t const*>, B>
-    operator||(wchar_t const* a, parser<B> const& b);
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
-#include <boost/spirit/home/classic/core/composite/impl/sequential_or.ipp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/config.hpp b/contrib/autoboost/boost/spirit/home/classic/core/config.hpp
deleted file mode 100644
index 57eca7f03..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/config.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_CONFIG_HPP)
-#define BOOST_SPIRIT_CONFIG_HPP
-
-#include <boost/config.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Compiler check:
-//
-//  Historically, Spirit supported a lot of compilers, including (to some
-//  extent) poorly conforming compilers such as VC6. Spirit v1.6.x will be
-//  the last release that will support older poorly conforming compilers.
-//  Starting from Spirit v1.8.0, ill conforming compilers will not be
-//  supported. If you are still using one of these older compilers, you can
-//  still use Spirit v1.6.x.
-//
-//  The reason why Spirit v1.6.x worked on old non-conforming compilers is
-//  that the authors laboriously took the trouble of searching for
-//  workarounds to make these compilers happy. The process takes a lot of
-//  time and energy, especially when one encounters the dreaded ICE or
-//  "Internal Compiler Error". Sometimes searching for a single workaround
-//  takes days or even weeks. Sometimes, there are no known workarounds. This
-//  stifles progress a lot. And, as the library gets more progressive and
-//  takes on more advanced C++ techniques, the difficulty is escalated to
-//  even new heights.
-//
-//  Spirit v1.6.x will still be supported. Maintenance and bug fixes will
-//  still be applied. There will still be active development for the back-
-//  porting of new features introduced in Spirit v1.8.0 (and Spirit 1.9.0)
-//  to lesser able compilers; hopefully, fueled by contributions from the
-//  community. For instance, there is already a working AST tree back-port
-//  for VC6 and VC7 by Peder Holt.
-//
-//  If you got here somehow, your compiler is known to be poorly conforming
-//  WRT ANSI/ISO C++ standard. Library implementers get a bad reputation when
-//  someone attempts to compile the code on a non-conforming compiler. She'll
-//  be confronted with tons of compiler errors when she tries to compile the
-//  library. Such errors will somehow make less informed users conclude that
-//  the code is poorly written. It's better for the user to see a message
-//  "sorry, this code has not been ported to your compiler yet", than to see
-//  pages and pages of compiler error messages.
-//
-/////////////////////////////////////////////////////////////////////////////////
-#if     (defined(BOOST_MSVC) && (BOOST_MSVC < 1310))                            \
-    ||  (defined(__BORLANDC__) && (__BORLANDC__ <= 0x570))                      \
-    ||  (defined(__GNUC__) && (__GNUC__ < 3))                                   \
-    ||  (defined(__GNUC__) && (__GNUC__ == 3) && (__GNUC_MINOR__ < 1))
-# error "Compiler not supported. See note in <boost/spirit/core/config.hpp>"
-#else
-// Pass... Compiler supported.
-#endif
-
-#endif
-
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/impl/match.ipp b/contrib/autoboost/boost/spirit/home/classic/core/impl/match.ipp
deleted file mode 100644
index dcd32ff4d..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/impl/match.ipp
+++ /dev/null
@@ -1,113 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_MATCH_IPP)
-#define BOOST_SPIRIT_MATCH_IPP
-#include <algorithm>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    template <typename T>
-    inline match<T>::match()
-    : len(-1), val() {}
-
-    template <typename T>
-    inline match<T>::match(std::size_t length_)
-    : len(length_), val() {}
-
-    template <typename T>
-    inline match<T>::match(std::size_t length_, ctor_param_t val_)
-    : len(length_), val(val_) {}
-
-    template <typename T>
-    inline bool
-    match<T>::operator!() const
-    {
-        return len < 0;
-    }
-
-    template <typename T>
-    inline std::ptrdiff_t
-    match<T>::length() const
-    {
-        return len;
-    }
-
-    template <typename T>
-    inline bool
-    match<T>::has_valid_attribute() const
-    {
-        return val.is_initialized();
-    }
-
-    template <typename T>
-    inline typename match<T>::return_t
-    match<T>::value() const
-    {
-        BOOST_SPIRIT_ASSERT(val.is_initialized());
-        return *val;
-    }
-
-    template <typename T>
-    inline void
-    match<T>::swap(match& other)
-    {
-        std::swap(len, other.len);
-        std::swap(val, other.val);
-    }
-
-    inline match<nil_t>::match()
-    : len(-1) {}
-
-    inline match<nil_t>::match(std::size_t length_)
-    : len(length_) {}
-
-    inline match<nil_t>::match(std::size_t length_, nil_t)
-    : len(length_) {}
-
-    inline bool
-    match<nil_t>::operator!() const
-    {
-        return len < 0;
-    }
-
-    inline bool
-    match<nil_t>::has_valid_attribute() const
-    {
-        return false;
-    }
-
-    inline std::ptrdiff_t
-    match<nil_t>::length() const
-    {
-        return len;
-    }
-
-    inline nil_t
-    match<nil_t>::value() const
-    {
-        return nil_t();
-    }
-
-    inline void
-    match<nil_t>::value(nil_t) {}
-
-    inline void
-    match<nil_t>::swap(match<nil_t>& other)
-    {
-        std::swap(len, other.len);
-    }
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/impl/match_attr_traits.ipp b/contrib/autoboost/boost/spirit/home/classic/core/impl/match_attr_traits.ipp
deleted file mode 100644
index 6e9b6c67c..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/impl/match_attr_traits.ipp
+++ /dev/null
@@ -1,102 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_MATCH_ATTR_TRAITS_IPP)
-#define BOOST_SPIRIT_MATCH_ATTR_TRAITS_IPP
-
-#include <boost/optional.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_same.hpp>
-
-namespace autoboost { namespace spirit { 
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-namespace impl
-{
-    template <typename T>
-    struct match_attr_traits
-    {
-        typedef typename
-            autoboost::optional<T>::reference_const_type
-        const_reference;
-
-        //  case where src *IS* convertible to T (dest)
-        template <typename T2>
-        static void
-        convert(autoboost::optional<T>& dest, T2 const& src, mpl::true_)
-        { 
-            dest.reset(src); 
-        }
-
-        //  case where src *IS NOT* convertible to T (dest)
-        template <typename T2>
-        static void
-        convert(autoboost::optional<T>& dest, T2 const& /*src*/, mpl::false_)
-        { 
-            dest.reset(); 
-        }
-
-        static void
-        convert(autoboost::optional<T>& dest, nil_t/*src*/)
-        { 
-            dest.reset(); 
-        }
-        
-        template <typename T2>
-        static void
-        convert(autoboost::optional<T>& dest, T2 const& src)
-        { 
-            convert(dest, src, is_convertible<T2, T>());
-        }
-
-        template <typename OtherMatchT>
-        static void
-        copy(autoboost::optional<T>& dest, OtherMatchT const& src)
-        {
-            if (src.has_valid_attribute())
-                convert(dest, src.value());
-        }
-
-        template <typename OtherMatchT>
-        static void
-        assign(autoboost::optional<T>& dest, OtherMatchT const& src)
-        {
-            if (src.has_valid_attribute())
-                convert(dest, src.value());
-            else
-                dest.reset();
-        }
-
-        // T is not reference
-        template <typename ValueT>
-        static void
-        set_value(autoboost::optional<T>& dest, ValueT const& val, mpl::false_)
-        {
-            dest.reset(val);
-        }
-
-        // T is a reference
-        template <typename ValueT>
-        static void
-        set_value(autoboost::optional<T>& dest, ValueT const& val, mpl::true_)
-        {
-            dest.get() = val;
-        }
-    };
-
-}
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit::impl
-
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/impl/parser.ipp b/contrib/autoboost/boost/spirit/home/classic/core/impl/parser.ipp
deleted file mode 100644
index 30a94c9a0..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/impl/parser.ipp
+++ /dev/null
@@ -1,55 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_PARSER_IPP)
-#define BOOST_SPIRIT_PARSER_IPP
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  Generic parse function implementation
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename IteratorT, typename DerivedT>
-    inline parse_info<IteratorT>
-    parse(
-        IteratorT const& first_
-      , IteratorT const& last
-      , parser<DerivedT> const& p)
-    {
-        IteratorT first = first_;
-        scanner<IteratorT, scanner_policies<> > scan(first, last);
-        match<nil_t> hit = p.derived().parse(scan);
-        return parse_info<IteratorT>(
-            first, hit, hit && (first == last), hit.length());
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  Parse function for null terminated strings implementation
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename CharT, typename DerivedT>
-    inline parse_info<CharT const*>
-    parse(CharT const* str, parser<DerivedT> const& p)
-    {
-        CharT const* last = str;
-        while (*last)
-            last++;
-        return parse(str, last, p);
-    }
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/match.hpp b/contrib/autoboost/boost/spirit/home/classic/core/match.hpp
deleted file mode 100644
index 32136bd55..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/match.hpp
+++ /dev/null
@@ -1,185 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_MATCH_HPP)
-#define BOOST_SPIRIT_MATCH_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/config.hpp>
-#include <boost/spirit/home/classic/core/nil.hpp>
-#include <boost/call_traits.hpp>
-#include <boost/optional.hpp>
-#include <boost/spirit/home/classic/core/assert.hpp>
-#include <boost/spirit/home/classic/core/safe_bool.hpp>
-#include <boost/spirit/home/classic/core/impl/match_attr_traits.ipp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/type_traits/is_reference.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  match class
-    //
-    //      The match holds the result of a parser. A match object evaluates
-    //      to true when a successful match is found, otherwise false. The
-    //      length of the match is the number of characters (or tokens) that
-    //      is successfully matched. This can be queried through its length()
-    //      member function. A negative value means that the match is
-    //      unsucessful.
-    //
-    //      Each parser may have an associated attribute. This attribute is
-    //      also returned back to the client on a successful parse through
-    //      the match object. The match's value() member function returns the
-    //      match's attribute.
-    //
-    //      A match attribute is valid:
-    //
-    //          * on a successful match
-    //          * when its value is set through the value(val) member function
-    //          * if it is assigned or copied from a compatible match object
-    //            (e.g. match<double> from match<int>) with a valid attribute.
-    //
-    //      The match attribute is undefined:
-    //
-    //          * on an unsuccessful match
-    //          * when an attempt to copy or assign from another match object
-    //            with an incompatible attribute type (e.g. match<std::string>
-    //            from match<int>).
-    //
-    //      The member function has_valid_attribute() can be queried to know if
-    //      it is safe to get the match's attribute. The attribute may be set
-    //      through the member function value(v) where v is the new attribute
-    //      value.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename T = nil_t>
-    class match : public safe_bool<match<T> >
-    {
-
-    public:
-
-        typedef typename autoboost::optional<T> optional_type;
-        typedef typename optional_type::argument_type ctor_param_t;
-        typedef typename optional_type::reference_const_type return_t;
-        typedef T attr_t;
-
-                                match();
-        explicit                match(std::size_t length);
-                                match(std::size_t length, ctor_param_t val);
-
-        bool                    operator!() const;
-        std::ptrdiff_t          length() const;
-        bool                    has_valid_attribute() const;
-        return_t                value() const;
-        void                    swap(match& other);
-
-        template <typename T2>
-        match(match<T2> const& other)
-        : len(other.length()), val()
-        {
-            impl::match_attr_traits<T>::copy(val, other);
-        }
-
-        template <typename T2>
-        match&
-        operator=(match<T2> const& other)
-        {
-            impl::match_attr_traits<T>::assign(val, other);
-            len = other.length();
-            return *this;
-        }
-
-        template <typename MatchT>
-        void
-        concat(MatchT const& other)
-        {
-            BOOST_SPIRIT_ASSERT(*this && other);
-            len += other.length();
-        }
-
-        template <typename ValueT>
-        void
-        value(ValueT const& val_)
-        {
-            impl::match_attr_traits<T>::set_value(val, val_, is_reference<T>());
-        }
-
-        bool operator_bool() const
-        {
-            return len >= 0;
-        }
-
-    private:
-
-        std::ptrdiff_t len;
-        optional_type val;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  match class specialization for nil_t values
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <>
-    class match<nil_t> : public safe_bool<match<nil_t> >
-    {
-    public:
-
-        typedef nil_t attr_t;
-        typedef nil_t return_t;
-
-                                match();
-        explicit                match(std::size_t length);
-                                match(std::size_t length, nil_t);
-
-        bool                    operator!() const;
-        bool                    has_valid_attribute() const;
-        std::ptrdiff_t          length() const;
-        nil_t                   value() const;
-        void                    value(nil_t);
-        void                    swap(match& other);
-
-        template <typename T>
-        match(match<T> const& other)
-        : len(other.length()) {}
-
-        template <typename T>
-        match<>&
-        operator=(match<T> const& other)
-        {
-            len = other.length();
-            return *this;
-        }
-
-        template <typename T>
-        void
-        concat(match<T> const& other)
-        {
-            BOOST_SPIRIT_ASSERT(*this && other);
-            len += other.length();
-        }
-
-        bool operator_bool() const
-        {
-            return len >= 0;
-        }
-
-    private:
-
-        std::ptrdiff_t len;
-    };
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-#include <boost/spirit/home/classic/core/impl/match.ipp>
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/nil.hpp b/contrib/autoboost/boost/spirit/home/classic/core/nil.hpp
deleted file mode 100644
index b0d171c6e..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/nil.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_NIL_HPP)
-#define BOOST_SPIRIT_NIL_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    struct nil_t {};
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}}
-
-#endif
-
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/non_terminal/impl/rule.ipp b/contrib/autoboost/boost/spirit/home/classic/core/non_terminal/impl/rule.ipp
deleted file mode 100644
index 9db5531cf..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/non_terminal/impl/rule.ipp
+++ /dev/null
@@ -1,420 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_RULE_IPP)
-#define BOOST_SPIRIT_RULE_IPP
-
-#if BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1
-#include <boost/preprocessor/repeat.hpp>
-#include <boost/preprocessor/repeat_from_to.hpp>
-#include <boost/preprocessor/enum_params.hpp>
-#include <boost/preprocessor/enum_params_with_defaults.hpp>
-#include <boost/preprocessor/facilities/intercept.hpp>
-#include <boost/preprocessor/inc.hpp>
-#include <boost/preprocessor/cat.hpp>
-#endif
-
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/scanner/scanner.hpp>
-#include <boost/spirit/home/classic/core/non_terminal/parser_context.hpp>
-#include <boost/spirit/home/classic/core/non_terminal/parser_id.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-#if BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1
-
-        template <
-            BOOST_PP_ENUM_BINARY_PARAMS(
-                BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT,
-                typename ScannerT, = mpl::void_ BOOST_PP_INTERCEPT
-            )
-        >
-        struct scanner_list;
-
-#endif // BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1
-
-    ///////////////////////////////////////////////////////////////////////////
-    namespace impl
-    {
-        template <typename BaseT, typename DefaultT
-            , typename T0, typename T1, typename T2>
-        struct get_param
-        {
-            typedef typename mpl::if_<
-                is_base_and_derived<BaseT, T0>
-              , T0
-              , typename mpl::if_<
-                    is_base_and_derived<BaseT, T1>
-                  , T1
-                  , typename mpl::if_<
-                        is_base_and_derived<BaseT, T2>
-                      , T2
-                      , DefaultT
-                    >::type
-                >::type
-            >::type type;
-        };
-
-        template <typename T0, typename T1, typename T2>
-        struct get_context
-        {
-            typedef typename get_param<
-                parser_context_base, parser_context<>, T0, T1, T2>::type
-            type;
-        };
-
-        template <typename T0, typename T1, typename T2>
-        struct get_tag
-        {
-            typedef typename get_param<
-                parser_tag_base, parser_address_tag, T0, T1, T2>::type
-            type;
-        };
-
-        template <typename T0, typename T1, typename T2>
-        struct get_scanner
-        {
-            typedef typename get_param<
-                scanner_base, scanner<>, T0, T1, T2>::type
-            type;
-        };
-
-        ///////////////////////////////////////////////////////////////////////
-        //
-        //  rule_base class
-        //
-        //      The rule_base class implements the basic plumbing for rules
-        //      minus the storage mechanism. It is up to the derived class
-        //      to actually store the definition somewhere. The rule_base
-        //      class assumes that the derived class provides a get() function
-        //      that will return a pointer to a parser. The get() function
-        //      may return NULL. See rule below for details.
-        //
-        //      <<< For framework use only. Not for public consumption. >>>
-        //
-        ///////////////////////////////////////////////////////////////////////
-        template <
-            typename DerivedT       // derived class
-          , typename EmbedT         // how derived class is embedded
-          , typename T0 = nil_t     // see rule class
-          , typename T1 = nil_t     // see rule class
-          , typename T2 = nil_t     // see rule class
-        >
-        class rule_base; // forward declaration
-
-        class rule_base_access
-        {
-#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) \
-    || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-        public: // YUCK!
-#else
-            template <
-                typename DerivedT
-              , typename EmbedT
-              , typename T0
-              , typename T1
-              , typename T2
-            >
-           friend class rule_base;
-#endif
-            template <typename RuleT>
-            static typename RuleT::abstract_parser_t*
-            get(RuleT const& r)
-            {
-                return r.get();
-            }
-        };
-
-        template <
-            typename DerivedT       // derived class
-          , typename EmbedT         // how derived class is embedded
-          , typename T0             // see rule class
-          , typename T1             // see rule class
-          , typename T2             // see rule class
-        >
-        class rule_base
-            : public parser<DerivedT>
-            , public impl::get_context<T0, T1, T2>::type::base_t
-            , public context_aux<
-                typename impl::get_context<T0, T1, T2>::type, DerivedT>
-            , public impl::get_tag<T0, T1, T2>::type
-        {
-        public:
-
-            typedef typename impl::get_scanner<T0, T1, T2>::type scanner_t;
-            typedef typename impl::get_context<T0, T1, T2>::type context_t;
-            typedef typename impl::get_tag<T0, T1, T2>::type tag_t;
-
-            typedef EmbedT embed_t;
-            typedef typename context_t::context_linker_t linked_context_t;
-            typedef typename linked_context_t::attr_t attr_t;
-
-            template <typename ScannerT>
-            struct result
-            {
-                typedef typename match_result<ScannerT, attr_t>::type type;
-            };
-
-            template <typename ScannerT>
-            typename parser_result<DerivedT, ScannerT>::type
-            parse(ScannerT const& scan) const
-            {
-                typedef parser_scanner_linker<ScannerT> linked_scanner_t;
-                typedef typename parser_result<DerivedT, ScannerT>::type result_t;
-                BOOST_SPIRIT_CONTEXT_PARSE(
-                    scan, *this, linked_scanner_t, linked_context_t, result_t);
-            }
-
-            template <typename ScannerT>
-            typename parser_result<DerivedT, ScannerT>::type
-            parse_main(ScannerT const& scan) const
-            {
-                typename parser_result<DerivedT, ScannerT>::type hit;
-
-                //  MWCW 8.3 needs this cast to be done through a pointer,
-                //  not a reference. Otherwise, it will silently construct
-                //  a temporary, causing an infinite runtime recursion.
-                DerivedT const* derived_this = static_cast<DerivedT const*>(this);
-
-                if (rule_base_access::get(*derived_this))
-                {
-                    typename ScannerT::iterator_t s(scan.first);
-                    hit = rule_base_access::get(*derived_this)
-                            ->do_parse_virtual(scan);
-                    scan.group_match(hit, this->id(), s, scan.first);
-                }
-                else
-                {
-                    hit = scan.no_match();
-                }
-                return hit;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////
-        //
-        //  abstract_parser class
-        //
-        ///////////////////////////////////////////////////////////////////////
-        template <typename ScannerT, typename AttrT>
-        struct abstract_parser
-        {
-            abstract_parser() {}
-            virtual ~abstract_parser() {}
-
-            virtual typename match_result<ScannerT, AttrT>::type
-            do_parse_virtual(ScannerT const& scan) const = 0;
-
-            virtual abstract_parser*
-            clone() const = 0;
-        };
-
-        ///////////////////////////////////////////////////////////////////////
-        //
-        //  concrete_parser class
-        //
-        ///////////////////////////////////////////////////////////////////////
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-        
-        template <typename ParserT, typename ScannerT, typename AttrT>
-        struct concrete_parser : abstract_parser<ScannerT, AttrT>
-        {
-            concrete_parser(ParserT const& p_) : p(p_) {}
-            virtual ~concrete_parser() {}
-
-            virtual typename match_result<ScannerT, AttrT>::type
-            do_parse_virtual(ScannerT const& scan) const
-            {
-                return p.parse(scan);
-            }
-
-            virtual abstract_parser<ScannerT, AttrT>*
-            clone() const
-            {
-                return new concrete_parser(p);
-            }
-
-            typename ParserT::embed_t p;
-        };
-        
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-
-#if BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1
-
-        ///////////////////////////////////////////////////////////////////////
-        //
-        //  This generates partial specializations for the class
-        //
-        //          abstract_parser
-        //
-        //  with an increasing number of different ScannerT template parameters
-        //  and corresponding do_parse_virtual function declarations for each
-        //  of the different required scanner types:
-        //
-        //      template <typename ScannerT0, ..., typename AttrT>
-        //      struct abstract_parser<scanner_list<ScannerT0, ...>, AttrT>
-        //      {
-        //          abstract_parser() {}
-        //          virtual ~abstract_parser() {}
-        //
-        //          virtual typename match_result<ScannerT0, AttrT>::type
-        //          do_parse_virtual(ScannerT0 const &scan) const = 0;
-        //
-        //          virtual abstract_parser*
-        //          clone() const = 0;
-        //
-        //          ...
-        //      };
-        //
-        ///////////////////////////////////////////////////////////////////////
-        #define BOOST_SPIRIT_RULE_ENUM_DOPARSE_A(z, N, _)                       \
-                virtual typename match_result<                                  \
-                    BOOST_PP_CAT(ScannerT, N), AttrT                            \
-                >::type                                                         \
-                do_parse_virtual(                                               \
-                    BOOST_PP_CAT(ScannerT, N) const& scan) const = 0;           \
-
-        #define BOOST_SPIRIT_ENUM_ABSTRACT_PARSERS(z, N, _)                     \
-            template <                                                          \
-                BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_INC(N), typename ScannerT),  \
-                typename AttrT                                                  \
-            >                                                                   \
-            struct abstract_parser<                                             \
-                scanner_list<                                                   \
-                    BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_INC(N), ScannerT)        \
-                >,                                                              \
-                AttrT                                                           \
-            >                                                                   \
-            {                                                                   \
-                abstract_parser() {}                                            \
-                virtual ~abstract_parser() {}                                   \
-                                                                                \
-                BOOST_PP_REPEAT_ ## z(                                          \
-                    BOOST_PP_INC(N), BOOST_SPIRIT_RULE_ENUM_DOPARSE_A, _)       \
-                                                                                \
-                virtual abstract_parser*                                        \
-                clone() const = 0;                                              \
-            };                                                                  \
-
-        BOOST_PP_REPEAT_FROM_TO(1, BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT,
-            BOOST_SPIRIT_ENUM_ABSTRACT_PARSERS, _)
-
-        #undef BOOST_SPIRIT_RULE_ENUM_DOPARSE_A
-        #undef BOOST_SPIRIT_ENUM_ABSTRACT_PARSERS
-        ///////////////////////////////////////////////////////////////////////
-
-        ///////////////////////////////////////////////////////////////////////
-        //
-        //  This generates partial specializations for the class
-        //
-        //          concrete_parser
-        //
-        //  with an increasing number of different ScannerT template parameters
-        //  and corresponding do_parse_virtual function declarations for each
-        //  of the different required scanner types:
-        //
-        //      template <
-        //          typename ParserT, typename ScannerT0, ..., typename AttrT
-        //      >
-        //      struct concrete_parser<
-        //          ParserT, scanner_list<ScannerT0, ...>, AttrT
-        //      >
-        //      :   public abstract_parser<scanner_list<ScannerT0, ...>, AttrT>
-        //      {
-        //          concrete_parser(ParserT const& p_) : p(p_) {}
-        //          virtual ~concrete_parser() {}
-        //
-        //          virtual typename match_result<ScannerT0, AttrT>::type
-        //          do_parse_virtual(ScannerT0 const &scan) const
-        //          { return p.parse(scan); }
-        //
-        //          virtual abstract_parser<scanner_list<ScannerT0, ...>, AttrT>*
-        //          clone() const
-        //          {
-        //              return new concrete_parser(p);
-        //          }
-        //
-        //          ...
-        //
-        //          typename ParserT::embed_t p;
-        //      };
-        //
-        ///////////////////////////////////////////////////////////////////////
-        #define BOOST_SPIRIT_RULE_ENUM_DOPARSE_C(z, N, _)                       \
-                virtual typename match_result<                                  \
-                    BOOST_PP_CAT(ScannerT, N), AttrT                            \
-                >::type                                                         \
-                do_parse_virtual(                                               \
-                    BOOST_PP_CAT(ScannerT, N) const& scan) const                \
-                { return p.parse(scan); }                                       \
-
-        #define BOOST_SPIRIT_ENUM_CONCRETE_PARSERS(z, N, _)                     \
-            template <                                                          \
-                typename ParserT,                                               \
-                BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_INC(N), typename ScannerT),  \
-                typename AttrT                                                  \
-            >                                                                   \
-            struct concrete_parser<                                             \
-                ParserT,                                                        \
-                scanner_list<                                                   \
-                    BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_INC(N), ScannerT)        \
-                >,                                                              \
-                AttrT                                                           \
-            >                                                                   \
-            :   abstract_parser<                                                \
-                    scanner_list<                                               \
-                        BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_INC(N), ScannerT)    \
-                    >,                                                          \
-                    AttrT                                                       \
-                >                                                               \
-            {                                                                   \
-                concrete_parser(ParserT const& p_) : p(p_) {}                   \
-                virtual ~concrete_parser() {}                                   \
-                                                                                \
-                BOOST_PP_REPEAT_ ## z(                                          \
-                    BOOST_PP_INC(N), BOOST_SPIRIT_RULE_ENUM_DOPARSE_C, _)       \
-                                                                                \
-                virtual abstract_parser<                                        \
-                    scanner_list<                                               \
-                        BOOST_PP_ENUM_PARAMS_Z(z, BOOST_PP_INC(N), ScannerT)    \
-                    >,                                                          \
-                    AttrT                                                       \
-                >*                                                              \
-                clone() const                                                   \
-                {                                                               \
-                    return new concrete_parser(p);                              \
-                }                                                               \
-                                                                                \
-                typename ParserT::embed_t p;                                    \
-            };                                                                  \
-
-        BOOST_PP_REPEAT_FROM_TO(1, BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT,
-            BOOST_SPIRIT_ENUM_CONCRETE_PARSERS, _)
-
-        #undef BOOST_SPIRIT_ENUM_CONCRETE_PARSERS
-        #undef BOOST_SPIRIT_RULE_ENUM_DOPARSE_C
-        ///////////////////////////////////////////////////////////////////////
-
-#endif // BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1
-
-    } // namespace impl
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/non_terminal/parser_context.hpp b/contrib/autoboost/boost/spirit/home/classic/core/non_terminal/parser_context.hpp
deleted file mode 100644
index 3d6759055..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/non_terminal/parser_context.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2002-2003 Joel de Guzman
-    Copyright (c) 2002-2003 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_PARSER_CONTEXT_HPP)
-#define BOOST_SPIRIT_PARSER_CONTEXT_HPP
-
-///////////////////////////////////////////////////////////////////////////////
-namespace autoboost
-{
-    namespace spirit
-    {
-    BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  default_parser_context_base class { default context base }
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct default_parser_context_base
-    {
-        template <typename DerivedT>
-        struct aux {};
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  parser_context_base class { base class of all context classes }
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct parser_context_base {};
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  parser_context class { default context }
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct nil_t;
-    template<typename ContextT> struct parser_context_linker;
-
-    template<typename AttrT = nil_t>
-    struct parser_context : parser_context_base
-    {
-        typedef AttrT attr_t;
-        typedef default_parser_context_base base_t;
-        typedef parser_context_linker<parser_context<AttrT> > context_linker_t;
-
-        template <typename ParserT>
-        parser_context(ParserT const&) {}
-
-        template <typename ParserT, typename ScannerT>
-        void
-        pre_parse(ParserT const&, ScannerT const&) {}
-
-        template <typename ResultT, typename ParserT, typename ScannerT>
-        ResultT&
-        post_parse(ResultT& hit, ParserT const&, ScannerT const&)
-        { return hit; }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  context_aux class
-    //
-    //      context_aux<ContextT, DerivedT> is a class derived from the
-    //      ContextT's nested base_t::base<DerivedT> template class. (see
-    //      default_parser_context_base::aux for an example).
-    //
-    //      Basically, this class provides ContextT dependent optional
-    //      functionality to the derived class DerivedT through the CRTP
-    //      idiom (Curiously recurring template pattern).
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename ContextT, typename DerivedT>
-    struct context_aux : public ContextT::base_t::template aux<DerivedT> {};
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  parser_scanner_linker and parser_scanner_linker classes
-    //  { helper templates for the rule extensibility }
-    //
-    //      This classes can be 'overloaded' (defined elsewhere), to plug
-    //      in additional functionality into the non-terminal parsing process.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    #if !defined(BOOST_SPIRIT_PARSER_SCANNER_LINKER_DEFINED)
-    #define BOOST_SPIRIT_PARSER_SCANNER_LINKER_DEFINED
-
-    template<typename ScannerT>
-    struct parser_scanner_linker : public ScannerT
-    {
-        parser_scanner_linker(ScannerT const scan_) : ScannerT(scan_) {}
-    };
-
-    #endif // !defined(BOOST_SPIRIT_PARSER_SCANNER_LINKER_DEFINED)
-
-    //////////////////////////////////
-    #if !defined(BOOST_SPIRIT_PARSER_CONTEXT_LINKER_DEFINED)
-    #define BOOST_SPIRIT_PARSER_CONTEXT_LINKER_DEFINED
-
-    template<typename ContextT>
-    struct parser_context_linker : public ContextT
-    {
-        template <typename ParserT>
-        parser_context_linker(ParserT const& p)
-        : ContextT(p) {}
-
-        template <typename ParserT, typename ScannerT>
-        void pre_parse(ParserT const& p, ScannerT const& scan)
-        { ContextT::pre_parse(p, scan); }
-
-        template <typename ResultT, typename ParserT, typename ScannerT>
-        ResultT&
-        post_parse(ResultT& hit, ParserT const& p, ScannerT const& scan)
-        { return ContextT::post_parse(hit, p, scan); }
-    };
-
-    #endif // !defined(BOOST_SPIRIT_PARSER_CONTEXT_LINKER_DEFINED)
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  BOOST_SPIRIT_CONTEXT_PARSE helper macro
-    //
-    //      The original implementation uses a template class. However, we
-    //      need to lessen the template instantiation depth to help inferior
-    //      compilers that sometimes choke on deep template instantiations.
-    //      The objective is to avoid code redundancy. A macro, in this case
-    //      is an obvious solution. Sigh!
-    //
-    //      WARNING: INTERNAL USE ONLY. NOT FOR PUBLIC CONSUMPTION.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    #define BOOST_SPIRIT_CONTEXT_PARSE(scan, this_, scanner_t, context_t, result_t) \
-            scanner_t scan_wrap(scan);                                              \
-            context_t context_wrap(this_);                                          \
-            context_wrap.pre_parse(this_, scan_wrap);                               \
-            result_t hit = parse_main(scan);                                        \
-            return context_wrap.post_parse(hit, this_, scan_wrap);
-
-    BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-    } // namespace spirit
-} // namespace autoboost
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/non_terminal/parser_id.hpp b/contrib/autoboost/boost/spirit/home/classic/core/non_terminal/parser_id.hpp
deleted file mode 100644
index 87c1d60f1..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/non_terminal/parser_id.hpp
+++ /dev/null
@@ -1,122 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Joel de Guzman
-    Copyright (c) 2001 Daniel Nuffer
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_PARSER_ID_HPP)
-#define BOOST_SPIRIT_PARSER_ID_HPP
-
-#if defined(BOOST_SPIRIT_DEBUG)
-#   include <ostream>
-#endif
-#include <boost/spirit/home/classic/namespace.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  parser_id class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    class parser_id
-    {
-    public:
-                    parser_id()                     : p(0) {}
-        explicit    parser_id(void const* prule)    : p(prule) {}
-                    parser_id(std::size_t l_)       : l(l_) {}
-
-        bool operator==(parser_id const& x) const   { return p == x.p; }
-        bool operator!=(parser_id const& x) const   { return !(*this == x); }
-        bool operator<(parser_id const& x) const    { return p < x.p; }
-        std::size_t to_long() const                 { return l; }
-
-    private:
-
-        union
-        {
-            void const* p;
-            std::size_t l;
-        };
-    };
-
-    #if defined(BOOST_SPIRIT_DEBUG)
-    inline std::ostream&
-    operator<<(std::ostream& out, parser_id const& rid)
-    {
-        out << (unsigned int)rid.to_long();
-        return out;
-    }
-    #endif
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  parser_tag_base class: base class of all parser tags
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct parser_tag_base {};
-    
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  parser_address_tag class: tags a parser with its address
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct parser_address_tag : parser_tag_base
-    {
-        parser_id id() const
-        { return parser_id(reinterpret_cast<std::size_t>(this)); }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  parser_tag class: tags a parser with an integer ID
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <int N>
-    struct parser_tag : parser_tag_base
-    {
-        static parser_id id()
-        { return parser_id(std::size_t(N)); }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  dynamic_parser_tag class: tags a parser with a dynamically changeable
-    //  integer ID
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    class dynamic_parser_tag : public parser_tag_base
-    {
-    public:
-    
-        dynamic_parser_tag() 
-        : tag(std::size_t(0)) {}
-        
-        parser_id 
-        id() const
-        { 
-            return 
-                tag.to_long() 
-                ? tag 
-                : parser_id(reinterpret_cast<std::size_t>(this)); 
-        }
-
-        void set_id(parser_id id_) { tag = id_; } 
-        
-    private:
-    
-        parser_id tag;
-    };
-
-///////////////////////////////////////////////////////////////////////////////
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/non_terminal/rule.hpp b/contrib/autoboost/boost/spirit/home/classic/core/non_terminal/rule.hpp
deleted file mode 100644
index 638452952..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/non_terminal/rule.hpp
+++ /dev/null
@@ -1,175 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_RULE_HPP)
-#define BOOST_SPIRIT_RULE_HPP
-
-#include <boost/static_assert.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Spirit predefined maximum number of simultaneously usable different
-//  scanner types.
-//
-//  This limit defines the maximum number of possible different scanner
-//  types for which a specific rule<> may be used. If this isn't defined, a
-//  rule<> may be used with one scanner type only (multiple scanner support
-//  is disabled).
-//
-///////////////////////////////////////////////////////////////////////////////
-#if !defined(BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT)
-#  define BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT 1
-#endif
-
-//  Ensure a meaningful maximum number of simultaneously usable scanner types
-BOOST_STATIC_ASSERT(BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 0);
-
-#include <boost/scoped_ptr.hpp>
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/non_terminal/impl/rule.ipp>
-
-#if BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1
-#  include <boost/preprocessor/enum_params.hpp>
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-#if BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT > 1
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  scanner_list (a fake scanner)
-    //
-    //      Typically, rules are tied to a specific scanner type and
-    //      a particular rule cannot be used with anything else. Sometimes
-    //      there's a need for rules that can accept more than one scanner
-    //      type. The scanner_list<S0, ...SN> can be used as a template
-    //      parameter to the rule class to specify up to the number of
-    //      scanner types defined by the BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT
-    //      constant. Example:
-    //
-    //          rule<scanner_list<ScannerT0, ScannerT1> > r;
-    //
-    //      *** This feature is available only to compilers that support
-    //      partial template specialization. ***
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <
-        BOOST_PP_ENUM_PARAMS(
-            BOOST_SPIRIT_RULE_SCANNERTYPE_LIMIT,
-            typename ScannerT
-        )
-    >
-    struct scanner_list : scanner_base {};
-
-#endif
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  rule class
-    //
-    //      The rule is a polymorphic parser that acts as a named place-
-    //      holder capturing the behavior of an EBNF expression assigned to
-    //      it.
-    //
-    //      The rule is a template class parameterized by:
-    //
-    //          1) scanner (scanner_t, see scanner.hpp),
-    //          2) the rule's context (context_t, see parser_context.hpp)
-    //          3) an arbitrary tag (tag_t, see parser_id.hpp) that allows
-    //             a rule to be tagged for identification.
-    //
-    //      These template parameters may be specified in any order. The
-    //      scanner will default to scanner<> when it is not specified.
-    //      The context will default to parser_context when not specified.
-    //      The tag will default to parser_address_tag when not specified.
-    //
-    //      The definition of the rule (its right hand side, RHS) held by
-    //      the rule through a scoped_ptr. When a rule is seen in the RHS
-    //      of an assignment or copy construction EBNF expression, the rule
-    //      is held by the LHS rule by reference.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <
-        typename T0 = nil_t
-      , typename T1 = nil_t
-      , typename T2 = nil_t
-    >
-    class rule
-        : public impl::rule_base<
-            rule<T0, T1, T2>
-          , rule<T0, T1, T2> const&
-          , T0, T1, T2>
-    {
-    public:
-
-        typedef rule<T0, T1, T2> self_t;
-        typedef impl::rule_base<
-            self_t
-          , self_t const&
-          , T0, T1, T2>
-        base_t;
-
-        typedef typename base_t::scanner_t scanner_t;
-        typedef typename base_t::attr_t attr_t;
-        typedef impl::abstract_parser<scanner_t, attr_t> abstract_parser_t;
-
-        rule() : ptr() {}
-        ~rule() {}
-
-        rule(rule const& r)
-        : ptr(new impl::concrete_parser<rule, scanner_t, attr_t>(r)) {}
-
-        template <typename ParserT>
-        rule(ParserT const& p)
-        : ptr(new impl::concrete_parser<ParserT, scanner_t, attr_t>(p)) {}
-
-        template <typename ParserT>
-        rule& operator=(ParserT const& p)
-        {
-            ptr.reset(new impl::concrete_parser<ParserT, scanner_t, attr_t>(p));
-            return *this;
-        }
-
-        rule& operator=(rule const& r)
-        {
-            ptr.reset(new impl::concrete_parser<rule, scanner_t, attr_t>(r));
-            return *this;
-        }
-
-        rule<T0, T1, T2>
-        copy() const
-        {
-            return rule<T0, T1, T2>(ptr.get() ? ptr->clone() : 0);
-        }
-
-    private:
-        friend class impl::rule_base_access;
-
-        abstract_parser_t*
-        get() const
-        {
-            return ptr.get();
-        }
-
-        rule(abstract_parser_t* ptr_)
-        : ptr(ptr_) {}
-
-        rule(abstract_parser_t const* ptr_)
-        : ptr(ptr_) {}
-
-        scoped_ptr<abstract_parser_t> ptr;
-    };
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/parser.hpp b/contrib/autoboost/boost/spirit/home/classic/core/parser.hpp
deleted file mode 100644
index 121baa8c1..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/parser.hpp
+++ /dev/null
@@ -1,223 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_PARSER_HPP)
-#define BOOST_SPIRIT_PARSER_HPP
-
-#include <boost/config.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/scanner/scanner.hpp>
-#include <boost/spirit/home/classic/core/nil.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    template <typename ParserT, typename ActionT>
-    class action; //  forward declaration
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  Parser categories
-    //
-    //      Helper template classes to distinguish different types of
-    //      parsers. The following categories are the most generic. More
-    //      specific types may inherit from these. Each parser has a typedef
-    //      parser_category_t that defines its category. By default, if one
-    //      is not specified, it will inherit from the base parser class
-    //      which typedefs its parser_category_t as plain_parser_category.
-    //
-    //          - plain parser has nothing special
-    //          - binary parser has subject a and b (e.g. alternative)
-    //          - unary parser has single subject  (e.g. kleene star)
-    //          - action parser has an attached action parser
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct plain_parser_category {};
-    struct binary_parser_category       : plain_parser_category {};
-    struct unary_parser_category        : plain_parser_category {};
-    struct action_parser_category       : unary_parser_category {};
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  parser_result metafunction
-    //
-    //      Given a scanner type ScannerT and a parser type ParserT, the
-    //      parser_result metafunction provides the actual result of the
-    //      parser.
-    //
-    //  Usage:
-    //
-    //      typename parser_result<ParserT, ScannerT>::type
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename ParserT, typename ScannerT>
-    struct parser_result
-    {
-        typedef typename autoboost::remove_reference<ParserT>::type parser_type;
-        typedef typename parser_type::template result<ScannerT>::type type;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  parser class
-    //
-    //      This class is a protocol base class for all parsers. This is
-    //      essentially an interface contract. The parser class does not
-    //      really know how to parse anything but instead relies on the
-    //      template parameter DerivedT (which obviously is assumed to be a
-    //      subclass) to do the actual parsing.
-    //
-    //      Concrete sub-classes inheriting from parser must have a
-    //      corresponding member function parse(...) compatible with the
-    //      conceptual Interface:
-    //
-    //          template <typename ScannerT>
-    //          RT parse(ScannerT const& scan) const;
-    //
-    //      where RT is the desired return type of the parser and ScannerT
-    //      scan is the scanner (see scanner.hpp).
-    //
-    //      Concrete sub-classes inheriting from parser in most cases need to
-    //      have a nested meta-function result that returns the result type
-    //      of the parser's parse member function, given a scanner type. The
-    //      meta-function has the form:
-    //
-    //          template <typename ScannerT>
-    //          struct result
-    //          {
-    //              typedef RT type;
-    //          };
-    //
-    //      where RT is the desired return type of the parser. This is
-    //      usually, but not always, dependent on the template parameter
-    //      ScannerT. If a parser does not supply a result metafunction, a
-    //      default is provided by the base parser class.
-    //
-    //      The parser's derived() member function returns a reference to the
-    //      parser as its derived object.
-    //
-    //      An operator[] is provided. The operator returns a semantic action
-    //      handler (see actions.hpp).
-    //
-    //      Each parser has a typedef embed_t. This typedef specifies how a
-    //      parser is embedded in a composite (see composite.hpp). By
-    //      default, if one is not specified, the parser will be embedded by
-    //      value. That is, a copy of the parser is placed as a member
-    //      variable of the composite. Most parsers are embedded by value. In
-    //      certain situations however, this is not desirable or possible.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename DerivedT>
-    struct parser
-    {
-        typedef DerivedT                embed_t;
-        typedef DerivedT                derived_t;
-        typedef plain_parser_category   parser_category_t;
-
-        template <typename ScannerT>
-        struct result
-        {
-            typedef typename match_result<ScannerT, nil_t>::type type;
-        };
-
-        DerivedT& derived()
-        {
-            return *static_cast<DerivedT*>(this);
-        }
-
-        DerivedT const& derived() const
-        {
-            return *static_cast<DerivedT const*>(this);
-        }
-
-        template <typename ActionT>
-        action<DerivedT, ActionT>
-        operator[](ActionT const& actor) const
-        {
-            return action<DerivedT, ActionT>(derived(), actor);
-        }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  parse_info
-    //
-    //      Results returned by the free parse functions:
-    //
-    //      stop:   points to the final parse position (i.e parsing
-    //              processed the input up to this point).
-    //
-    //      hit:    true if parsing is successful. This may be full:
-    //              the parser consumed all the input, or partial:
-    //              the parser consumed only a portion of the input.
-    //
-    //      full:   true when we have a full hit (i.e the parser
-    //              consumed all the input.
-    //
-    //      length: The number of characters consumed by the parser.
-    //              This is valid only if we have a successful hit
-    //              (either partial or full).
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename IteratorT = char const*>
-    struct parse_info
-    {
-        IteratorT   stop;
-        bool        hit;
-        bool        full;
-        std::size_t length;
-
-        parse_info(
-            IteratorT const& stop_ = IteratorT(),
-            bool hit_ = false,
-            bool full_ = false,
-            std::size_t length_ = 0)
-        : stop(stop_)
-        , hit(hit_)
-        , full(full_)
-        , length(length_) {}
-
-        template <typename ParseInfoT>
-        parse_info(ParseInfoT const& pi)
-        : stop(pi.stop)
-        , hit(pi.hit)
-        , full(pi.full)
-        , length(pi.length) {}
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  Generic parse function
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename IteratorT, typename DerivedT>
-    parse_info<IteratorT>
-    parse(
-        IteratorT const&        first,
-        IteratorT const&        last,
-        parser<DerivedT> const& p);
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  Parse function for null terminated strings
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename CharT, typename DerivedT>
-    parse_info<CharT const*>
-    parse(
-        CharT const*            str,
-        parser<DerivedT> const& p);
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
-#include <boost/spirit/home/classic/core/impl/parser.ipp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/primitives/impl/numerics.ipp b/contrib/autoboost/boost/spirit/home/classic/core/primitives/impl/numerics.ipp
deleted file mode 100644
index 25d7a137b..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/primitives/impl/numerics.ipp
+++ /dev/null
@@ -1,478 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001-2003 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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_SPIRIT_NUMERICS_IPP
-#define BOOST_SPIRIT_NUMERICS_IPP
-
-#include <boost/config/no_tr1/cmath.hpp>
-#include <limits>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    struct sign_parser; // forward declaration only
-
-    namespace impl
-    {
-        ///////////////////////////////////////////////////////////////////////
-        //
-        //  Extract the prefix sign (- or +)
-        //
-        ///////////////////////////////////////////////////////////////////////
-        template <typename ScannerT>
-        bool
-        extract_sign(ScannerT const& scan, std::size_t& count)
-        {
-            //  Extract the sign
-            count = 0;
-            bool neg = *scan == '-';
-            if (neg || (*scan == '+'))
-            {
-                ++scan;
-                ++count;
-                return neg;
-            }
-
-            return false;
-        }
-
-        ///////////////////////////////////////////////////////////////////////
-        //
-        //  Traits class for radix specific number conversion
-        //
-        //      Convert a digit from character representation, ch, to binary
-        //      representation, returned in val.
-        //      Returns whether the conversion was successful.
-        //
-        //        template<typename CharT> static bool digit(CharT ch, T& val);
-        //
-        ///////////////////////////////////////////////////////////////////////
-        template<const int Radix>
-        struct radix_traits;
-
-        ////////////////////////////////// Binary
-        template<>
-        struct radix_traits<2>
-        {
-            template<typename CharT, typename T>
-            static bool digit(CharT ch, T& val)
-            {
-                val = ch - '0';
-                return ('0' == ch || '1' == ch);
-            }
-        };
-
-        ////////////////////////////////// Octal
-        template<>
-        struct radix_traits<8>
-        {
-            template<typename CharT, typename T>
-            static bool digit(CharT ch, T& val)
-            {
-                val = ch - '0';
-                return ('0' <= ch && ch <= '7');
-            }
-        };
-
-        ////////////////////////////////// Decimal
-        template<>
-        struct radix_traits<10>
-        {
-            template<typename CharT, typename T>
-            static bool digit(CharT ch, T& val)
-            {
-                val = ch - '0';
-                return impl::isdigit_(ch);
-            }
-        };
-
-        ////////////////////////////////// Hexadecimal
-        template<>
-        struct radix_traits<16>
-        {
-            template<typename CharT, typename T>
-            static bool digit(CharT ch, T& val)
-            {
-                if (radix_traits<10>::digit(ch, val))
-                    return true;
-
-                CharT lc = impl::tolower_(ch);
-                if ('a' <= lc && lc <= 'f')
-                {
-                    val = lc - 'a' + 10;
-                    return true;
-                }
-                return false;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////
-        //
-        //      Helper templates for encapsulation of radix specific
-        //      conversion of an input string to an integral value.
-        //
-        //      main entry point:
-        //
-        //          extract_int<Radix, MinDigits, MaxDigits, Accumulate>
-        //              ::f(first, last, n, count);
-        //
-        //          The template parameter Radix represents the radix of the
-        //          number contained in the parsed string. The template
-        //          parameter MinDigits specifies the minimum digits to
-        //          accept. The template parameter MaxDigits specifies the
-        //          maximum digits to parse. A -1 value for MaxDigits will
-        //          make it parse an arbitrarilly large number as long as the
-        //          numeric type can hold it. Accumulate is either
-        //          positive_accumulate<Radix> (default) for parsing positive
-        //          numbers or negative_accumulate<Radix> otherwise.
-        //          Checking is only performed when std::numeric_limits<T>::
-        //          is_specialized is true. Otherwise, there's no way to
-        //          do the check.
-        //
-        //          scan.first and scan.last are iterators as usual (i.e.
-        //          first is mutable and is moved forward when a match is
-        //          found), n is a variable that holds the number (passed by
-        //          reference). The number of parsed characters is added to
-        //          count (also passed by reference)
-        //
-        //      NOTE:
-        //              Returns a non-match, if the number to parse
-        //              overflows (or underflows) the used type.
-        //
-        //      BEWARE:
-        //              the parameters 'n' and 'count' should be properly
-        //              initialized before calling this function.
-        //
-        ///////////////////////////////////////////////////////////////////////
-#if defined(BOOST_MSVC)
-#pragma warning(push) 
-#pragma warning(disable:4127) //conditional expression is constant
-#endif
-        
-        template <typename T, int Radix>
-        struct positive_accumulate
-        {
-            //  Use this accumulator if number is positive
-            static bool add(T& n, T digit)
-            {
-                if (std::numeric_limits<T>::is_specialized)
-                {
-                    static T const max = (std::numeric_limits<T>::max)();
-                    static T const max_div_radix = max/Radix;
-
-                    if (n > max_div_radix)
-                        return false;
-                    n *= Radix;
-
-                    if (n > max - digit)
-                        return false;
-                    n += digit;
-
-                    return true;
-                }
-                else
-                {
-                    n *= Radix;
-                    n += digit;
-                    return true;
-                }
-            }
-        };
-
-        template <typename T, int Radix>
-        struct negative_accumulate
-        {
-            //  Use this accumulator if number is negative
-            static bool add(T& n, T digit)
-            {
-                if (std::numeric_limits<T>::is_specialized)
-                {
-                    typedef std::numeric_limits<T> num_limits;
-                    static T const min =
-                        (!num_limits::is_integer && num_limits::is_signed && num_limits::has_denorm) ?
-                        -(num_limits::max)() : (num_limits::min)();
-                    static T const min_div_radix = min/Radix;
-
-                    if (n < min_div_radix)
-                        return false;
-                    n *= Radix;
-
-                    if (n < min + digit)
-                        return false;
-                    n -= digit;
-
-                    return true;
-                }
-                else
-                {
-                    n *= Radix;
-                    n -= digit;
-                    return true;
-                }
-            }
-        };
-
-        template <int MaxDigits>
-        inline bool allow_more_digits(std::size_t i)
-        {
-            return i < MaxDigits;
-        }
-
-        template <>
-        inline bool allow_more_digits<-1>(std::size_t)
-        {
-            return true;
-        }
-
-        //////////////////////////////////
-        template <
-            int Radix, unsigned MinDigits, int MaxDigits,
-            typename Accumulate
-        >
-        struct extract_int
-        {
-            template <typename ScannerT, typename T>
-            static bool
-            f(ScannerT& scan, T& n, std::size_t& count)
-            {
-                std::size_t i = 0;
-                T digit;
-                while( allow_more_digits<MaxDigits>(i) && !scan.at_end() &&
-                    radix_traits<Radix>::digit(*scan, digit) )
-                {
-                    if (!Accumulate::add(n, digit))
-                        return false; // Overflow
-                    ++i, ++scan, ++count;
-                }
-                return i >= MinDigits;
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////
-        //
-        //  uint_parser_impl class
-        //
-        ///////////////////////////////////////////////////////////////////////
-        template <
-            typename T = unsigned,
-            int Radix = 10,
-            unsigned MinDigits = 1,
-            int MaxDigits = -1
-        >
-        struct uint_parser_impl
-            : parser<uint_parser_impl<T, Radix, MinDigits, MaxDigits> >
-        {
-            typedef uint_parser_impl<T, Radix, MinDigits, MaxDigits> self_t;
-
-            template <typename ScannerT>
-            struct result
-            {
-                typedef typename match_result<ScannerT, T>::type type;
-            };
-
-            template <typename ScannerT>
-            typename parser_result<self_t, ScannerT>::type
-            parse(ScannerT const& scan) const
-            {
-                if (!scan.at_end())
-                {
-                    T n = 0;
-                    std::size_t count = 0;
-                    typename ScannerT::iterator_t save = scan.first;
-                    if (extract_int<Radix, MinDigits, MaxDigits,
-                        positive_accumulate<T, Radix> >::f(scan, n, count))
-                    {
-                        return scan.create_match(count, n, save, scan.first);
-                    }
-                    // return no-match if number overflows
-                }
-                return scan.no_match();
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////
-        //
-        //  int_parser_impl class
-        //
-        ///////////////////////////////////////////////////////////////////////
-        template <
-            typename T = unsigned,
-            int Radix = 10,
-            unsigned MinDigits = 1,
-            int MaxDigits = -1
-        >
-        struct int_parser_impl
-            : parser<int_parser_impl<T, Radix, MinDigits, MaxDigits> >
-        {
-            typedef int_parser_impl<T, Radix, MinDigits, MaxDigits> self_t;
-
-            template <typename ScannerT>
-            struct result
-            {
-                typedef typename match_result<ScannerT, T>::type type;
-            };
-
-            template <typename ScannerT>
-            typename parser_result<self_t, ScannerT>::type
-            parse(ScannerT const& scan) const
-            {
-                typedef extract_int<Radix, MinDigits, MaxDigits,
-                    negative_accumulate<T, Radix> > extract_int_neg_t;
-                typedef extract_int<Radix, MinDigits, MaxDigits,
-                    positive_accumulate<T, Radix> > extract_int_pos_t;
-
-                if (!scan.at_end())
-                {
-                    T n = 0;
-                    std::size_t count = 0;
-                    typename ScannerT::iterator_t save = scan.first;
-
-                    bool hit = impl::extract_sign(scan, count);
-
-                    if (hit)
-                        hit = extract_int_neg_t::f(scan, n, count);
-                    else
-                        hit = extract_int_pos_t::f(scan, n, count);
-
-                    if (hit)
-                        return scan.create_match(count, n, save, scan.first);
-                    else
-                        scan.first = save;
-                    // return no-match if number overflows or underflows
-                }
-                return scan.no_match();
-            }
-        };
-
-        ///////////////////////////////////////////////////////////////////////
-        //
-        //  real_parser_impl class
-        //
-        ///////////////////////////////////////////////////////////////////////
-        template <typename RT, typename T, typename RealPoliciesT>
-        struct real_parser_impl
-        {
-            typedef real_parser_impl<RT, T, RealPoliciesT> self_t;
-
-            template <typename ScannerT>
-            RT parse_main(ScannerT const& scan) const
-            {
-                if (scan.at_end())
-                    return scan.no_match();
-                typename ScannerT::iterator_t save = scan.first;
-
-                typedef typename parser_result<sign_parser, ScannerT>::type
-                    sign_match_t;
-                typedef typename parser_result<chlit<>, ScannerT>::type
-                    exp_match_t;
-
-                sign_match_t    sign_match = RealPoliciesT::parse_sign(scan);
-                std::size_t     count = sign_match ? sign_match.length() : 0;
-                bool            neg = sign_match.has_valid_attribute() ?
-                                    sign_match.value() : false;
-
-                RT              n_match = RealPoliciesT::parse_n(scan);
-                T               n = n_match.has_valid_attribute() ?
-                                    n_match.value() : T(0);
-                bool            got_a_number = n_match;
-                exp_match_t     e_hit;
-
-                if (!got_a_number && !RealPoliciesT::allow_leading_dot)
-                     return scan.no_match();
-                else
-                    count += n_match.length();
-
-                if (neg)
-                    n = -n;
-
-                if (RealPoliciesT::parse_dot(scan))
-                {
-                    //  We got the decimal point. Now we will try to parse
-                    //  the fraction if it is there. If not, it defaults
-                    //  to zero (0) only if we already got a number.
-
-                    if (RT hit = RealPoliciesT::parse_frac_n(scan))
-                    {
-#if !defined(BOOST_NO_STDC_NAMESPACE)
-                        using namespace std;  // allow for ADL to find pow()
-#endif
-                        hit.value(hit.value()
-                            * pow(T(10), T(-hit.length())));
-                        if (neg)
-                            n -= hit.value();
-                        else
-                            n += hit.value();
-                        count += hit.length() + 1;
-
-                    }
-
-                    else if (!got_a_number ||
-                        !RealPoliciesT::allow_trailing_dot)
-                        return scan.no_match();
-
-                    e_hit = RealPoliciesT::parse_exp(scan);
-                }
-                else
-                {
-                    //  We have reached a point where we
-                    //  still haven't seen a number at all.
-                    //  We return early with a no-match.
-                    if (!got_a_number)
-                        return scan.no_match();
-
-                    //  If we must expect a dot and we didn't see
-                    //  an exponent, return early with a no-match.
-                    e_hit = RealPoliciesT::parse_exp(scan);
-                    if (RealPoliciesT::expect_dot && !e_hit)
-                        return scan.no_match();
-                }
-
-                if (e_hit)
-                {
-                    //  We got the exponent prefix. Now we will try to parse the
-                    //  actual exponent. It is an error if it is not there.
-                    if (RT e_n_hit = RealPoliciesT::parse_exp_n(scan))
-                    {
-#if !defined(BOOST_NO_STDC_NAMESPACE)
-                        using namespace std;    // allow for ADL to find pow()
-#endif
-                        n *= pow(T(10), T(e_n_hit.value()));
-                        count += e_n_hit.length() + e_hit.length();
-                    }
-                    else
-                    {
-                        //  Oops, no exponent, return a no-match
-                        return scan.no_match();
-                    }
-                }
-
-                return scan.create_match(count, n, save, scan.first);
-            }
-
-            template <typename ScannerT>
-            static RT parse(ScannerT const& scan)
-            {
-                static self_t this_;
-                return impl::implicit_lexeme_parse<RT>(this_, scan, scan);
-            }
-        };
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop)
-#endif
-
-    }   //  namespace impl
-
-///////////////////////////////////////////////////////////////////////////////
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/primitives/impl/primitives.ipp b/contrib/autoboost/boost/spirit/home/classic/core/primitives/impl/primitives.ipp
deleted file mode 100644
index 97b8ed4b2..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/primitives/impl/primitives.ipp
+++ /dev/null
@@ -1,390 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2003 Martin Wille
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_PRIMITIVES_IPP)
-#define BOOST_SPIRIT_PRIMITIVES_IPP
-
-#include <cctype>
-#if !defined(BOOST_NO_CWCTYPE)
-#include <cwctype>
-#endif
-
-#include <string> // char_traits
-
-#if defined(BOOST_MSVC)
-#  pragma warning (push)
-#  pragma warning(disable:4800)
-#endif
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    template <typename DrivedT> struct char_parser;
-
-    namespace impl
-    {
-        template <typename IteratorT>
-        inline IteratorT
-        get_last(IteratorT first)
-        {
-            while (*first)
-                first++;
-            return first;
-        }
-
-        template<
-            typename RT,
-            typename IteratorT,
-            typename ScannerT>
-        inline RT
-        string_parser_parse(
-            IteratorT str_first,
-            IteratorT str_last,
-            ScannerT& scan)
-        {
-            typedef typename ScannerT::iterator_t iterator_t;
-            iterator_t saved = scan.first;
-            std::size_t slen = str_last - str_first;
-
-            while (str_first != str_last)
-            {
-                if (scan.at_end() || (*str_first != *scan))
-                    return scan.no_match();
-                ++str_first;
-                ++scan;
-            }
-
-            return scan.create_match(slen, nil_t(), saved, scan.first);
-        }
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    // Conversion from char_type to int_type
-    //
-    ///////////////////////////////////////////////////////////////////////////
-
-        //  Use char_traits for char and wchar_t only, as these are the only
-        //  specializations provided in the standard. Other types are on their
-        //  own.
-        //
-        //  For UDT, one may override:
-        //
-        //      isalnum
-        //      isalpha
-        //      iscntrl
-        //      isdigit
-        //      isgraph
-        //      islower
-        //      isprint
-        //      ispunct
-        //      isspace
-        //      isupper
-        //      isxdigit
-        //      isblank
-        //      isupper
-        //      tolower
-        //      toupper
-        //
-        //  in a namespace suitable for Argument Dependent lookup or in
-        //  namespace std (disallowed by the standard).
-
-        template <typename CharT>
-        struct char_type_char_traits_helper
-        {
-            typedef CharT char_type;
-            typedef typename std::char_traits<CharT>::int_type int_type;
-
-            static int_type to_int_type(CharT c)
-            {
-                return std::char_traits<CharT>::to_int_type(c);
-            }
-
-            static char_type to_char_type(int_type i)
-            {
-                return std::char_traits<CharT>::to_char_type(i);
-            }
-        };
-
-        template <typename CharT>
-        struct char_traits_helper
-        {
-            typedef CharT char_type;
-            typedef CharT int_type;
-
-            static CharT & to_int_type(CharT & c)
-            {
-                return c;
-            }
-
-            static CharT & to_char_type(CharT & c)
-            {
-                return c;
-            }
-        };
-
-        template <>
-        struct char_traits_helper<char>
-            : char_type_char_traits_helper<char>
-        {
-        };
-
-#if !defined(BOOST_NO_CWCTYPE)
-
-        template <>
-        struct char_traits_helper<wchar_t>
-            : char_type_char_traits_helper<wchar_t>
-        {
-        };
-
-#endif
-
-        template <typename CharT>
-        inline typename char_traits_helper<CharT>::int_type
-        to_int_type(CharT c)
-        {
-            return char_traits_helper<CharT>::to_int_type(c);
-        }
-
-        template <typename CharT>
-        inline CharT
-        to_char_type(typename char_traits_helper<CharT>::int_type c)
-        {
-            return char_traits_helper<CharT>::to_char_type(c);
-        }
-
-        ///////////////////////////////////////////////////////////////////////
-        //
-        //  Convenience functions
-        //
-        ///////////////////////////////////////////////////////////////////////
-
-        template <typename CharT>
-        inline bool
-        isalnum_(CharT c)
-        {
-            using namespace std;
-            return isalnum(to_int_type(c)) ? true : false;
-        }
-
-        template <typename CharT>
-        inline bool
-        isalpha_(CharT c)
-        {
-            using namespace std;
-            return isalpha(to_int_type(c)) ? true : false;
-        }
-
-        template <typename CharT>
-        inline bool
-        iscntrl_(CharT c)
-        {
-            using namespace std;
-            return iscntrl(to_int_type(c)) ? true : false;
-        }
-
-        template <typename CharT>
-        inline bool
-        isdigit_(CharT c)
-        {
-            using namespace std;
-            return isdigit(to_int_type(c)) ? true : false;
-        }
-
-        template <typename CharT>
-        inline bool
-        isgraph_(CharT c)
-        {
-            using namespace std;
-            return isgraph(to_int_type(c)) ? true : false;
-        }
-
-        template <typename CharT>
-        inline bool
-        islower_(CharT c)
-        {
-            using namespace std;
-            return islower(to_int_type(c)) ? true : false;
-        }
-
-        template <typename CharT>
-        inline bool
-        isprint_(CharT c)
-        {
-            using namespace std;
-            return isprint(to_int_type(c)) ? true : false;
-        }
-
-        template <typename CharT>
-        inline bool
-        ispunct_(CharT c)
-        {
-            using namespace std;
-            return ispunct(to_int_type(c)) ? true : false;
-        }
-
-        template <typename CharT>
-        inline bool
-        isspace_(CharT c)
-        {
-            using namespace std;
-            return isspace(to_int_type(c)) ? true : false;
-        }
-
-        template <typename CharT>
-        inline bool
-        isupper_(CharT c)
-        {
-            using namespace std;
-            return isupper(to_int_type(c)) ? true : false;
-        }
-
-        template <typename CharT>
-        inline bool
-        isxdigit_(CharT c)
-        {
-            using namespace std;
-            return isxdigit(to_int_type(c)) ? true : false;
-        }
-
-        template <typename CharT>
-        inline bool
-        isblank_(CharT c)
-        {
-            return (c == ' ' || c == '\t');
-        }
-
-        template <typename CharT>
-        inline CharT
-        tolower_(CharT c)
-        {
-            using namespace std;
-            return to_char_type<CharT>(tolower(to_int_type(c)));
-        }
-
-        template <typename CharT>
-        inline CharT
-        toupper_(CharT c)
-        {
-            using namespace std;
-            return to_char_type<CharT>(toupper(to_int_type(c)));
-        }
-
-#if !defined(BOOST_NO_CWCTYPE)
-
-        inline bool
-        isalnum_(wchar_t c)
-        {
-            using namespace std;
-            return iswalnum(to_int_type(c)) ? true : false;
-        }
-
-        inline bool
-        isalpha_(wchar_t c)
-        {
-            using namespace std;
-            return iswalpha(to_int_type(c)) ? true : false;
-        }
-
-        inline bool
-        iscntrl_(wchar_t c)
-        {
-            using namespace std;
-            return iswcntrl(to_int_type(c)) ? true : false;
-        }
-
-        inline bool
-        isdigit_(wchar_t c)
-        {
-            using namespace std;
-            return iswdigit(to_int_type(c)) ? true : false;
-        }
-
-        inline bool
-        isgraph_(wchar_t c)
-        {
-            using namespace std;
-            return iswgraph(to_int_type(c)) ? true : false;
-        }
-
-        inline bool
-        islower_(wchar_t c)
-        {
-            using namespace std;
-            return iswlower(to_int_type(c)) ? true : false;
-        }
-
-        inline bool
-        isprint_(wchar_t c)
-        {
-            using namespace std;
-            return iswprint(to_int_type(c)) ? true : false;
-        }
-
-        inline bool
-        ispunct_(wchar_t c)
-        {
-            using namespace std;
-            return iswpunct(to_int_type(c)) ? true : false;
-        }
-
-        inline bool
-        isspace_(wchar_t c)
-        {
-            using namespace std;
-            return iswspace(to_int_type(c)) ? true : false;
-        }
-
-        inline bool
-        isupper_(wchar_t c)
-        {
-            using namespace std;
-            return iswupper(to_int_type(c)) ? true : false;
-        }
-
-        inline bool
-        isxdigit_(wchar_t c)
-        {
-            using namespace std;
-            return iswxdigit(to_int_type(c)) ? true : false;
-        }
-
-        inline bool
-        isblank_(wchar_t c)
-        {
-            return (c == L' ' || c == L'\t');
-        }
-
-        inline wchar_t
-        tolower_(wchar_t c)
-        {
-            using namespace std;
-            return to_char_type<wchar_t>(towlower(to_int_type(c)));
-        }
-
-        inline wchar_t
-        toupper_(wchar_t c)
-        {
-            using namespace std;
-            return to_char_type<wchar_t>(towupper(to_int_type(c)));
-        }
-
-#endif // !defined(BOOST_NO_CWCTYPE)
-
-}
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit::impl
-
-#ifdef BOOST_MSVC
-#pragma warning (pop)
-#endif
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/primitives/numerics.hpp b/contrib/autoboost/boost/spirit/home/classic/core/primitives/numerics.hpp
deleted file mode 100644
index 72c8c0ebf..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/primitives/numerics.hpp
+++ /dev/null
@@ -1,289 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2001-2003 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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_SPIRIT_NUMERICS_HPP
-#define BOOST_SPIRIT_NUMERICS_HPP
-
-#include <boost/config.hpp>
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/composite/directives.hpp>
-
-#include <boost/spirit/home/classic/core/primitives/numerics_fwd.hpp>
-#include <boost/spirit/home/classic/core/primitives/impl/numerics.ipp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  uint_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <
-        typename T, 
-        int Radix, 
-        unsigned MinDigits,
-        int MaxDigits
-    >
-    struct uint_parser : parser<uint_parser<T, Radix, MinDigits, MaxDigits> >
-    {
-        typedef uint_parser<T, Radix, MinDigits, MaxDigits> self_t;
-    
-        template <typename ScannerT>
-        struct result
-        {
-            typedef typename match_result<ScannerT, T>::type type;
-        };
-        
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef impl::uint_parser_impl<T, Radix, MinDigits, MaxDigits> impl_t;
-            typedef typename parser_result<impl_t, ScannerT>::type result_t;
-            return impl::contiguous_parser_parse<result_t>(impl_t(), scan, scan);
-        }
-    };
-    
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  int_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <
-        typename T,
-        int Radix,
-        unsigned MinDigits,
-        int MaxDigits
-    >
-    struct int_parser : parser<int_parser<T, Radix, MinDigits, MaxDigits> >
-    {
-        typedef int_parser<T, Radix, MinDigits, MaxDigits> self_t;
-    
-        template <typename ScannerT>
-        struct result
-        {
-            typedef typename match_result<ScannerT, T>::type type;
-        };
-        
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef impl::int_parser_impl<T, Radix, MinDigits, MaxDigits> impl_t;
-            typedef typename parser_result<impl_t, ScannerT>::type result_t;
-            return impl::contiguous_parser_parse<result_t>(impl_t(), scan, scan);
-        }
-    };
-    
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  uint_parser/int_parser instantiations
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    int_parser<int> const
-        int_p   = int_parser<int>();
-    
-    uint_parser<unsigned> const
-        uint_p  = uint_parser<unsigned>();
-    
-    uint_parser<unsigned, 2> const
-        bin_p   = uint_parser<unsigned, 2>();
-    
-    uint_parser<unsigned, 8> const
-        oct_p   = uint_parser<unsigned, 8>();
-    
-    uint_parser<unsigned, 16> const
-        hex_p   = uint_parser<unsigned, 16>();
-    
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  sign_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    namespace impl
-    {
-        //  Utility to extract the prefix sign ('-' | '+')
-        template <typename ScannerT>
-        bool extract_sign(ScannerT const& scan, std::size_t& count);
-    }
-    
-    struct sign_parser : public parser<sign_parser>
-    {
-        typedef sign_parser self_t;
-
-        template <typename ScannerT>
-        struct result 
-        {
-            typedef typename match_result<ScannerT, bool>::type type;
-        };
-
-        sign_parser() {}
-    
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            if (!scan.at_end())
-            {
-                std::size_t length;
-                typename ScannerT::iterator_t save(scan.first);
-                bool neg = impl::extract_sign(scan, length);
-                if (length)
-                    return scan.create_match(1, neg, save, scan.first);
-            }
-            return scan.no_match();
-        }
-    };
-    
-    sign_parser const sign_p = sign_parser();
-    
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  default real number policies
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename T>
-    struct ureal_parser_policies
-    {
-        // trailing dot policy suggested suggested by Gustavo Guerra
-        BOOST_STATIC_CONSTANT(bool, allow_leading_dot = true);
-        BOOST_STATIC_CONSTANT(bool, allow_trailing_dot = true);
-        BOOST_STATIC_CONSTANT(bool, expect_dot = false);
-    
-        typedef uint_parser<T, 10, 1, -1>   uint_parser_t;
-        typedef int_parser<T, 10, 1, -1>    int_parser_t;
-    
-        template <typename ScannerT>
-        static typename match_result<ScannerT, nil_t>::type
-        parse_sign(ScannerT& scan)
-        { 
-            return scan.no_match(); 
-        }
-    
-        template <typename ScannerT>
-        static typename parser_result<uint_parser_t, ScannerT>::type
-        parse_n(ScannerT& scan)
-        { 
-            return uint_parser_t().parse(scan); 
-        }
-    
-        template <typename ScannerT>
-        static typename parser_result<chlit<>, ScannerT>::type
-        parse_dot(ScannerT& scan)
-        { 
-            return ch_p('.').parse(scan); 
-        }
-    
-        template <typename ScannerT>
-        static typename parser_result<uint_parser_t, ScannerT>::type
-        parse_frac_n(ScannerT& scan)
-        { 
-            return uint_parser_t().parse(scan); 
-        }
-    
-        template <typename ScannerT>
-        static typename parser_result<chlit<>, ScannerT>::type
-        parse_exp(ScannerT& scan)
-        { 
-            return as_lower_d['e'].parse(scan); 
-        }
-    
-        template <typename ScannerT>
-        static typename parser_result<int_parser_t, ScannerT>::type
-        parse_exp_n(ScannerT& scan)
-        { 
-            return int_parser_t().parse(scan); 
-        }
-    };
-    
-    template <typename T>
-    struct real_parser_policies : public ureal_parser_policies<T>
-    {
-        template <typename ScannerT>
-        static typename parser_result<sign_parser, ScannerT>::type
-        parse_sign(ScannerT& scan)
-        { 
-            return sign_p.parse(scan); 
-        }
-    };
-    
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  real_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <
-        typename T,
-        typename RealPoliciesT
-    >
-    struct real_parser
-    :   public parser<real_parser<T, RealPoliciesT> >
-    {
-        typedef real_parser<T, RealPoliciesT> self_t;
-    
-        template <typename ScannerT>
-        struct result
-        {
-            typedef typename match_result<ScannerT, T>::type type;
-        };
-    
-        real_parser() {}
-    
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            return impl::real_parser_impl<result_t, T, RealPoliciesT>::parse(scan);
-        }
-    };
-    
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  real_parser instantiations
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    real_parser<double, ureal_parser_policies<double> > const
-        ureal_p     = real_parser<double, ureal_parser_policies<double> >();
-    
-    real_parser<double, real_parser_policies<double> > const
-        real_p      = real_parser<double, real_parser_policies<double> >();
-    
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  strict reals (do not allow plain integers (no decimal point))
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename T>
-    struct strict_ureal_parser_policies : public ureal_parser_policies<T>
-    {
-        BOOST_STATIC_CONSTANT(bool, expect_dot = true);
-    };
-    
-    template <typename T>
-    struct strict_real_parser_policies : public real_parser_policies<T>
-    {
-        BOOST_STATIC_CONSTANT(bool, expect_dot = true);
-    };
-    
-    real_parser<double, strict_ureal_parser_policies<double> > const
-        strict_ureal_p
-            = real_parser<double, strict_ureal_parser_policies<double> >();
-    
-    real_parser<double, strict_real_parser_policies<double> > const
-        strict_real_p
-            = real_parser<double, strict_real_parser_policies<double> >();
-    
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/primitives/numerics_fwd.hpp b/contrib/autoboost/boost/spirit/home/classic/core/primitives/numerics_fwd.hpp
deleted file mode 100644
index f05bfe589..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/primitives/numerics_fwd.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-/*=============================================================================
-    Copyright (C) 2006 Tobias Schwinger
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_NUMERICS_FWD_HPP)
-#   define BOOST_SPIRIT_NUMERICS_FWD_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  uint_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <
-        typename T = unsigned,
-        int Radix = 10,
-        unsigned MinDigits = 1,
-        int MaxDigits = -1
-    >
-    struct uint_parser;
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  int_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <
-        typename T = unsigned,
-        int Radix = 10,
-        unsigned MinDigits = 1,
-        int MaxDigits = -1
-    >
-    struct int_parser;
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  sign_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct sign_parser;
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  default real number policies
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename T>
-    struct ureal_parser_policies;
-
-    template <typename T>
-    struct real_parser_policies;
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  real_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <
-        typename T = double,
-        typename RealPoliciesT = ureal_parser_policies<T>
-    >
-    struct real_parser;
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  strict reals (do not allow plain integers (no decimal point))
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename T>
-    struct strict_ureal_parser_policies;
-
-    template <typename T>
-    struct strict_real_parser_policies;
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/primitives/primitives.hpp b/contrib/autoboost/boost/spirit/home/classic/core/primitives/primitives.hpp
deleted file mode 100644
index 53e7794b6..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/primitives/primitives.hpp
+++ /dev/null
@@ -1,654 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    Copyright (c) 2003 Martin Wille
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_PRIMITIVES_HPP)
-#define BOOST_SPIRIT_PRIMITIVES_HPP
-
-#include <boost/ref.hpp>
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/assert.hpp>
-#include <boost/spirit/home/classic/core/parser.hpp>
-#include <boost/spirit/home/classic/core/composite/impl/directives.ipp>
-#include <boost/spirit/home/classic/core/primitives/impl/primitives.ipp>
-
-#ifdef BOOST_MSVC
-#pragma warning (push)
-#pragma warning(disable : 4512)
-#endif
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  char_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename DerivedT>
-    struct char_parser : public parser<DerivedT>
-    {
-        typedef DerivedT self_t;
-        template <typename ScannerT>
-        struct result
-        {
-            typedef typename match_result<
-                ScannerT,
-                typename ScannerT::value_t
-            >::type type;
-        };
-
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            typedef typename ScannerT::value_t value_t;
-            typedef typename ScannerT::iterator_t iterator_t;
-
-            if (!scan.at_end())
-            {
-                value_t ch = *scan;
-                if (this->derived().test(ch))
-                {
-                    iterator_t save(scan.first);
-                    ++scan.first;
-                    return scan.create_match(1, ch, save, scan.first);
-                }
-            }
-            return scan.no_match();
-        }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  negation of char_parsers
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename PositiveT>
-    struct negated_char_parser
-    : public char_parser<negated_char_parser<PositiveT> >
-    {
-        typedef negated_char_parser<PositiveT> self_t;
-        typedef PositiveT positive_t;
-
-        negated_char_parser(positive_t const& p)
-        : positive(p.derived()) {}
-
-        template <typename T>
-        bool test(T ch) const
-        {
-            return !positive.test(ch);
-        }
-
-        positive_t const positive;
-    };
-
-    template <typename ParserT>
-    inline negated_char_parser<ParserT>
-    operator~(char_parser<ParserT> const& p)
-    {
-        return negated_char_parser<ParserT>(p.derived());
-    }
-
-    template <typename ParserT>
-    inline ParserT
-    operator~(negated_char_parser<ParserT> const& n)
-    {
-        return n.positive;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  chlit class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename CharT = char>
-    struct chlit : public char_parser<chlit<CharT> >
-    {
-        chlit(CharT ch_)
-        : ch(ch_) {}
-
-        template <typename T>
-        bool test(T ch_) const
-        {
-            return ch_ == ch;
-        }
-
-        CharT   ch;
-    };
-
-    template <typename CharT>
-    inline chlit<CharT>
-    ch_p(CharT ch)
-    {
-        return chlit<CharT>(ch);
-    }
-
-    // This should take care of ch_p("a") "bugs"
-    template <typename CharT, std::size_t N>
-    inline chlit<CharT>
-    ch_p(CharT const (& str)[N])
-    {
-        //  ch_p's argument should be a single character or a null-terminated
-        //  string with a single character
-        BOOST_STATIC_ASSERT(N < 3);
-        return chlit<CharT>(str[0]);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  range class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename CharT = char>
-    struct range : public char_parser<range<CharT> >
-    {
-        range(CharT first_, CharT last_)
-        : first(first_), last(last_)
-        {
-            BOOST_SPIRIT_ASSERT(!(last < first));
-        }
-
-        template <typename T>
-        bool test(T ch) const
-        {
-            return !(CharT(ch) < first) && !(last < CharT(ch));
-        }
-
-        CharT   first;
-        CharT   last;
-    };
-
-    template <typename CharT>
-    inline range<CharT>
-    range_p(CharT first, CharT last)
-    {
-        return range<CharT>(first, last);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  chseq class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename IteratorT = char const*>
-    class chseq : public parser<chseq<IteratorT> >
-    {
-    public:
-
-        typedef chseq<IteratorT> self_t;
-
-        chseq(IteratorT first_, IteratorT last_)
-        : first(first_), last(last_) {}
-
-        chseq(IteratorT first_)
-        : first(first_), last(impl::get_last(first_)) {}
-
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename autoboost::unwrap_reference<IteratorT>::type striter_t;
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            return impl::string_parser_parse<result_t>(
-                striter_t(first),
-                striter_t(last),
-                scan);
-        }
-
-    private:
-
-        IteratorT first;
-        IteratorT last;
-    };
-
-    template <typename CharT>
-    inline chseq<CharT const*>
-    chseq_p(CharT const* str)
-    {
-        return chseq<CharT const*>(str);
-    }
-
-    template <typename IteratorT>
-    inline chseq<IteratorT>
-    chseq_p(IteratorT first, IteratorT last)
-    {
-        return chseq<IteratorT>(first, last);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  strlit class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename IteratorT = char const*>
-    class strlit : public parser<strlit<IteratorT> >
-    {
-    public:
-
-        typedef strlit<IteratorT> self_t;
-
-        strlit(IteratorT first, IteratorT last)
-        : seq(first, last) {}
-
-        strlit(IteratorT first)
-        : seq(first) {}
-
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typedef typename parser_result<self_t, ScannerT>::type result_t;
-            return impl::contiguous_parser_parse<result_t>
-                (seq, scan, scan);
-        }
-
-    private:
-
-        chseq<IteratorT> seq;
-    };
-
-    template <typename CharT>
-    inline strlit<CharT const*>
-    str_p(CharT const* str)
-    {
-        return strlit<CharT const*>(str);
-    }
-
-    template <typename CharT>
-    inline strlit<CharT *>
-    str_p(CharT * str)
-    {
-        return strlit<CharT *>(str);
-    }
-
-    template <typename IteratorT>
-    inline strlit<IteratorT>
-    str_p(IteratorT first, IteratorT last)
-    {
-        return strlit<IteratorT>(first, last);
-    }
-
-    // This should take care of str_p('a') "bugs"
-    template <typename CharT>
-    inline chlit<CharT>
-    str_p(CharT ch)
-    {
-        return chlit<CharT>(ch);
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  nothing_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct nothing_parser : public parser<nothing_parser>
-    {
-        typedef nothing_parser self_t;
-
-        nothing_parser() {}
-
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            return scan.no_match();
-        }
-    };
-
-    nothing_parser const nothing_p = nothing_parser();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  anychar_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct anychar_parser : public char_parser<anychar_parser>
-    {
-        typedef anychar_parser self_t;
-
-        anychar_parser() {}
-
-        template <typename CharT>
-        bool test(CharT) const
-        {
-            return true;
-        }
-    };
-
-    anychar_parser const anychar_p = anychar_parser();
-
-    inline nothing_parser
-    operator~(anychar_parser)
-    {
-        return nothing_p;
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  alnum_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct alnum_parser : public char_parser<alnum_parser>
-    {
-        typedef alnum_parser self_t;
-
-        alnum_parser() {}
-
-        template <typename CharT>
-        bool test(CharT ch) const
-        {
-            return impl::isalnum_(ch);
-        }
-    };
-
-    alnum_parser const alnum_p = alnum_parser();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  alpha_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct alpha_parser : public char_parser<alpha_parser>
-    {
-        typedef alpha_parser self_t;
-
-        alpha_parser() {}
-
-        template <typename CharT>
-        bool test(CharT ch) const
-        {
-            return impl::isalpha_(ch);
-        }
-    };
-
-    alpha_parser const alpha_p = alpha_parser();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  cntrl_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct cntrl_parser : public char_parser<cntrl_parser>
-    {
-        typedef cntrl_parser self_t;
-
-        cntrl_parser() {}
-
-        template <typename CharT>
-        bool test(CharT ch) const
-        {
-            return impl::iscntrl_(ch);
-        }
-    };
-
-    cntrl_parser const cntrl_p = cntrl_parser();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  digit_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct digit_parser : public char_parser<digit_parser>
-    {
-        typedef digit_parser self_t;
-
-        digit_parser() {}
-
-        template <typename CharT>
-        bool test(CharT ch) const
-        {
-            return impl::isdigit_(ch);
-        }
-    };
-
-    digit_parser const digit_p = digit_parser();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  graph_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct graph_parser : public char_parser<graph_parser>
-    {
-        typedef graph_parser self_t;
-
-        graph_parser() {}
-
-        template <typename CharT>
-        bool test(CharT ch) const
-        {
-            return impl::isgraph_(ch);
-        }
-    };
-
-    graph_parser const graph_p = graph_parser();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  lower_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct lower_parser : public char_parser<lower_parser>
-    {
-        typedef lower_parser self_t;
-
-        lower_parser() {}
-
-        template <typename CharT>
-        bool test(CharT ch) const
-        {
-            return impl::islower_(ch);
-        }
-    };
-
-    lower_parser const lower_p = lower_parser();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  print_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct print_parser : public char_parser<print_parser>
-    {
-        typedef print_parser self_t;
-
-        print_parser() {}
-
-        template <typename CharT>
-        bool test(CharT ch) const
-        {
-            return impl::isprint_(ch);
-        }
-    };
-
-    print_parser const print_p = print_parser();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  punct_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct punct_parser : public char_parser<punct_parser>
-    {
-        typedef punct_parser self_t;
-
-        punct_parser() {}
-
-        template <typename CharT>
-        bool test(CharT ch) const
-        {
-            return impl::ispunct_(ch);
-        }
-    };
-
-    punct_parser const punct_p = punct_parser();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  blank_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct blank_parser : public char_parser<blank_parser>
-    {
-        typedef blank_parser self_t;
-
-        blank_parser() {}
-
-        template <typename CharT>
-        bool test(CharT ch) const
-        {
-            return impl::isblank_(ch);
-        }
-    };
-
-    blank_parser const blank_p = blank_parser();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  space_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct space_parser : public char_parser<space_parser>
-    {
-        typedef space_parser self_t;
-
-        space_parser() {}
-
-        template <typename CharT>
-        bool test(CharT ch) const
-        {
-            return impl::isspace_(ch);
-        }
-    };
-
-    space_parser const space_p = space_parser();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  upper_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct upper_parser : public char_parser<upper_parser>
-    {
-        typedef upper_parser self_t;
-
-        upper_parser() {}
-
-        template <typename CharT>
-        bool test(CharT ch) const
-        {
-            return impl::isupper_(ch);
-        }
-    };
-
-    upper_parser const upper_p = upper_parser();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  xdigit_parser class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct xdigit_parser : public char_parser<xdigit_parser>
-    {
-        typedef xdigit_parser self_t;
-
-        xdigit_parser() {}
-
-        template <typename CharT>
-        bool test(CharT ch) const
-        {
-            return impl::isxdigit_(ch);
-        }
-    };
-
-    xdigit_parser const xdigit_p = xdigit_parser();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  eol_parser class (contributed by Martin Wille)
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct eol_parser : public parser<eol_parser>
-    {
-        typedef eol_parser self_t;
-
-        eol_parser() {}
-
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            typename ScannerT::iterator_t save = scan.first;
-            std::size_t len = 0;
-
-            if (!scan.at_end() && *scan == '\r')    // CR
-            {
-                ++scan.first;
-                ++len;
-            }
-
-            // Don't call skipper here
-            if (scan.first != scan.last && *scan == '\n')    // LF
-            {
-                ++scan.first;
-                ++len;
-            }
-
-            if (len)
-                return scan.create_match(len, nil_t(), save, scan.first);
-            return scan.no_match();
-        }
-    };
-
-    eol_parser const eol_p = eol_parser();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  end_parser class (suggested by Markus Schoepflin)
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct end_parser : public parser<end_parser>
-    {
-        typedef end_parser self_t;
-
-        end_parser() {}
-
-        template <typename ScannerT>
-        typename parser_result<self_t, ScannerT>::type
-        parse(ScannerT const& scan) const
-        {
-            if (scan.at_end())
-                return scan.empty_match();
-            return scan.no_match();
-        }
-    };
-
-    end_parser const end_p = end_parser();
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  the pizza_p parser :-)
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    inline strlit<char const*> const
-    pizza_p(char const* your_favorite_pizza)
-    {
-        return your_favorite_pizza;
-    }
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#ifdef BOOST_MSVC
-#pragma warning (pop)
-#endif
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/safe_bool.hpp b/contrib/autoboost/boost/spirit/home/classic/core/safe_bool.hpp
deleted file mode 100644
index ab8e51de9..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/safe_bool.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_SAFE_BOOL_HPP)
-#define BOOST_SPIRIT_SAFE_BOOL_HPP
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/spirit/home/classic/namespace.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    namespace impl
-    {
-        template <typename T>
-        struct no_base {};
-
-        template <typename T>
-        struct safe_bool_impl
-        {
-#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
-            void stub(T*) {};
-            typedef void (safe_bool_impl::*type)(T*);
-#else
-            typedef T* TP; // workaround to make parsing easier
-            TP stub;
-            typedef TP safe_bool_impl::*type;
-#endif
-        };
-    }
-
-    template <typename DerivedT, typename BaseT = impl::no_base<DerivedT> >
-    struct safe_bool : BaseT
-    {
-    private:
-        typedef impl::safe_bool_impl<DerivedT> impl_t;
-        typedef typename impl_t::type bool_type;
-
-    public:
-        operator bool_type() const
-        {
-            return static_cast<const DerivedT*>(this)->operator_bool() ?
-                &impl_t::stub : 0;
-        }
-
-        operator bool_type()
-        {
-            return static_cast<DerivedT*>(this)->operator_bool() ?
-                &impl_t::stub : 0;
-        }
-    };
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}}
-
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/scanner/impl/skipper.ipp b/contrib/autoboost/boost/spirit/home/classic/core/scanner/impl/skipper.ipp
deleted file mode 100644
index 5db89a77e..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/scanner/impl/skipper.ipp
+++ /dev/null
@@ -1,181 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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)
-============================================================================*/
-#if !defined(BOOST_SPIRIT_SKIPPER_IPP)
-#define BOOST_SPIRIT_SKIPPER_IPP
-
-///////////////////////////////////////////////////////////////////////////////
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    struct space_parser;
-    template <typename BaseT>
-    struct no_skipper_iteration_policy;
-
-    namespace impl
-    {
-        template <typename ST, typename ScannerT, typename BaseT>
-        inline void
-        skipper_skip(
-            ST const& s,
-            ScannerT const& scan,
-            skipper_iteration_policy<BaseT> const&)
-        {
-            typedef scanner_policies<
-                no_skipper_iteration_policy<
-                    BOOST_DEDUCED_TYPENAME ScannerT::iteration_policy_t>,
-                BOOST_DEDUCED_TYPENAME ScannerT::match_policy_t,
-                BOOST_DEDUCED_TYPENAME ScannerT::action_policy_t
-            > policies_t;
-
-            scanner<BOOST_DEDUCED_TYPENAME ScannerT::iterator_t, policies_t>
-                scan2(scan.first, scan.last, policies_t(scan));
-            typedef typename ScannerT::iterator_t iterator_t;
-
-            for (;;)
-            {
-                iterator_t save = scan.first;
-                if (!s.parse(scan2))
-                {
-                    scan.first = save;
-                    break;
-                }
-            }
-        }
-
-        template <typename ST, typename ScannerT, typename BaseT>
-        inline void
-        skipper_skip(
-            ST const& s,
-            ScannerT const& scan,
-            no_skipper_iteration_policy<BaseT> const&)
-        {
-            for (;;)
-            {
-                typedef typename ScannerT::iterator_t iterator_t;
-                iterator_t save = scan.first;
-                if (!s.parse(scan))
-                {
-                    scan.first = save;
-                    break;
-                }
-            }
-        }
-
-        template <typename ST, typename ScannerT>
-        inline void
-        skipper_skip(
-            ST const& s,
-            ScannerT const& scan,
-            iteration_policy const&)
-        {
-            for (;;)
-            {
-                typedef typename ScannerT::iterator_t iterator_t;
-                iterator_t save = scan.first;
-                if (!s.parse(scan))
-                {
-                    scan.first = save;
-                    break;
-                }
-            }
-        }
-
-        template <typename SkipT>
-        struct phrase_parser
-        {
-            template <typename IteratorT, typename ParserT>
-            static parse_info<IteratorT>
-            parse(
-                IteratorT const&    first_,
-                IteratorT const&    last,
-                ParserT const&      p,
-                SkipT const&        skip)
-            {
-                typedef skip_parser_iteration_policy<SkipT> iter_policy_t;
-                typedef scanner_policies<iter_policy_t> scanner_policies_t;
-                typedef scanner<IteratorT, scanner_policies_t> scanner_t;
-
-                iter_policy_t iter_policy(skip);
-                scanner_policies_t policies(iter_policy);
-                IteratorT first = first_;
-                scanner_t scan(first, last, policies);
-                match<nil_t> hit = p.parse(scan);
-                return parse_info<IteratorT>(
-                    first, hit, hit && (first == last),
-                    hit.length());
-            }
-        };
-
-        template <>
-        struct phrase_parser<space_parser>
-        {
-            template <typename IteratorT, typename ParserT>
-            static parse_info<IteratorT>
-            parse(
-                IteratorT const&    first_,
-                IteratorT const&    last,
-                ParserT const&      p,
-                space_parser const&)
-            {
-                typedef skipper_iteration_policy<> iter_policy_t;
-                typedef scanner_policies<iter_policy_t> scanner_policies_t;
-                typedef scanner<IteratorT, scanner_policies_t> scanner_t;
-
-                IteratorT first = first_;
-                scanner_t scan(first, last);
-                match<nil_t> hit = p.parse(scan);
-                return parse_info<IteratorT>(
-                    first, hit, hit && (first == last),
-                    hit.length());
-            }
-        };
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  Free parse functions using the skippers
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename IteratorT, typename ParserT, typename SkipT>
-    inline parse_info<IteratorT>
-    parse(
-        IteratorT const&        first,
-        IteratorT const&        last,
-        parser<ParserT> const&  p,
-        parser<SkipT> const&    skip)
-    {
-        return impl::phrase_parser<SkipT>::
-            parse(first, last, p.derived(), skip.derived());
-    }
-    
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  Parse function for null terminated strings using the skippers
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename CharT, typename ParserT, typename SkipT>
-    inline parse_info<CharT const*>
-    parse(
-        CharT const*            str,
-        parser<ParserT> const&  p,
-        parser<SkipT> const&    skip)
-    {
-        CharT const* last = str;
-        while (*last)
-            last++;
-        return parse(str, last, p, skip);
-    }
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/scanner/scanner.hpp b/contrib/autoboost/boost/spirit/home/classic/core/scanner/scanner.hpp
deleted file mode 100644
index a00f96504..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/scanner/scanner.hpp
+++ /dev/null
@@ -1,329 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2002 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_SCANNER_HPP)
-#define BOOST_SPIRIT_SCANNER_HPP
-
-#include <iterator>
-#include <boost/config.hpp>
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/match.hpp>
-#include <boost/spirit/home/classic/core/non_terminal/parser_id.hpp>
-#include <boost/detail/iterator.hpp> // for autoboost::detail::iterator_traits
-
-#include <boost/spirit/home/classic/core/scanner/scanner_fwd.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  iteration_policy class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct iteration_policy
-    {
-        template <typename ScannerT>
-        void
-        advance(ScannerT const& scan) const
-        {
-            ++scan.first;
-        }
-
-        template <typename ScannerT>
-        bool at_end(ScannerT const& scan) const
-        {
-            return scan.first == scan.last;
-        }
-
-        template <typename T>
-        T filter(T ch) const
-        {
-            return ch;
-        }
-
-        template <typename ScannerT>
-        typename ScannerT::ref_t
-        get(ScannerT const& scan) const
-        {
-            return *scan.first;
-        }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  match_policy class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct match_policy
-    {
-        template <typename T>
-        struct result { typedef match<T> type; };
-
-        const match<nil_t>
-        no_match() const
-        {
-            return match<nil_t>();
-        }
-
-        const match<nil_t>
-        empty_match() const
-        {
-            return match<nil_t>(0, nil_t());
-        }
-
-        template <typename AttrT, typename IteratorT>
-        match<AttrT>
-        create_match(
-            std::size_t         length,
-            AttrT const&        val,
-            IteratorT const&    /*first*/,
-            IteratorT const&    /*last*/) const
-        {
-            return match<AttrT>(length, val);
-        }
-
-        template <typename MatchT, typename IteratorT>
-        void group_match(
-            MatchT&             /*m*/,
-            parser_id const&    /*id*/,
-            IteratorT const&    /*first*/,
-            IteratorT const&    /*last*/) const {}
-
-        template <typename Match1T, typename Match2T>
-        void concat_match(Match1T& l, Match2T const& r) const
-        {
-            l.concat(r);
-        }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  match_result class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename MatchPolicyT, typename T>
-    struct match_result
-    {
-        typedef typename MatchPolicyT::template result<T>::type type;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  action_policy class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename AttrT>
-    struct attributed_action_policy
-    {
-        template <typename ActorT, typename IteratorT>
-        static void
-        call(
-            ActorT const& actor,
-            AttrT& val,
-            IteratorT const&,
-            IteratorT const&)
-        {
-            actor(val);
-        }
-    };
-
-    //////////////////////////////////
-    template <>
-    struct attributed_action_policy<nil_t>
-    {
-        template <typename ActorT, typename IteratorT>
-        static void
-        call(
-            ActorT const& actor,
-            nil_t,
-            IteratorT const& first,
-            IteratorT const& last)
-        {
-            actor(first, last);
-        }
-    };
-
-    //////////////////////////////////
-    struct action_policy
-    {
-        template <typename ActorT, typename AttrT, typename IteratorT>
-        void
-        do_action(
-            ActorT const&       actor,
-            AttrT&              val,
-            IteratorT const&    first,
-            IteratorT const&    last) const
-        {
-            attributed_action_policy<AttrT>::call(actor, val, first, last);
-        }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  scanner_policies class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <
-        typename IterationPolicyT,
-        typename MatchPolicyT,
-        typename ActionPolicyT>
-    struct scanner_policies :
-        public IterationPolicyT,
-        public MatchPolicyT,
-        public ActionPolicyT
-    {
-        typedef IterationPolicyT    iteration_policy_t;
-        typedef MatchPolicyT        match_policy_t;
-        typedef ActionPolicyT       action_policy_t;
-
-        scanner_policies(
-            IterationPolicyT const& i_policy = IterationPolicyT(),
-            MatchPolicyT const&     m_policy = MatchPolicyT(),
-            ActionPolicyT const&    a_policy = ActionPolicyT())
-        : IterationPolicyT(i_policy)
-        , MatchPolicyT(m_policy)
-        , ActionPolicyT(a_policy) {}
-
-        template <typename ScannerPoliciesT>
-        scanner_policies(ScannerPoliciesT const& policies)
-        : IterationPolicyT(policies)
-        , MatchPolicyT(policies)
-        , ActionPolicyT(policies) {}
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  scanner_policies_base class: the base class of all scanners
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct scanner_base {};
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  scanner class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <
-        typename IteratorT,
-        typename PoliciesT>
-    class scanner : public PoliciesT, public scanner_base
-    {
-    public:
-
-        typedef IteratorT iterator_t;
-        typedef PoliciesT policies_t;
-
-        typedef typename autoboost::detail::
-            iterator_traits<IteratorT>::value_type value_t;
-        typedef typename autoboost::detail::
-            iterator_traits<IteratorT>::reference ref_t;
-        typedef typename autoboost::
-            call_traits<IteratorT>::param_type iter_param_t;
-
-        scanner(
-            IteratorT&          first_,
-            iter_param_t        last_,
-            PoliciesT const&    policies = PoliciesT())
-        : PoliciesT(policies), first(first_), last(last_)
-        {
-            at_end();
-        }
-
-        scanner(scanner const& other)
-        : PoliciesT(other), first(other.first), last(other.last) {}
-
-        scanner(scanner const& other, IteratorT& first_)
-        : PoliciesT(other), first(first_), last(other.last) {}
-
-        template <typename PoliciesT1>
-        scanner(scanner<IteratorT, PoliciesT1> const& other)
-        : PoliciesT(other), first(other.first), last(other.last) {}
-
-        bool
-        at_end() const
-        {
-            typedef typename PoliciesT::iteration_policy_t iteration_policy_type;
-            return iteration_policy_type::at_end(*this);
-        }
-
-        value_t
-        operator*() const
-        {
-            typedef typename PoliciesT::iteration_policy_t iteration_policy_type;
-            return iteration_policy_type::filter(iteration_policy_type::get(*this));
-        }
-
-        scanner const&
-        operator++() const
-        {
-            typedef typename PoliciesT::iteration_policy_t iteration_policy_type;
-            iteration_policy_type::advance(*this);
-            return *this;
-        }
-
-        template <typename PoliciesT2>
-        struct rebind_policies
-        {
-            typedef scanner<IteratorT, PoliciesT2> type;
-        };
-
-        template <typename PoliciesT2>
-        scanner<IteratorT, PoliciesT2>
-        change_policies(PoliciesT2 const& policies) const
-        {
-            return scanner<IteratorT, PoliciesT2>(first, last, policies);
-        }
-
-        template <typename IteratorT2>
-        struct rebind_iterator
-        {
-            typedef scanner<IteratorT2, PoliciesT> type;
-        };
-
-        template <typename IteratorT2>
-        scanner<IteratorT2, PoliciesT>
-        change_iterator(IteratorT2 const& first_, IteratorT2 const &last_) const
-        {
-            return scanner<IteratorT2, PoliciesT>(first_, last_, *this);
-        }
-
-        IteratorT& first;
-        IteratorT const last;
-
-    private:
-
-        scanner&
-        operator=(scanner const& other);
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  rebind_scanner_policies class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename ScannerT, typename PoliciesT>
-    struct rebind_scanner_policies
-    {
-        typedef typename ScannerT::template
-            rebind_policies<PoliciesT>::type type;
-    };
-
-    //////////////////////////////////
-    template <typename ScannerT, typename IteratorT>
-    struct rebind_scanner_iterator
-    {
-        typedef typename ScannerT::template
-            rebind_iterator<IteratorT>::type type;
-    };
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}}
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/scanner/scanner_fwd.hpp b/contrib/autoboost/boost/spirit/home/classic/core/scanner/scanner_fwd.hpp
deleted file mode 100644
index c9f293004..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/scanner/scanner_fwd.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2006 Tobias Schwinger
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_SCANNER_FWD_HPP)
-#define BOOST_SPIRIT_SCANNER_FWD_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  policy classes
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    struct iteration_policy;
-    struct action_policy;
-    struct match_policy;
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  scanner_policies class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <
-        typename IterationPolicyT   = iteration_policy,
-        typename MatchPolicyT       = match_policy,
-        typename ActionPolicyT      = action_policy>
-    struct scanner_policies;
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  scanner class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <
-        typename IteratorT  = char const*,
-        typename PoliciesT  = scanner_policies<> >
-    class scanner;
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/scanner/skipper.hpp b/contrib/autoboost/boost/spirit/home/classic/core/scanner/skipper.hpp
deleted file mode 100644
index f5b3a5837..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/scanner/skipper.hpp
+++ /dev/null
@@ -1,197 +0,0 @@
-/*=============================================================================
-    Copyright (c) 1998-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_SKIPPER_HPP)
-#define BOOST_SPIRIT_SKIPPER_HPP
-
-///////////////////////////////////////////////////////////////////////////////
-#include <cctype>
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/scanner/scanner.hpp>
-#include <boost/spirit/home/classic/core/primitives/impl/primitives.ipp>
-
-#include <boost/spirit/home/classic/core/scanner/skipper_fwd.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  skipper_iteration_policy class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename BaseT>
-    struct skipper_iteration_policy : public BaseT
-    {
-        typedef BaseT base_t;
-    
-        skipper_iteration_policy()
-        : BaseT() {}
-    
-        template <typename PolicyT>
-        skipper_iteration_policy(PolicyT const& other)
-        : BaseT(other) {}
-    
-        template <typename ScannerT>
-        void
-        advance(ScannerT const& scan) const
-        {
-            BaseT::advance(scan);
-            scan.skip(scan);
-        }
-    
-        template <typename ScannerT>
-        bool
-        at_end(ScannerT const& scan) const
-        {
-            scan.skip(scan);
-            return BaseT::at_end(scan);
-        }
-    
-        template <typename ScannerT>
-        void
-        skip(ScannerT const& scan) const
-        {
-            while (!BaseT::at_end(scan) && impl::isspace_(BaseT::get(scan)))
-                BaseT::advance(scan);
-        }
-    };
-    
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  no_skipper_iteration_policy class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename BaseT>
-    struct no_skipper_iteration_policy : public BaseT
-    {
-        typedef BaseT base_t;
-
-        no_skipper_iteration_policy()
-        : BaseT() {}
-
-        template <typename PolicyT>
-        no_skipper_iteration_policy(PolicyT const& other)
-        : BaseT(other) {}
-
-        template <typename ScannerT>
-        void
-        skip(ScannerT const& /*scan*/) const {}
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  skip_parser_iteration_policy class
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    namespace impl
-    {
-        template <typename ST, typename ScannerT, typename BaseT>
-        void
-        skipper_skip(
-            ST const& s,
-            ScannerT const& scan,
-            skipper_iteration_policy<BaseT> const&);
-
-        template <typename ST, typename ScannerT, typename BaseT>
-        void
-        skipper_skip(
-            ST const& s,
-            ScannerT const& scan,
-            no_skipper_iteration_policy<BaseT> const&);
-
-        template <typename ST, typename ScannerT>
-        void
-        skipper_skip(
-            ST const& s,
-            ScannerT const& scan,
-            iteration_policy const&);
-    }
-
-    template <typename ParserT, typename BaseT>
-    class skip_parser_iteration_policy : public skipper_iteration_policy<BaseT>
-    {
-    public:
-    
-        typedef skipper_iteration_policy<BaseT> base_t;
-    
-        skip_parser_iteration_policy(
-            ParserT const& skip_parser,
-            base_t const& base = base_t())
-        : base_t(base), subject(skip_parser) {}
-    
-        template <typename PolicyT>
-        skip_parser_iteration_policy(PolicyT const& other)
-        : base_t(other), subject(other.skipper()) {}
-    
-        template <typename ScannerT>
-        void
-        skip(ScannerT const& scan) const
-        {
-            impl::skipper_skip(subject, scan, scan);
-        }
-    
-        ParserT const&
-        skipper() const
-        { 
-            return subject; 
-        }
-    
-    private:
-    
-        ParserT const& subject;
-    };
-    
-    ///////////////////////////////////////////////////////////////////////////////
-    //
-    //  Free parse functions using the skippers
-    //
-    ///////////////////////////////////////////////////////////////////////////////
-    template <typename IteratorT, typename ParserT, typename SkipT>
-    parse_info<IteratorT>
-    parse(
-        IteratorT const&        first,
-        IteratorT const&        last,
-        parser<ParserT> const&  p,
-        parser<SkipT> const&    skip);
-    
-    ///////////////////////////////////////////////////////////////////////////////
-    //
-    //  Parse function for null terminated strings using the skippers
-    //
-    ///////////////////////////////////////////////////////////////////////////////
-    template <typename CharT, typename ParserT, typename SkipT>
-    parse_info<CharT const*>
-    parse(
-        CharT const*            str,
-        parser<ParserT> const&  p,
-        parser<SkipT> const&    skip);
-    
-    ///////////////////////////////////////////////////////////////////////////////
-    //
-    //  phrase_scanner_t and wide_phrase_scanner_t
-    //
-    //      The most common scanners. Use these typedefs when you need
-    //      a scanner that skips white spaces.
-    //
-    ///////////////////////////////////////////////////////////////////////////////
-    typedef skipper_iteration_policy<>                  iter_policy_t;
-    typedef scanner_policies<iter_policy_t>             scanner_policies_t;
-    typedef scanner<char const*, scanner_policies_t>    phrase_scanner_t;
-    typedef scanner<wchar_t const*, scanner_policies_t> wide_phrase_scanner_t;
-    
-    ///////////////////////////////////////////////////////////////////////////////
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#include <boost/spirit/home/classic/core/scanner/impl/skipper.ipp>
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/core/scanner/skipper_fwd.hpp b/contrib/autoboost/boost/spirit/home/classic/core/scanner/skipper_fwd.hpp
deleted file mode 100644
index d7c1da39b..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/core/scanner/skipper_fwd.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2006 Tobias Schwinger
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_SKIPPER_FWD_HPP)
-#define BOOST_SPIRIT_SKIPPER_FWD_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/scanner/scanner_fwd.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    template <typename BaseT = iteration_policy>
-    struct skipper_iteration_policy;
-
-    template <typename BaseT = iteration_policy>
-    struct no_skipper_iteration_policy; 
-
-    template <typename ParserT, typename BaseT = iteration_policy>
-    class skip_parser_iteration_policy;
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/debug.hpp b/contrib/autoboost/boost/spirit/home/classic/debug.hpp
deleted file mode 100644
index 9737b35be..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/debug.hpp
+++ /dev/null
@@ -1,154 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Joel de Guzman
-    Copyright (c) 2002-2003 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_DEBUG_MAIN_HPP)
-#define BOOST_SPIRIT_DEBUG_MAIN_HPP
-
-///////////////////////////////////////////////////////////////////////////
-#if defined(BOOST_SPIRIT_DEBUG)
-
-#include <boost/spirit/home/classic/version.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Spirit.Debug includes and defines
-//
-///////////////////////////////////////////////////////////////////////////////
-
-    #include <iostream>
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  The BOOST_SPIRIT_DEBUG_OUT defines the stream object, which should be used
-    //  for debug diagnostics. This defaults to std::cout.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    #if !defined(BOOST_SPIRIT_DEBUG_OUT)
-    #define BOOST_SPIRIT_DEBUG_OUT std::cout
-    #endif
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  The BOOST_SPIRIT_DEBUG_PRINT_SOME constant defines the number of characters
-    //  from the stream to be printed for diagnosis. This defaults to the first
-    //  20 characters.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    #if !defined(BOOST_SPIRIT_DEBUG_PRINT_SOME)
-    #define BOOST_SPIRIT_DEBUG_PRINT_SOME 20
-    #endif
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  Additional BOOST_SPIRIT_DEBUG_FLAGS control the level of diagnostics printed
-    //  Basic constants are defined in debug/minimal.hpp.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    #define BOOST_SPIRIT_DEBUG_FLAGS_NODES        0x0001  // node diagnostics
-    #define BOOST_SPIRIT_DEBUG_FLAGS_ESCAPE_CHAR  0x0002  // escape_char_parse diagnostics
-    #define BOOST_SPIRIT_DEBUG_FLAGS_TREES        0x0004  // parse tree/ast diagnostics
-    #define BOOST_SPIRIT_DEBUG_FLAGS_CLOSURES     0x0008  // closure diagnostics
-    #define BOOST_SPIRIT_DEBUG_FLAGS_SLEX         0x8000  // slex diagnostics
-
-    #define BOOST_SPIRIT_DEBUG_FLAGS_MAX          0xFFFF  // print maximal diagnostics
-
-    #if !defined(BOOST_SPIRIT_DEBUG_FLAGS)
-    #define BOOST_SPIRIT_DEBUG_FLAGS BOOST_SPIRIT_DEBUG_FLAGS_MAX
-    #endif
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  By default all nodes are traced (even those, not registered with
-    //  BOOST_SPIRIT_DEBUG_RULE et.al. - see below). The following constant may be
-    //  used to redefine this default.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    #if !defined(BOOST_SPIRIT_DEBUG_TRACENODE)
-    #define BOOST_SPIRIT_DEBUG_TRACENODE          (true)
-    #endif // !defined(BOOST_SPIRIT_DEBUG_TRACENODE)
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  Helper macros for giving rules and subrules a name accessible through
-    //  parser_name() functions (see parser_names.hpp).
-    //
-    //  Additionally, the macros BOOST_SPIRIT_DEBUG_RULE, SPIRIT_DEBUG_NODE and
-    //  BOOST_SPIRIT_DEBUG_GRAMMAR enable/disable the tracing of the 
-    //  correspondingnode accordingly to the PP constant 
-    //  BOOST_SPIRIT_DEBUG_TRACENODE.
-    //
-    //  The macros BOOST_SPIRIT_DEBUG_TRACE_RULE, BOOST_SPIRIT_DEBUG_TRACE_NODE 
-    //  and BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR allow to specify a flag to define, 
-    //  whether the corresponding node is to be traced or not.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    #if !defined(BOOST_SPIRIT_DEBUG_RULE)
-    #define BOOST_SPIRIT_DEBUG_RULE(r)    \
-        ::BOOST_SPIRIT_CLASSIC_NS::impl::get_node_registry(). \
-            register_node(&r, #r, BOOST_SPIRIT_DEBUG_TRACENODE)
-    #endif // !defined(BOOST_SPIRIT_DEBUG_RULE)
-
-    #if !defined(BOOST_SPIRIT_DEBUG_NODE)
-    #define BOOST_SPIRIT_DEBUG_NODE(r)    \
-        ::BOOST_SPIRIT_CLASSIC_NS::impl::get_node_registry(). \
-            register_node(&r, #r, BOOST_SPIRIT_DEBUG_TRACENODE)
-    #endif // !defined(BOOST_SPIRIT_DEBUG_NODE)
-
-    #if !defined(BOOST_SPIRIT_DEBUG_GRAMMAR)
-    #define BOOST_SPIRIT_DEBUG_GRAMMAR(r)    \
-        ::BOOST_SPIRIT_CLASSIC_NS::impl::get_node_registry(). \
-            register_node(&r, #r, BOOST_SPIRIT_DEBUG_TRACENODE)
-    #endif // !defined(BOOST_SPIRIT_DEBUG_GRAMMAR)
-
-    #if !defined(BOOST_SPIRIT_DEBUG_TRACE_RULE)
-    #define BOOST_SPIRIT_DEBUG_TRACE_RULE(r, t)    \
-        ::BOOST_SPIRIT_CLASSIC_NS::impl::get_node_registry(). \
-            register_node(&r, #r, (t))
-    #endif // !defined(BOOST_SPIRIT_TRACE_RULE)
-
-    #if !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE)
-    #define BOOST_SPIRIT_DEBUG_TRACE_NODE(r, t)    \
-        ::BOOST_SPIRIT_CLASSIC_NS::impl::get_node_registry(). \
-            register_node(&r, #r, (t))
-    #endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE)
-
-    #if !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR)
-    #define BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR(r, t)    \
-        ::BOOST_SPIRIT_CLASSIC_NS::impl::get_node_registry(). \
-            register_node(&r, #r, (t))
-    #endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR)
-
-    #if !defined(BOOST_SPIRIT_DEBUG_TRACE_RULE_NAME)
-    #define BOOST_SPIRIT_DEBUG_TRACE_RULE_NAME(r, n, t)    \
-        ::BOOST_SPIRIT_CLASSIC_NS::impl::get_node_registry(). \
-            register_node(&r, (n), (t))
-    #endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_RULE_NAME)
-
-    #if !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE_NAME)
-    #define BOOST_SPIRIT_DEBUG_TRACE_NODE_NAME(r, n, t)    \
-        ::BOOST_SPIRIT_CLASSIC_NS::impl::get_node_registry(). \
-            register_node(&r, (n), (t))
-    #endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE_NAME)
-
-    #if !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME)
-    #define BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME(r, n, t)    \
-        ::BOOST_SPIRIT_CLASSIC_NS::impl::get_node_registry(). \
-            register_node(&r, (n), (t))
-    #endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME)
-
-    //////////////////////////////////
-    #include <boost/spirit/home/classic/debug/debug_node.hpp>
-
-#else
-    //////////////////////////////////
-    #include <boost/spirit/home/classic/debug/minimal.hpp>
-
-#endif // BOOST_SPIRIT_DEBUG
-
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/debug/debug_node.hpp b/contrib/autoboost/boost/spirit/home/classic/debug/debug_node.hpp
deleted file mode 100644
index d70b28923..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/debug/debug_node.hpp
+++ /dev/null
@@ -1,319 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Joel de Guzman
-    Copyright (c) 2002-2003 Hartmut Kaiser
-    Copyright (c) 2003 Gustavo Guerra
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_DEBUG_NODE_HPP)
-#define BOOST_SPIRIT_DEBUG_NODE_HPP
-
-#if !defined(BOOST_SPIRIT_DEBUG_MAIN_HPP)
-#error "You must include boost/spirit/debug.hpp, not boost/spirit/debug/debug_node.hpp"
-#endif
-
-#if defined(BOOST_SPIRIT_DEBUG)
-
-#include <string>
-
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/primitives/primitives.hpp> // for iscntrl_
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Debug helper classes for rules, which ensure maximum non-intrusiveness of
-//  the Spirit debug support
-//
-///////////////////////////////////////////////////////////////////////////////
-
-namespace impl {
-
-    struct token_printer_aux_for_chars
-    {
-        template<typename CharT>
-        static void print(std::ostream& o, CharT c)
-        {
-            if (c == static_cast<CharT>('\a'))
-                o << "\\a";
-
-            else if (c == static_cast<CharT>('\b'))
-                o << "\\b";
-
-            else if (c == static_cast<CharT>('\f'))
-                o << "\\f";
-
-            else if (c == static_cast<CharT>('\n'))
-                o << "\\n";
-
-            else if (c == static_cast<CharT>('\r'))
-                o << "\\r";
-
-            else if (c == static_cast<CharT>('\t'))
-                o << "\\t";
-
-            else if (c == static_cast<CharT>('\v'))
-                o << "\\v";
-
-            else if (iscntrl_(c))
-                o << "\\" << static_cast<int>(c);
-
-            else
-                o << static_cast<char>(c);
-        }
-    };
-
-    // for token types where the comparison with char constants wouldn't work
-    struct token_printer_aux_for_other_types
-    {
-        template<typename CharT>
-        static void print(std::ostream& o, CharT c)
-        {
-            o << c;
-        }
-    };
-
-    template <typename CharT>
-    struct token_printer_aux
-    :   mpl::if_<
-            mpl::and_<
-                is_convertible<CharT, char>,
-                is_convertible<char, CharT> >,
-            token_printer_aux_for_chars,
-            token_printer_aux_for_other_types
-        >::type
-    {
-    };
-
-    template<typename CharT>
-    inline void token_printer(std::ostream& o, CharT c)
-    {
-    #if !defined(BOOST_SPIRIT_DEBUG_TOKEN_PRINTER)
-
-        token_printer_aux<CharT>::print(o, c);
-
-    #else
-
-        BOOST_SPIRIT_DEBUG_TOKEN_PRINTER(o, c);
-
-    #endif
-    }
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Dump infos about the parsing state of a rule
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#if BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_NODES
-    template <typename IteratorT>
-    inline void
-    print_node_info(bool hit, int level, bool close, std::string const& name,
-        IteratorT first, IteratorT last)
-    {
-        if (!name.empty())
-        {
-            for (int i = 0; i < level; ++i)
-                BOOST_SPIRIT_DEBUG_OUT << "  ";
-            if (close)
-            {
-                if (hit)
-                    BOOST_SPIRIT_DEBUG_OUT << "/";
-                else
-                    BOOST_SPIRIT_DEBUG_OUT << "#";
-            }
-            BOOST_SPIRIT_DEBUG_OUT << name << ":\t\"";
-            IteratorT iter = first;
-            IteratorT ilast = last;
-            for (int j = 0; j < BOOST_SPIRIT_DEBUG_PRINT_SOME; ++j)
-            {
-                if (iter == ilast)
-                    break;
-
-                token_printer(BOOST_SPIRIT_DEBUG_OUT, *iter);
-                ++iter;
-            }
-            BOOST_SPIRIT_DEBUG_OUT << "\"\n";
-        }
-    }
-#endif  // BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_NODES
-
-#if BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_CLOSURES
-    template <typename ResultT>
-    inline ResultT &
-    print_closure_info(ResultT &hit, int level, std::string const& name)
-    {
-        if (!name.empty())
-        {
-            for (int i = 0; i < level-1; ++i)
-                BOOST_SPIRIT_DEBUG_OUT << "  ";
-
-        // for now, print out the return value only
-            BOOST_SPIRIT_DEBUG_OUT << "^" << name << ":\t";
-            if (hit.has_valid_attribute())
-                BOOST_SPIRIT_DEBUG_OUT << hit.value();
-            else
-                BOOST_SPIRIT_DEBUG_OUT << "undefined attribute";
-            BOOST_SPIRIT_DEBUG_OUT << "\n";
-        }
-        return hit;
-    }
-#endif // BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_CLOSURES
-
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Implementation note: The parser_context_linker, parser_scanner_linker and
-//  closure_context_linker classes are wrapped by a PP constant to allow
-//  redefinition of this classes outside of Spirit
-//
-///////////////////////////////////////////////////////////////////////////////
-#if !defined(BOOST_SPIRIT_PARSER_CONTEXT_LINKER_DEFINED)
-#define BOOST_SPIRIT_PARSER_CONTEXT_LINKER_DEFINED
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  parser_context_linker is a debug wrapper for the ContextT template
-    //  parameter of the rule<>, subrule<> and the grammar<> classes
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template<typename ContextT>
-    struct parser_context_linker : public ContextT
-    {
-        typedef ContextT base_t;
-
-        template <typename ParserT>
-        parser_context_linker(ParserT const& p)
-        : ContextT(p) {}
-
-        template <typename ParserT, typename ScannerT>
-        void pre_parse(ParserT const& p, ScannerT &scan)
-        {
-            this->base_t::pre_parse(p, scan);
-
-#if BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_NODES
-            if (trace_parser(p.derived())) {
-                impl::print_node_info(
-                    false,
-                    scan.get_level(),
-                    false,
-                    parser_name(p.derived()),
-                    scan.first,
-                    scan.last);
-            }
-            scan.get_level()++;
-#endif  // BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_NODES
-        }
-
-        template <typename ResultT, typename ParserT, typename ScannerT>
-        ResultT& post_parse(ResultT& hit, ParserT const& p, ScannerT &scan)
-        {
-#if BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_NODES
-            --scan.get_level();
-            if (trace_parser(p.derived())) {
-                impl::print_node_info(
-                    hit,
-                    scan.get_level(),
-                    true,
-                    parser_name(p.derived()),
-                    scan.first,
-                    scan.last);
-            }
-#endif  // BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_NODES
-
-            return this->base_t::post_parse(hit, p, scan);
-        }
-    };
-
-#endif // !defined(BOOST_SPIRIT_PARSER_CONTEXT_LINKER_DEFINED)
-
-#if !defined(BOOST_SPIRIT_PARSER_SCANNER_LINKER_DEFINED)
-#define BOOST_SPIRIT_PARSER_SCANNER_LINKER_DEFINED
-
-///////////////////////////////////////////////////////////////////////////////
-//  This class is to avoid linker problems and to ensure a real singleton
-//  'level' variable
-    struct debug_support
-    {
-        int& get_level()
-        {
-            static int level = 0;
-            return level;
-        }
-    };
-
-    template<typename ScannerT>
-    struct parser_scanner_linker : public ScannerT
-    {
-        parser_scanner_linker(ScannerT const &scan_) : ScannerT(scan_)
-        {}
-
-        int &get_level()
-        { return debug.get_level(); }
-
-        private: debug_support debug;
-    };
-
-#endif // !defined(BOOST_SPIRIT_PARSER_SCANNER_LINKER_DEFINED)
-
-#if !defined(BOOST_SPIRIT_CLOSURE_CONTEXT_LINKER_DEFINED)
-#define BOOST_SPIRIT_CLOSURE_CONTEXT_LINKER_DEFINED
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  closure_context_linker is a debug wrapper for the closure template
-    //  parameter of the rule<>, subrule<> and grammar classes
-    //
-    ///////////////////////////////////////////////////////////////////////////
-
-    template<typename ContextT>
-    struct closure_context_linker : public parser_context_linker<ContextT>
-    {
-        typedef parser_context_linker<ContextT> base_t;
-
-        template <typename ParserT>
-        closure_context_linker(ParserT const& p)
-        : parser_context_linker<ContextT>(p) {}
-
-        template <typename ParserT, typename ScannerT>
-        void pre_parse(ParserT const& p, ScannerT &scan)
-        { this->base_t::pre_parse(p, scan); }
-
-        template <typename ResultT, typename ParserT, typename ScannerT>
-        ResultT&
-        post_parse(ResultT& hit, ParserT const& p, ScannerT &scan)
-        {
-#if BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_CLOSURES
-            if (hit && trace_parser(p.derived())) {
-            // for now, print out the return value only
-                return impl::print_closure_info(
-                    this->base_t::post_parse(hit, p, scan),
-                    scan.get_level(),
-                    parser_name(p.derived())
-                );
-            }
-#endif // BOOST_SPIRIT_DEBUG_FLAGS & BOOST_SPIRIT_DEBUG_FLAGS_CLOSURES
-
-            return this->base_t::post_parse(hit, p, scan);
-        }
-    };
-
-#endif // !defined(BOOST_SPIRIT_CLOSURE_CONTEXT_LINKER_DEFINED)
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif // defined(BOOST_SPIRIT_DEBUG)
-
-#endif // !defined(BOOST_SPIRIT_DEBUG_NODE_HPP)
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/debug/minimal.hpp b/contrib/autoboost/boost/spirit/home/classic/debug/minimal.hpp
deleted file mode 100644
index 0cb42644a..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/debug/minimal.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Joel de Guzman
-    Copyright (c) 2002-2003 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_MINIMAL_DEBUG_HPP)
-#define BOOST_SPIRIT_MINIMAL_DEBUG_HPP
-
-#if !defined(BOOST_SPIRIT_DEBUG_MAIN_HPP)
-#error "You must include boost/spirit/debug.hpp, not boost/spirit/debug/minimal.hpp"
-#endif
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Minimum debugging tools support
-//
-///////////////////////////////////////////////////////////////////////////////
-#if !defined(BOOST_SPIRIT_DEBUG_OUT)
-#define BOOST_SPIRIT_DEBUG_OUT std::cout
-#endif
-
-///////////////////////////////////////////////////////////////////////////
-//
-//  BOOST_SPIRIT_DEBUG_FLAGS controls the level of diagnostics printed
-//
-///////////////////////////////////////////////////////////////////////////
-#if !defined(BOOST_SPIRIT_DEBUG_FLAGS_NONE)
-#define BOOST_SPIRIT_DEBUG_FLAGS_NONE         0x0000  // no diagnostics at all
-#endif
-
-#if !defined(BOOST_SPIRIT_DEBUG_FLAGS_MAX)
-#define BOOST_SPIRIT_DEBUG_FLAGS_MAX          0xFFFF  // print maximal diagnostics
-#endif
-
-#if !defined(BOOST_SPIRIT_DEBUG_FLAGS)
-#define BOOST_SPIRIT_DEBUG_FLAGS BOOST_SPIRIT_DEBUG_FLAGS_MAX
-#endif
-
-#if !defined(BOOST_SPIRIT_DEBUG_PRINT_SOME)
-#define BOOST_SPIRIT_DEBUG_PRINT_SOME 20
-#endif
-
-#if !defined(BOOST_SPIRIT_DEBUG_RULE)
-#define BOOST_SPIRIT_DEBUG_RULE(r)
-#endif // !defined(BOOST_SPIRIT_DEBUG_RULE)
-
-#if !defined(BOOST_SPIRIT_DEBUG_NODE)
-#define BOOST_SPIRIT_DEBUG_NODE(r)
-#endif // !defined(BOOST_SPIRIT_DEBUG_NODE)
-
-#if !defined(BOOST_SPIRIT_DEBUG_GRAMMAR)
-#define BOOST_SPIRIT_DEBUG_GRAMMAR(r)
-#endif // !defined(BOOST_SPIRIT_DEBUG_GRAMMAR)
-
-#if !defined(BOOST_SPIRIT_DEBUG_TRACE_RULE)
-#define BOOST_SPIRIT_DEBUG_TRACE_RULE(r, t)
-#endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_RULE)
-
-#if !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE)
-#define BOOST_SPIRIT_DEBUG_TRACE_NODE(r, t)
-#endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE)
-
-#if !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR)
-#define BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR(r, t)
-#endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR)
-
-#if !defined(BOOST_SPIRIT_DEBUG_TRACE_RULE_NAME)
-#define BOOST_SPIRIT_DEBUG_TRACE_RULE_NAME(r, n, t)
-#endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_RULE_NAME)
-
-#if !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE_NAME)
-#define BOOST_SPIRIT_DEBUG_TRACE_NODE_NAME(r, n, t)
-#endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_NODE_NAME)
-
-#if !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME)
-#define BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME(r, n, t)
-#endif // !defined(BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME)
-
-#endif  // !defined(BOOST_SPIRIT_MINIMAL_DEBUG_HPP)
diff --git a/contrib/autoboost/boost/spirit/home/classic/meta/as_parser.hpp b/contrib/autoboost/boost/spirit/home/classic/meta/as_parser.hpp
deleted file mode 100644
index 8cffcb7f5..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/meta/as_parser.hpp
+++ /dev/null
@@ -1,113 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2002-2003 Joel de Guzman
-    Copyright (c) 2002-2003 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_AS_PARSER_HPP)
-#define BOOST_SPIRIT_AS_PARSER_HPP
-
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  Helper templates to derive the parser type from an auxilliary type
-    //  and to generate an object of the required parser type given an
-    //  auxilliary object. Supported types to convert are parsers,
-    //  single characters and character strings.
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    namespace impl
-    {
-        template<typename T>
-        struct default_as_parser
-        {
-            typedef T type;
-            static type const& convert(type const& p)
-            {
-                return p;
-            }
-        };
-
-        struct char_as_parser
-        {
-            typedef chlit<char> type;
-            static type convert(char ch)
-            {
-                return type(ch);
-            }
-        };
-
-        struct wchar_as_parser
-        {
-            typedef chlit<wchar_t> type;
-            static type convert(wchar_t ch)
-            {
-                return type(ch);
-            }
-        };
-
-        struct string_as_parser
-        {
-            typedef strlit<char const*> type;
-            static type convert(char const* str)
-            {
-                return type(str);
-            }
-        };
-
-        struct wstring_as_parser
-        {
-            typedef strlit<wchar_t const*> type;
-            static type convert(wchar_t const* str)
-            {
-                return type(str);
-            }
-        };
-    }
-
-    template<typename T>
-    struct as_parser : impl::default_as_parser<T> {};
-
-    template<>
-    struct as_parser<char> : impl::char_as_parser {};
-
-    template<>
-    struct as_parser<wchar_t> : impl::wchar_as_parser {};
-
-    template<>
-    struct as_parser<char*> : impl::string_as_parser {};
-
-    template<>
-    struct as_parser<char const*> : impl::string_as_parser {};
-
-    template<>
-    struct as_parser<wchar_t*> : impl::wstring_as_parser {};
-
-    template<>
-    struct as_parser<wchar_t const*> : impl::wstring_as_parser {};
-
-    template<int N>
-    struct as_parser<char[N]> : impl::string_as_parser {};
-
-    template<int N>
-    struct as_parser<wchar_t[N]> : impl::wstring_as_parser {};
-
-    template<int N>
-    struct as_parser<char const[N]> : impl::string_as_parser {};
-
-    template<int N>
-    struct as_parser<wchar_t const[N]> : impl::wstring_as_parser {};
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/namespace.hpp b/contrib/autoboost/boost/spirit/home/classic/namespace.hpp
deleted file mode 100644
index ed9031f2d..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/namespace.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/*=============================================================================
-  Copyright (c) 2001-2008 Joel de Guzman
-  Copyright (c) 2001-2008 Hartmut Kaiser
-  http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(SPIRIT_CLASSIC_NAMESPACE_HPP)
-#define SPIRIT_CLASSIC_NAMESPACE_HPP
-
-#if defined(BOOST_SPIRIT_USE_OLD_NAMESPACE)
-
-// Use the old namespace for Spirit.Classic, everything is located in the 
-// namespace autoboost::spirit.
-// This is in place for backwards compatibility with Spirit V1.8.x. Don't use
-// it when combining Spirit.Classic with other parts of the library
-
-#define BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN /*namespace classic {*/
-#define BOOST_SPIRIT_CLASSIC_NS              autoboost::spirit/*::classic*/
-#define BOOST_SPIRIT_CLASSIC_NAMESPACE_END   /*}*/
-        
-#else
-
-// This is the normal (and suggested) mode of operation when using 
-// Spirit.Classic. Everything will be located in the namespace 
-// autoboost::spirit::classic, avoiding name clashes with other parts of Spirit.
-
-#define BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN namespace classic {
-#define BOOST_SPIRIT_CLASSIC_NS              autoboost::spirit::classic
-#define BOOST_SPIRIT_CLASSIC_NAMESPACE_END   }
-
-#endif
-
-#endif 
diff --git a/contrib/autoboost/boost/spirit/home/classic/utility/chset.hpp b/contrib/autoboost/boost/spirit/home/classic/utility/chset.hpp
deleted file mode 100644
index 7dff20eae..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/utility/chset.hpp
+++ /dev/null
@@ -1,187 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Joel de Guzman
-    Copyright (c) 2001-2003 Daniel Nuffer
-    http://spirit.sourceforge.net/
-
-  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_SPIRIT_CHSET_HPP
-#define BOOST_SPIRIT_CHSET_HPP
-
-///////////////////////////////////////////////////////////////////////////////
-#include <boost/shared_ptr.hpp>
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/core/primitives/primitives.hpp>
-#include <boost/spirit/home/classic/utility/impl/chset/basic_chset.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-namespace utility { namespace impl {
-
-    // This is here because some compilers choke on out-of-line member
-    // template functions.  And we don't want to put the whole algorithm
-    // in the chset constructor in the class definition.
-    template <typename CharT, typename CharT2>
-    void construct_chset(autoboost::shared_ptr<basic_chset<CharT> >& ptr,
-            CharT2 const* definition);
-
-}} // namespace utility::impl
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  chset class
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT = char>
-class chset: public char_parser<chset<CharT> > {
-
-public:
-                    chset();
-                    chset(chset const& arg_);
-    explicit        chset(CharT arg_);
-    explicit        chset(anychar_parser arg_);
-    explicit        chset(nothing_parser arg_);
-    explicit        chset(chlit<CharT> const& arg_);
-    explicit        chset(range<CharT> const& arg_);
-    explicit        chset(negated_char_parser<chlit<CharT> > const& arg_);
-    explicit        chset(negated_char_parser<range<CharT> > const& arg_);
-
-                    template <typename CharT2>
-    explicit        chset(CharT2 const* definition)
-                    : ptr(new basic_chset<CharT>())
-                    {
-                        utility::impl::construct_chset(ptr, definition);
-                    }
-                    ~chset();
-
-    chset&          operator=(chset const& rhs);
-    chset&          operator=(CharT rhs);
-    chset&          operator=(anychar_parser rhs);
-    chset&          operator=(nothing_parser rhs);
-    chset&          operator=(chlit<CharT> const& rhs);
-    chset&          operator=(range<CharT> const& rhs);
-    chset&          operator=(negated_char_parser<chlit<CharT> > const& rhs);
-    chset&          operator=(negated_char_parser<range<CharT> > const& rhs);
-
-    void            set(range<CharT> const& arg_);
-    void            set(negated_char_parser<chlit<CharT> > const& arg_);
-    void            set(negated_char_parser<range<CharT> > const& arg_);
-
-    void            clear(range<CharT> const& arg_);
-    void            clear(negated_char_parser<range<CharT> > const& arg_);
-    bool            test(CharT ch) const;
-    chset&          inverse();
-    void            swap(chset& x);
-
-    chset&          operator|=(chset const& x);
-    chset&          operator&=(chset const& x);
-    chset&          operator-=(chset const& x);
-    chset&          operator^=(chset const& x);
-
-private:
-
-    autoboost::shared_ptr<basic_chset<CharT> > ptr;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  Generator functions
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-chset_p(chlit<CharT> const& arg_)
-{ return chset<CharT>(arg_); }
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-chset_p(range<CharT> const& arg_)
-{ return chset<CharT>(arg_); }
-
-template <typename CharT>
-inline chset<CharT>
-chset_p(negated_char_parser<chlit<CharT> > const& arg_)
-{ return chset<CharT>(arg_); }
-
-template <typename CharT>
-inline chset<CharT>
-chset_p(negated_char_parser<range<CharT> > const& arg_)
-{ return chset<CharT>(arg_); }
-
-//////////////////////////////////
-inline chset<char>
-chset_p(char const* init)
-{ return chset<char>(init); }
-
-//////////////////////////////////
-inline chset<wchar_t>
-chset_p(wchar_t const* init)
-{ return chset<wchar_t>(init); }
-
-//////////////////////////////////
-inline chset<char>
-chset_p(char ch)
-{ return chset<char>(ch); }
-
-//////////////////////////////////
-inline chset<wchar_t>
-chset_p(wchar_t ch)
-{ return chset<wchar_t>(ch); }
-
-//////////////////////////////////
-inline chset<int>
-chset_p(int ch)
-{ return chset<int>(ch); }
-
-//////////////////////////////////
-inline chset<unsigned int>
-chset_p(unsigned int ch)
-{ return chset<unsigned int>(ch); }
-
-//////////////////////////////////
-inline chset<short>
-chset_p(short ch)
-{ return chset<short>(ch); }
-
-#if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
-//////////////////////////////////
-inline chset<unsigned short>
-chset_p(unsigned short ch)
-{ return chset<unsigned short>(ch); }
-#endif
-//////////////////////////////////
-inline chset<long>
-chset_p(long ch)
-{ return chset<long>(ch); }
-
-//////////////////////////////////
-inline chset<unsigned long>
-chset_p(unsigned long ch)
-{ return chset<unsigned long>(ch); }
-
-#ifdef BOOST_HAS_LONG_LONG
-//////////////////////////////////
-inline chset< ::autoboost::long_long_type>
-chset_p( ::autoboost::long_long_type ch)
-{ return chset< ::autoboost::long_long_type>(ch); }
-
-//////////////////////////////////
-inline chset< ::autoboost::ulong_long_type>
-chset_p( ::autoboost::ulong_long_type ch)
-{ return chset< ::autoboost::ulong_long_type>(ch); }
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
-#include <boost/spirit/home/classic/utility/impl/chset.ipp>
-#include <boost/spirit/home/classic/utility/chset_operators.hpp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/utility/chset_operators.hpp b/contrib/autoboost/boost/spirit/home/classic/utility/chset_operators.hpp
deleted file mode 100644
index 6b1f44503..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/utility/chset_operators.hpp
+++ /dev/null
@@ -1,402 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Joel de Guzman
-    Copyright (c) 2001-2003 Daniel Nuffer
-    http://spirit.sourceforge.net/
-
-  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_SPIRIT_CHSET_OPERATORS_HPP
-#define BOOST_SPIRIT_CHSET_OPERATORS_HPP
-
-///////////////////////////////////////////////////////////////////////////////
-#include <boost/spirit/home/classic/namespace.hpp>
-#include <boost/spirit/home/classic/utility/chset.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  chset free operators
-//
-//      Where a and b are both chsets, implements:
-//
-//          a | b, a & b, a - b, a ^ b
-//
-//      Where a is a chset, implements:
-//
-//          ~a
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator~(chset<CharT> const& a);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator|(chset<CharT> const& a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator&(chset<CharT> const& a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator-(chset<CharT> const& a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator^(chset<CharT> const& a, chset<CharT> const& b);
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  range <--> chset free operators
-//
-//      Where a is a chset and b is a range, and vice-versa, implements:
-//
-//          a | b, a & b, a - b, a ^ b
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator|(chset<CharT> const& a, range<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator&(chset<CharT> const& a, range<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator-(chset<CharT> const& a, range<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator^(chset<CharT> const& a, range<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator|(range<CharT> const& a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator&(range<CharT> const& a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator-(range<CharT> const& a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator^(range<CharT> const& a, chset<CharT> const& b);
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  chlit <--> chset free operators
-//
-//      Where a is a chset and b is a chlit, and vice-versa, implements:
-//
-//          a | b, a & b, a - b, a ^ b
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator|(chset<CharT> const& a, chlit<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator&(chset<CharT> const& a, chlit<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator-(chset<CharT> const& a, chlit<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator^(chset<CharT> const& a, chlit<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator|(chlit<CharT> const& a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator&(chlit<CharT> const& a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator-(chlit<CharT> const& a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator^(chlit<CharT> const& a, chset<CharT> const& b);
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  negated_char_parser<range> <--> chset free operators
-//
-//      Where a is a chset and b is a range, and vice-versa, implements:
-//
-//          a | b, a & b, a - b, a ^ b
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator|(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator&(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator-(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator^(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator|(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator&(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator-(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator^(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b);
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  negated_char_parser<chlit> <--> chset free operators
-//
-//      Where a is a chset and b is a chlit, and vice-versa, implements:
-//
-//          a | b, a & b, a - b, a ^ b
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator|(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator&(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator-(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator^(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator|(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator&(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator-(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator^(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b);
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  literal primitives <--> chset free operators
-//
-//      Where a is a chset and b is a literal primitive,
-//      and vice-versa, implements:
-//
-//          a | b, a & b, a - b, a ^ b
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator|(chset<CharT> const& a, CharT b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator&(chset<CharT> const& a, CharT b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator-(chset<CharT> const& a, CharT b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator^(chset<CharT> const& a, CharT b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator|(CharT a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator&(CharT a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator-(CharT a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator^(CharT a, chset<CharT> const& b);
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  anychar_parser <--> chset free operators
-//
-//      Where a is chset and b is a anychar_parser, and vice-versa, implements:
-//
-//          a | b, a & b, a - b, a ^ b
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator|(chset<CharT> const& a, anychar_parser b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator&(chset<CharT> const& a, anychar_parser b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator-(chset<CharT> const& a, anychar_parser b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator^(chset<CharT> const& a, anychar_parser b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator|(anychar_parser a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator&(anychar_parser a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator-(anychar_parser a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator^(anychar_parser a, chset<CharT> const& b);
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  nothing_parser <--> chset free operators
-//
-//      Where a is chset and b is nothing_parser, and vice-versa, implements:
-//
-//          a | b, a & b, a - b, a ^ b
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator|(chset<CharT> const& a, nothing_parser b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator&(chset<CharT> const& a, nothing_parser b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator-(chset<CharT> const& a, nothing_parser b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator^(chset<CharT> const& a, nothing_parser b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator|(nothing_parser a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator&(nothing_parser a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator-(nothing_parser a, chset<CharT> const& b);
-
-//////////////////////////////////
-template <typename CharT>
-chset<CharT>
-operator^(nothing_parser a, chset<CharT> const& b);
-
-///////////////////////////////////////////////////////////////////////////////
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
-#include <boost/spirit/home/classic/utility/impl/chset_operators.ipp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset.ipp b/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset.ipp
deleted file mode 100644
index 60a6c7f7f..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset.ipp
+++ /dev/null
@@ -1,322 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Joel de Guzman
-    Copyright (c) 2001-2003 Daniel Nuffer
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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_SPIRIT_CHSET_IPP
-#define BOOST_SPIRIT_CHSET_IPP
-
-///////////////////////////////////////////////////////////////////////////////
-#include <boost/limits.hpp>
-#include <boost/spirit/home/classic/utility/chset.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  chset class
-//
-///////////////////////////////////////////////////////////////////////////////
-namespace utility { namespace impl {
-    template <typename CharT>
-    inline void
-    detach(autoboost::shared_ptr<basic_chset<CharT> >& ptr)
-    {
-        if (!ptr.unique())
-            ptr = autoboost::shared_ptr<basic_chset<CharT> >
-                (new basic_chset<CharT>(*ptr));
-    }
-
-    template <typename CharT>
-    inline void
-    detach_clear(autoboost::shared_ptr<basic_chset<CharT> >& ptr)
-    {
-        if (ptr.unique())
-            ptr->clear();
-        else
-            ptr.reset(new basic_chset<CharT>());
-    }
-
-    template <typename CharT, typename CharT2>
-    void construct_chset(autoboost::shared_ptr<basic_chset<CharT> >& ptr,
-            CharT2 const* definition)
-    {
-        CharT2 ch = *definition++;
-        while (ch)
-        {
-            CharT2 next = *definition++;
-            if (next == '-')
-            {
-                next = *definition++;
-                if (next == 0)
-                {
-                    ptr->set(ch);
-                    ptr->set('-');
-                    break;
-                }
-                ptr->set(ch, next);
-            }
-            else
-            {
-                ptr->set(ch);
-            }
-            ch = next;
-        }
-    }
-
-}} // namespace utility::impl
-
-template <typename CharT>
-inline chset<CharT>::chset()
-: ptr(new basic_chset<CharT>()) {}
-
-template <typename CharT>
-inline chset<CharT>::chset(chset const& arg_)
-: ptr(new basic_chset<CharT>(*arg_.ptr)) {}
-
-template <typename CharT>
-inline chset<CharT>::chset(CharT arg_)
-: ptr(new basic_chset<CharT>())
-{ ptr->set(arg_); }
-
-template <typename CharT>
-inline chset<CharT>::chset(anychar_parser /*arg*/)
-: ptr(new basic_chset<CharT>())
-{
-    ptr->set(
-        (std::numeric_limits<CharT>::min)(),
-        (std::numeric_limits<CharT>::max)()
-    );
-}
-
-template <typename CharT>
-inline chset<CharT>::chset(nothing_parser arg_)
-: ptr(new basic_chset<CharT>()) {}
-
-template <typename CharT>
-inline chset<CharT>::chset(chlit<CharT> const& arg_)
-: ptr(new basic_chset<CharT>())
-{ ptr->set(arg_.ch); }
-
-template <typename CharT>
-inline chset<CharT>::chset(range<CharT> const& arg_)
-: ptr(new basic_chset<CharT>())
-{ ptr->set(arg_.first, arg_.last); }
-
-template <typename CharT>
-inline chset<CharT>::chset(negated_char_parser<chlit<CharT> > const& arg_)
-: ptr(new basic_chset<CharT>())
-{
-    set(arg_);
-}
-
-template <typename CharT>
-inline chset<CharT>::chset(negated_char_parser<range<CharT> > const& arg_)
-: ptr(new basic_chset<CharT>())
-{
-    set(arg_);
-}
-
-template <typename CharT>
-inline chset<CharT>::~chset() {}
-
-template <typename CharT>
-inline chset<CharT>&
-chset<CharT>::operator=(chset const& rhs)
-{
-    ptr = rhs.ptr;
-    return *this;
-}
-
-template <typename CharT>
-inline chset<CharT>&
-chset<CharT>::operator=(CharT rhs)
-{
-    utility::impl::detach_clear(ptr);
-    ptr->set(rhs);
-    return *this;
-}
-
-template <typename CharT>
-inline chset<CharT>&
-chset<CharT>::operator=(anychar_parser rhs)
-{
-    utility::impl::detach_clear(ptr);
-    ptr->set(
-        (std::numeric_limits<CharT>::min)(),
-        (std::numeric_limits<CharT>::max)()
-    );
-    return *this;
-}
-
-template <typename CharT>
-inline chset<CharT>&
-chset<CharT>::operator=(nothing_parser rhs)
-{
-    utility::impl::detach_clear(ptr);
-    return *this;
-}
-
-template <typename CharT>
-inline chset<CharT>&
-chset<CharT>::operator=(chlit<CharT> const& rhs)
-{
-    utility::impl::detach_clear(ptr);
-    ptr->set(rhs.ch);
-    return *this;
-}
-
-template <typename CharT>
-inline chset<CharT>&
-chset<CharT>::operator=(range<CharT> const& rhs)
-{
-    utility::impl::detach_clear(ptr);
-    ptr->set(rhs.first, rhs.last);
-    return *this;
-}
-
-template <typename CharT>
-inline chset<CharT>&
-chset<CharT>::operator=(negated_char_parser<chlit<CharT> > const& rhs)
-{
-    utility::impl::detach_clear(ptr);
-    set(rhs);
-    return *this;
-}
-
-template <typename CharT>
-inline chset<CharT>&
-chset<CharT>::operator=(negated_char_parser<range<CharT> > const& rhs)
-{
-    utility::impl::detach_clear(ptr);
-    set(rhs);
-    return *this;
-}
-
-template <typename CharT>
-inline void
-chset<CharT>::set(range<CharT> const& arg_)
-{
-    utility::impl::detach(ptr);
-    ptr->set(arg_.first, arg_.last);
-}
-
-template <typename CharT>
-inline void
-chset<CharT>::set(negated_char_parser<chlit<CharT> > const& arg_)
-{
-    utility::impl::detach(ptr);
-    
-    if(arg_.positive.ch != (std::numeric_limits<CharT>::min)()) {
-        ptr->set((std::numeric_limits<CharT>::min)(), arg_.positive.ch - 1);
-    }
-    if(arg_.positive.ch != (std::numeric_limits<CharT>::max)()) {
-        ptr->set(arg_.positive.ch + 1, (std::numeric_limits<CharT>::max)());
-    }
-}
-
-template <typename CharT>
-inline void
-chset<CharT>::set(negated_char_parser<range<CharT> > const& arg_)
-{
-    utility::impl::detach(ptr);
-    
-    if(arg_.positive.first != (std::numeric_limits<CharT>::min)()) {
-        ptr->set((std::numeric_limits<CharT>::min)(), arg_.positive.first - 1);
-    }
-    if(arg_.positive.last != (std::numeric_limits<CharT>::max)()) {
-        ptr->set(arg_.positive.last + 1, (std::numeric_limits<CharT>::max)());
-    }
-}
-
-template <typename CharT>
-inline void
-chset<CharT>::clear(range<CharT> const& arg_)
-{
-    utility::impl::detach(ptr);
-    ptr->clear(arg_.first, arg_.last);
-}
-
-template <typename CharT>
-inline void
-chset<CharT>::clear(negated_char_parser<range<CharT> > const& arg_)
-{
-    utility::impl::detach(ptr);
-
-    if(arg_.positive.first != (std::numeric_limits<CharT>::min)()) {
-        ptr->clear((std::numeric_limits<CharT>::min)(), arg_.positive.first - 1);
-    }
-    if(arg_.positive.last != (std::numeric_limits<CharT>::max)()) {
-        ptr->clear(arg_.positive.last + 1, (std::numeric_limits<CharT>::max)());
-    }
-}
-
-template <typename CharT>
-inline bool
-chset<CharT>::test(CharT ch) const
-{ return ptr->test(ch); }
-
-template <typename CharT>
-inline chset<CharT>&
-chset<CharT>::inverse()
-{
-    utility::impl::detach(ptr);
-    ptr->inverse();
-    return *this;
-}
-
-template <typename CharT>
-inline void
-chset<CharT>::swap(chset& x)
-{ ptr.swap(x.ptr); }
-
-template <typename CharT>
-inline chset<CharT>&
-chset<CharT>::operator|=(chset const& x)
-{
-    utility::impl::detach(ptr);
-    *ptr |= *x.ptr;
-    return *this;
-}
-
-template <typename CharT>
-inline chset<CharT>&
-chset<CharT>::operator&=(chset const& x)
-{
-    utility::impl::detach(ptr);
-    *ptr &= *x.ptr;
-    return *this;
-}
-
-template <typename CharT>
-inline chset<CharT>&
-chset<CharT>::operator-=(chset const& x)
-{
-    utility::impl::detach(ptr);
-    *ptr -= *x.ptr;
-    return *this;
-}
-
-template <typename CharT>
-inline chset<CharT>&
-chset<CharT>::operator^=(chset const& x)
-{
-    utility::impl::detach(ptr);
-    *ptr ^= *x.ptr;
-    return *this;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset/basic_chset.hpp b/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset/basic_chset.hpp
deleted file mode 100644
index f37e48b56..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset/basic_chset.hpp
+++ /dev/null
@@ -1,107 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Joel de Guzman
-    Copyright (c) 2001-2003 Daniel Nuffer
-    http://spirit.sourceforge.net/
-
-  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_SPIRIT_BASIC_CHSET_HPP
-#define BOOST_SPIRIT_BASIC_CHSET_HPP
-
-///////////////////////////////////////////////////////////////////////////////
-#include <bitset>
-#include <climits>
-#include <boost/spirit/home/classic/utility/impl/chset/range_run.hpp>
-#include <boost/spirit/home/classic/namespace.hpp>
-
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  basic_chset: basic character set implementation using range_run
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename CharT>
-    class basic_chset
-    {
-    public:
-                            basic_chset();
-                            basic_chset(basic_chset const& arg_);
-
-        bool                test(CharT v) const;
-        void                set(CharT from, CharT to);
-        void                set(CharT c);
-        void                clear(CharT from, CharT to);
-        void                clear(CharT c);
-        void                clear();
-
-        void                inverse();
-        void                swap(basic_chset& x);
-
-        basic_chset&        operator|=(basic_chset const& x);
-        basic_chset&        operator&=(basic_chset const& x);
-        basic_chset&        operator-=(basic_chset const& x);
-        basic_chset&        operator^=(basic_chset const& x);
-
-        private: utility::impl::range_run<CharT> rr;
-    };
-
-    #if (CHAR_BIT == 8)
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  basic_chset: specializations for 8 bit chars using std::bitset
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename CharT>
-    class basic_chset_8bit {
-
-    public:
-                            basic_chset_8bit();
-                            basic_chset_8bit(basic_chset_8bit const& arg_);
-
-        bool                test(CharT v) const;
-        void                set(CharT from, CharT to);
-        void                set(CharT c);
-        void                clear(CharT from, CharT to);
-        void                clear(CharT c);
-        void                clear();
-
-        void                inverse();
-        void                swap(basic_chset_8bit& x);
-
-        basic_chset_8bit&   operator|=(basic_chset_8bit const& x);
-        basic_chset_8bit&   operator&=(basic_chset_8bit const& x);
-        basic_chset_8bit&   operator-=(basic_chset_8bit const& x);
-        basic_chset_8bit&   operator^=(basic_chset_8bit const& x);
-
-        private: std::bitset<256> bset;
-    };
-
-    /////////////////////////////////
-    template <>
-    class basic_chset<char>
-    : public basic_chset_8bit<char> {};
-
-    /////////////////////////////////
-    template <>
-    class basic_chset<signed char>
-    : public basic_chset_8bit<signed char> {};
-
-    /////////////////////////////////
-    template <>
-    class basic_chset<unsigned char>
-    : public basic_chset_8bit<unsigned char> {};
-
-#endif
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS
-
-#endif
-
-#include <boost/spirit/home/classic/utility/impl/chset/basic_chset.ipp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset/basic_chset.ipp b/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset/basic_chset.ipp
deleted file mode 100644
index 212bff02d..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset/basic_chset.ipp
+++ /dev/null
@@ -1,246 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Joel de Guzman
-    Copyright (c) 2001-2003 Daniel Nuffer
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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_SPIRIT_BASIC_CHSET_IPP
-#define BOOST_SPIRIT_BASIC_CHSET_IPP
-
-///////////////////////////////////////////////////////////////////////////////
-#include <bitset>
-#include <boost/spirit/home/classic/utility/impl/chset/basic_chset.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  basic_chset: character set implementation
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-inline basic_chset<CharT>::basic_chset() {}
-
-//////////////////////////////////
-template <typename CharT>
-inline basic_chset<CharT>::basic_chset(basic_chset const& arg_)
-: rr(arg_.rr) {}
-
-//////////////////////////////////
-template <typename CharT>
-inline bool
-basic_chset<CharT>::test(CharT v) const
-{ return rr.test(v); }
-
-//////////////////////////////////
-template <typename CharT>
-inline void
-basic_chset<CharT>::set(CharT from, CharT to)
-{ rr.set(utility::impl::range<CharT>(from, to)); }
-
-//////////////////////////////////
-template <typename CharT>
-inline void
-basic_chset<CharT>::set(CharT c)
-{ rr.set(utility::impl::range<CharT>(c, c)); }
-
-//////////////////////////////////
-template <typename CharT>
-inline void
-basic_chset<CharT>::clear(CharT from, CharT to)
-{ rr.clear(utility::impl::range<CharT>(from, to)); }
-
-//////////////////////////////////
-template <typename CharT>
-inline void
-basic_chset<CharT>::clear()
-{ rr.clear(); }
-
-/////////////////////////////////
-template <typename CharT>
-inline void
-basic_chset<CharT>::inverse()
-{
-    basic_chset inv;
-    inv.set(
-        (std::numeric_limits<CharT>::min)(),
-        (std::numeric_limits<CharT>::max)()
-    );
-    inv -= *this;
-    swap(inv);
-}
-
-/////////////////////////////////
-template <typename CharT>
-inline void
-basic_chset<CharT>::swap(basic_chset& x)
-{ rr.swap(x.rr); }
-
-/////////////////////////////////
-template <typename CharT>
-inline basic_chset<CharT>&
-basic_chset<CharT>::operator|=(basic_chset<CharT> const& x)
-{
-    typedef typename utility::impl::range_run<CharT>::const_iterator const_iterator;
-    for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter)
-        rr.set(*iter);
-    return *this;
-}
-
-/////////////////////////////////
-template <typename CharT>
-inline basic_chset<CharT>&
-basic_chset<CharT>::operator&=(basic_chset<CharT> const& x)
-{
-    basic_chset inv;
-    inv.set(
-        (std::numeric_limits<CharT>::min)(),
-        (std::numeric_limits<CharT>::max)()
-    );
-    inv -= x;
-    *this -= inv;
-    return *this;
-}
-
-/////////////////////////////////
-template <typename CharT>
-inline basic_chset<CharT>&
-basic_chset<CharT>::operator-=(basic_chset<CharT> const& x)
-{
-    typedef typename utility::impl::range_run<CharT>::const_iterator const_iterator;
-    for (const_iterator iter = x.rr.begin(); iter != x.rr.end(); ++iter)
-        rr.clear(*iter);
-    return *this;
-}
-
-/////////////////////////////////
-template <typename CharT>
-inline basic_chset<CharT>&
-basic_chset<CharT>::operator^=(basic_chset<CharT> const& x)
-{
-    basic_chset bma = x;
-    bma -= *this;
-    *this -= x;
-    *this |= bma;
-    return *this;
-}
-
-#if (CHAR_BIT == 8)
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  basic_chset: specializations for 8 bit chars using std::bitset
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-inline basic_chset_8bit<CharT>::basic_chset_8bit() {}
-
-/////////////////////////////////
-template <typename CharT>
-inline basic_chset_8bit<CharT>::basic_chset_8bit(basic_chset_8bit const& arg_)
-: bset(arg_.bset) {}
-
-/////////////////////////////////
-template <typename CharT>
-inline bool
-basic_chset_8bit<CharT>::test(CharT v) const
-{ return bset.test((unsigned char)v); }
-
-/////////////////////////////////
-template <typename CharT>
-inline void
-basic_chset_8bit<CharT>::set(CharT from, CharT to)
-{
-    for (int i = from; i <= to; ++i)
-        bset.set((unsigned char)i);
-}
-
-/////////////////////////////////
-template <typename CharT>
-inline void
-basic_chset_8bit<CharT>::set(CharT c)
-{ bset.set((unsigned char)c); }
-
-/////////////////////////////////
-template <typename CharT>
-inline void
-basic_chset_8bit<CharT>::clear(CharT from, CharT to)
-{
-    for (int i = from; i <= to; ++i)
-        bset.reset((unsigned char)i);
-}
-
-/////////////////////////////////
-template <typename CharT>
-inline void
-basic_chset_8bit<CharT>::clear(CharT c)
-{ bset.reset((unsigned char)c); }
-
-/////////////////////////////////
-template <typename CharT>
-inline void
-basic_chset_8bit<CharT>::clear()
-{ bset.reset(); }
-
-/////////////////////////////////
-template <typename CharT>
-inline void
-basic_chset_8bit<CharT>::inverse()
-{ bset.flip(); }
-
-/////////////////////////////////
-template <typename CharT>
-inline void
-basic_chset_8bit<CharT>::swap(basic_chset_8bit& x)
-{ std::swap(bset, x.bset); }
-
-/////////////////////////////////
-template <typename CharT>
-inline basic_chset_8bit<CharT>&
-basic_chset_8bit<CharT>::operator|=(basic_chset_8bit const& x)
-{
-    bset |= x.bset;
-    return *this;
-}
-
-/////////////////////////////////
-template <typename CharT>
-inline basic_chset_8bit<CharT>&
-basic_chset_8bit<CharT>::operator&=(basic_chset_8bit const& x)
-{
-    bset &= x.bset;
-    return *this;
-}
-
-/////////////////////////////////
-template <typename CharT>
-inline basic_chset_8bit<CharT>&
-basic_chset_8bit<CharT>::operator-=(basic_chset_8bit const& x)
-{
-    bset &= ~x.bset;
-    return *this;
-}
-
-/////////////////////////////////
-template <typename CharT>
-inline basic_chset_8bit<CharT>&
-basic_chset_8bit<CharT>::operator^=(basic_chset_8bit const& x)
-{
-    bset ^= x.bset;
-    return *this;
-}
-
-#endif
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset/range_run.hpp b/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset/range_run.hpp
deleted file mode 100644
index 5c0073a44..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset/range_run.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-  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_SPIRIT_RANGE_RUN_HPP
-#define BOOST_SPIRIT_RANGE_RUN_HPP
-
-///////////////////////////////////////////////////////////////////////////////
-#include <vector>
-
-#include <boost/spirit/home/classic/namespace.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-namespace autoboost { namespace spirit { 
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-namespace utility { namespace impl {
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  range class
-    //
-    //      Implements a closed range of values. This class is used in
-    //      the implementation of the range_run class.
-    //
-    //      { Low level implementation detail }
-    //      { Not to be confused with BOOST_SPIRIT_CLASSIC_NS::range }
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename CharT>
-    struct range {
-
-                        range(CharT first, CharT last);
-
-        bool            is_valid() const;
-        bool            includes(CharT v) const;
-        bool            includes(range const& r) const;
-        bool            overlaps(range const& r) const;
-        void            merge(range const& r);
-
-        CharT first;
-        CharT last;
-    };
-
-    //////////////////////////////////
-    template <typename CharT>
-    struct range_char_compare {
-
-        bool operator()(range<CharT> const& x, const CharT y) const
-        { return x.first < y; }
-        
-        bool operator()(const CharT x, range<CharT> const& y) const
-        { return x < y.first; }
-        
-        // This additional operator is required for the checked STL shipped
-        // with VC8 testing the ordering of the iterators passed to the
-        // std::lower_bound algo this range_char_compare<> predicate is passed
-        // to.
-        bool operator()(range<CharT> const& x, range<CharT> const& y) const
-        { return x.first < y.first; }
-    };
-
-    //////////////////////////////////
-    template <typename CharT>
-    struct range_compare {
-
-        bool operator()(range<CharT> const& x, range<CharT> const& y) const
-        { return x.first < y.first; }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-    //
-    //  range_run
-    //
-    //      An implementation of a sparse bit (boolean) set. The set uses
-    //      a sorted vector of disjoint ranges. This class implements the
-    //      bare minimum essentials from which the full range of set
-    //      operators can be implemented. The set is constructed from
-    //      ranges. Internally, adjacent or overlapping ranges are
-    //      coalesced.
-    //
-    //      range_runs are very space-economical in situations where there
-    //      are lots of ranges and a few individual disjoint values.
-    //      Searching is O(log n) where n is the number of ranges.
-    //
-    //      { Low level implementation detail }
-    //
-    ///////////////////////////////////////////////////////////////////////////
-    template <typename CharT>
-    class range_run {
-
-    public:
-
-        typedef range<CharT> range_t;
-        typedef std::vector<range_t> run_t;
-        typedef typename run_t::iterator iterator;
-        typedef typename run_t::const_iterator const_iterator;
-
-        void            swap(range_run& rr);
-        bool            test(CharT v) const;
-        void            set(range_t const& r);
-        void            clear(range_t const& r);
-        void            clear();
-
-        const_iterator  begin() const;
-        const_iterator  end() const;
-
-    private:
-
-        void            merge(iterator iter, range_t const& r);
-
-        run_t run;
-    };
-
-}}
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace BOOST_SPIRIT_CLASSIC_NS::utility::impl
-
-#endif
-
-#include <boost/spirit/home/classic/utility/impl/chset/range_run.ipp>
diff --git a/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset/range_run.ipp b/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset/range_run.ipp
deleted file mode 100644
index 16bbc3350..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset/range_run.ipp
+++ /dev/null
@@ -1,218 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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_SPIRIT_RANGE_RUN_IPP
-#define BOOST_SPIRIT_RANGE_RUN_IPP
-
-///////////////////////////////////////////////////////////////////////////////
-#include <algorithm> // for std::lower_bound
-#include <boost/spirit/home/classic/core/assert.hpp> // for BOOST_SPIRIT_ASSERT
-#include <boost/spirit/home/classic/utility/impl/chset/range_run.hpp>
-#include <boost/spirit/home/classic/debug.hpp>
-#include <boost/limits.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-    namespace utility { namespace impl {
-
-        ///////////////////////////////////////////////////////////////////////
-        //
-        //  range class implementation
-        //
-        ///////////////////////////////////////////////////////////////////////
-        template <typename CharT>
-        inline range<CharT>::range(CharT first_, CharT last_)
-        : first(first_), last(last_) {}
-
-        //////////////////////////////////
-        template <typename CharT>
-        inline bool
-        range<CharT>::is_valid() const
-        { return first <= last; }
-
-        //////////////////////////////////
-        template <typename CharT>
-        inline bool
-        range<CharT>::includes(range const& r) const
-        { return (first <= r.first) && (last >= r.last); }
-
-        //////////////////////////////////
-        template <typename CharT>
-        inline bool
-        range<CharT>::includes(CharT v) const
-        { return (first <= v) && (last >= v); }
-
-        //////////////////////////////////
-        template <typename CharT>
-        inline bool
-        range<CharT>::overlaps(range const& r) const
-        {
-            CharT decr_first =
-                first == (std::numeric_limits<CharT>::min)() ? first : first-1;
-            CharT incr_last =
-                last == (std::numeric_limits<CharT>::max)() ? last : last+1;
-
-            return (decr_first <= r.last) && (incr_last >= r.first);
-        }
-
-        //////////////////////////////////
-        template <typename CharT>
-        inline void
-        range<CharT>::merge(range const& r)
-        {
-            first = (std::min)(first, r.first);
-            last = (std::max)(last, r.last);
-        }
-
-        ///////////////////////////////////////////////////////////////////////
-        //
-        //  range_run class implementation
-        //
-        ///////////////////////////////////////////////////////////////////////
-        template <typename CharT>
-        inline bool
-        range_run<CharT>::test(CharT v) const
-        {
-            if (!run.empty())
-            {
-                const_iterator iter =
-                    std::lower_bound(
-                        run.begin(), run.end(), v,
-                        range_char_compare<CharT>()
-                    );
-
-                if (iter != run.end() && iter->includes(v))
-                    return true;
-                if (iter != run.begin())
-                    return (--iter)->includes(v);
-            }
-            return false;
-        }
-
-        //////////////////////////////////
-        template <typename CharT>
-        inline void
-        range_run<CharT>::swap(range_run& rr)
-        { run.swap(rr.run); }
-
-        //////////////////////////////////
-        template <typename CharT>
-        void
-        range_run<CharT>::merge(iterator iter, range<CharT> const& r)
-        {
-            iter->merge(r);
-            iterator i = iter + 1;
-
-            while (i != run.end() && iter->overlaps(*i))
-                iter->merge(*i++);
-
-            run.erase(iter+1, i);
-        }
-
-        //////////////////////////////////
-        template <typename CharT>
-        void
-        range_run<CharT>::set(range<CharT> const& r)
-        {
-            BOOST_SPIRIT_ASSERT(r.is_valid());
-            if (!run.empty())
-            {
-                iterator iter =
-                    std::lower_bound(
-                        run.begin(), run.end(), r,
-                        range_compare<CharT>()
-                    );
-
-                if ((iter != run.end() && iter->includes(r)) ||
-                    ((iter != run.begin()) && (iter - 1)->includes(r)))
-                    return;
-
-                if (iter != run.begin() && (iter - 1)->overlaps(r))
-                    merge(--iter, r);
-
-                else if (iter != run.end() && iter->overlaps(r))
-                    merge(iter, r);
-
-                else
-                    run.insert(iter, r);
-            }
-            else
-            {
-                run.push_back(r);
-            }
-        }
-
-        //////////////////////////////////
-        template <typename CharT>
-        void
-        range_run<CharT>::clear(range<CharT> const& r)
-        {
-            BOOST_SPIRIT_ASSERT(r.is_valid());
-            if (!run.empty())
-            {
-                iterator iter =
-                    std::lower_bound(
-                        run.begin(), run.end(), r,
-                        range_compare<CharT>()
-                    );
-
-                iterator left_iter;
-
-                if ((iter != run.begin()) &&
-                        (left_iter = (iter - 1))->includes(r.first))
-                {
-                    if (left_iter->last > r.last)
-                    {
-                        CharT save_last = left_iter->last;
-                        left_iter->last = r.first-1;
-                        run.insert(iter, range<CharT>(r.last+1, save_last));
-                        return;
-                    }
-                    else
-                    {
-                        left_iter->last = r.first-1;
-                    }
-                }
-                
-                iterator i = iter;
-                while (i != run.end() && r.includes(*i))
-                    i++;
-                if (i != run.end() && i->includes(r.last))
-                    i->first = r.last+1;
-                run.erase(iter, i);
-            }
-        }
-
-        //////////////////////////////////
-        template <typename CharT>
-        inline void
-        range_run<CharT>::clear()
-        { run.clear(); }
-
-        //////////////////////////////////
-        template <typename CharT>
-        inline typename range_run<CharT>::const_iterator
-        range_run<CharT>::begin() const
-        { return run.begin(); }
-
-        //////////////////////////////////
-        template <typename CharT>
-        inline typename range_run<CharT>::const_iterator
-        range_run<CharT>::end() const
-        { return run.end(); }
-
-    }} // namespace utility::impl
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
diff --git a/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset_operators.ipp b/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset_operators.ipp
deleted file mode 100644
index 682621dce..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/utility/impl/chset_operators.ipp
+++ /dev/null
@@ -1,592 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Joel de Guzman
-    http://spirit.sourceforge.net/
-
-    Use, modification and distribution is subject to 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_SPIRIT_CHSET_OPERATORS_IPP
-#define BOOST_SPIRIT_CHSET_OPERATORS_IPP
-
-///////////////////////////////////////////////////////////////////////////////
-#include <boost/limits.hpp>
-
-///////////////////////////////////////////////////////////////////////////////
-namespace autoboost { namespace spirit {
-
-BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  chset free operators implementation
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator|(chset<CharT> const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) |= b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator-(chset<CharT> const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) -= b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator~(chset<CharT> const& a)
-{
-    return chset<CharT>(a).inverse();
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator&(chset<CharT> const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) &= b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator^(chset<CharT> const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) ^= b;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  range <--> chset free operators implementation
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator|(chset<CharT> const& a, range<CharT> const& b)
-{
-    chset<CharT> a_(a);
-    a_.set(b);
-    return a_;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator&(chset<CharT> const& a, range<CharT> const& b)
-{
-    chset<CharT> a_(a);
-    if(b.first != (std::numeric_limits<CharT>::min)()) {
-        a_.clear(range<CharT>((std::numeric_limits<CharT>::min)(), b.first - 1));
-    }
-    if(b.last != (std::numeric_limits<CharT>::max)()) {
-        a_.clear(range<CharT>(b.last + 1, (std::numeric_limits<CharT>::max)()));
-    }
-    return a_;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator-(chset<CharT> const& a, range<CharT> const& b)
-{
-    chset<CharT> a_(a);
-    a_.clear(b);
-    return a_;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator^(chset<CharT> const& a, range<CharT> const& b)
-{
-    return a ^ chset<CharT>(b);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator|(range<CharT> const& a, chset<CharT> const& b)
-{
-    chset<CharT> b_(b);
-    b_.set(a);
-    return b_;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator&(range<CharT> const& a, chset<CharT> const& b)
-{
-    chset<CharT> b_(b);
-    if(a.first != (std::numeric_limits<CharT>::min)()) {
-        b_.clear(range<CharT>((std::numeric_limits<CharT>::min)(), a.first - 1));
-    }
-    if(a.last != (std::numeric_limits<CharT>::max)()) {
-        b_.clear(range<CharT>(a.last + 1, (std::numeric_limits<CharT>::max)()));
-    }
-    return b_;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator-(range<CharT> const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) - b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator^(range<CharT> const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) ^ b;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  literal primitives <--> chset free operators implementation
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator|(chset<CharT> const& a, CharT b)
-{
-    return a | chset<CharT>(b);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator&(chset<CharT> const& a, CharT b)
-{
-    return a & chset<CharT>(b);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator-(chset<CharT> const& a, CharT b)
-{
-    return a - chset<CharT>(b);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator^(chset<CharT> const& a, CharT b)
-{
-    return a ^ chset<CharT>(b);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator|(CharT a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) | b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator&(CharT a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) & b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator-(CharT a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) - b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator^(CharT a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) ^ b;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  chlit <--> chset free operators implementation
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator|(chset<CharT> const& a, chlit<CharT> const& b)
-{
-    return a | chset<CharT>(b.ch);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator&(chset<CharT> const& a, chlit<CharT> const& b)
-{
-    return a & chset<CharT>(b.ch);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator-(chset<CharT> const& a, chlit<CharT> const& b)
-{
-    return a - chset<CharT>(b.ch);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator^(chset<CharT> const& a, chlit<CharT> const& b)
-{
-    return a ^ chset<CharT>(b.ch);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator|(chlit<CharT> const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a.ch) | b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator&(chlit<CharT> const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a.ch) & b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator-(chlit<CharT> const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a.ch) - b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator^(chlit<CharT> const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a.ch) ^ b;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  negated_char_parser<range> <--> chset free operators implementation
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator|(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
-{
-    return a | chset<CharT>(b);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator&(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
-{
-    return a & chset<CharT>(b);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator-(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
-{
-    return a - chset<CharT>(b);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator^(chset<CharT> const& a, negated_char_parser<range<CharT> > const& b)
-{
-    return a ^ chset<CharT>(b);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator|(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) | b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator&(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) & b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator-(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) - b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator^(negated_char_parser<range<CharT> > const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) ^ b;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  negated_char_parser<chlit> <--> chset free operators implementation
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator|(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
-{
-    return a | chset<CharT>(b);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator&(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
-{
-    return a & chset<CharT>(b);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator-(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
-{
-    return a - chset<CharT>(b);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator^(chset<CharT> const& a, negated_char_parser<chlit<CharT> > const& b)
-{
-    return a ^ chset<CharT>(b);
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator|(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) | b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator&(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) & b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator-(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) - b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator^(negated_char_parser<chlit<CharT> > const& a, chset<CharT> const& b)
-{
-    return chset<CharT>(a) ^ b;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  anychar_parser <--> chset free operators
-//
-//      Where a is chset and b is a anychar_parser, and vice-versa, implements:
-//
-//          a | b, a & b, a - b, a ^ b
-//
-///////////////////////////////////////////////////////////////////////////////
-namespace impl {
-
-    template <typename CharT>
-    inline BOOST_SPIRIT_CLASSIC_NS::range<CharT> const&
-    full()
-    {
-        static BOOST_SPIRIT_CLASSIC_NS::range<CharT> full_(
-            (std::numeric_limits<CharT>::min)(),
-            (std::numeric_limits<CharT>::max)());
-        return full_;
-    }
-
-    template <typename CharT>
-    inline BOOST_SPIRIT_CLASSIC_NS::range<CharT> const&
-    empty()
-    {
-        static BOOST_SPIRIT_CLASSIC_NS::range<CharT> empty_;
-        return empty_;
-    }
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator|(chset<CharT> const&, anychar_parser)
-{
-    return chset<CharT>(impl::full<CharT>());
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator&(chset<CharT> const& a, anychar_parser)
-{
-    return a;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator-(chset<CharT> const&, anychar_parser)
-{
-    return chset<CharT>();
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator^(chset<CharT> const& a, anychar_parser)
-{
-    return ~a;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator|(anychar_parser, chset<CharT> const& /*b*/)
-{
-    return chset<CharT>(impl::full<CharT>());
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator&(anychar_parser, chset<CharT> const& b)
-{
-    return b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator-(anychar_parser, chset<CharT> const& b)
-{
-    return ~b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator^(anychar_parser, chset<CharT> const& b)
-{
-    return ~b;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  nothing_parser <--> chset free operators implementation
-//
-///////////////////////////////////////////////////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator|(chset<CharT> const& a, nothing_parser)
-{
-    return a;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator&(chset<CharT> const& /*a*/, nothing_parser)
-{
-    return impl::empty<CharT>();
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator-(chset<CharT> const& a, nothing_parser)
-{
-    return a;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator^(chset<CharT> const& a, nothing_parser)
-{
-    return a;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator|(nothing_parser, chset<CharT> const& b)
-{
-    return b;
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator&(nothing_parser, chset<CharT> const& /*b*/)
-{
-    return impl::empty<CharT>();
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator-(nothing_parser, chset<CharT> const& /*b*/)
-{
-    return impl::empty<CharT>();
-}
-
-//////////////////////////////////
-template <typename CharT>
-inline chset<CharT>
-operator^(nothing_parser, chset<CharT> const& b)
-{
-    return b;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-BOOST_SPIRIT_CLASSIC_NAMESPACE_END
-
-}} // namespace autoboost::spirit
-
-#endif
-
diff --git a/contrib/autoboost/boost/spirit/home/classic/version.hpp b/contrib/autoboost/boost/spirit/home/classic/version.hpp
deleted file mode 100644
index 77371ed37..000000000
--- a/contrib/autoboost/boost/spirit/home/classic/version.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2003 Hartmut Kaiser
-    http://spirit.sourceforge.net/
-
-  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)
-=============================================================================*/
-#if !defined(SPIRIT_CLASSIC_VERSION_HPP)
-#define SPIRIT_CLASSIC_VERSION_HPP
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  This checks, whether the used Boost library is at least V1.32.0
-//
-///////////////////////////////////////////////////////////////////////////////
-#include <boost/version.hpp>
-
-#if BOOST_VERSION < 103200
-#error "Spirit v1.8.x needs at least Boost V1.32.0 to compile successfully."
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//  This is the version of the current Spirit distribution
-//
-///////////////////////////////////////////////////////////////////////////////
-#define SPIRIT_VERSION 0x1806
-#define SPIRIT_PIZZA_VERSION SPIRIT_MEGA_VEGGI  // :-)
-
-#endif // defined(SPIRIT_VERSION_HPP)
diff --git a/contrib/autoboost/boost/spirit/include/classic_actions.hpp b/contrib/autoboost/boost/spirit/include/classic_actions.hpp
deleted file mode 100644
index a37d631b5..000000000
--- a/contrib/autoboost/boost/spirit/include/classic_actions.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-/*=============================================================================
-  Copyright (c) 2001-2008 Joel de Guzman
-  Copyright (c) 2001-2008 Hartmut Kaiser
-  http://spirit.sourceforge.net/
-
-  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_SPIRIT_INCLUDE_CLASSIC_CLASSIC_ACTIONS
-#define BOOST_SPIRIT_INCLUDE_CLASSIC_CLASSIC_ACTIONS
-#include <boost/spirit/home/classic/core/composite/actions.hpp>
-#endif
diff --git a/contrib/autoboost/boost/spirit/include/classic_chset.hpp b/contrib/autoboost/boost/spirit/include/classic_chset.hpp
deleted file mode 100644
index 2f8df490d..000000000
--- a/contrib/autoboost/boost/spirit/include/classic_chset.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-/*=============================================================================
-  Copyright (c) 2001-2008 Joel de Guzman
-  Copyright (c) 2001-2008 Hartmut Kaiser
-  http://spirit.sourceforge.net/
-
-  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_SPIRIT_INCLUDE_CLASSIC_CHSET
-#define BOOST_SPIRIT_INCLUDE_CLASSIC_CHSET
-#include <boost/spirit/home/classic/utility/chset.hpp>
-#endif
diff --git a/contrib/autoboost/boost/spirit/include/classic_numerics.hpp b/contrib/autoboost/boost/spirit/include/classic_numerics.hpp
deleted file mode 100644
index 75f7c053b..000000000
--- a/contrib/autoboost/boost/spirit/include/classic_numerics.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-/*=============================================================================
-  Copyright (c) 2001-2008 Joel de Guzman
-  Copyright (c) 2001-2008 Hartmut Kaiser
-  http://spirit.sourceforge.net/
-
-  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_SPIRIT_INCLUDE_CLASSIC_NUMERICS
-#define BOOST_SPIRIT_INCLUDE_CLASSIC_NUMERICS
-#include <boost/spirit/home/classic/core/primitives/numerics.hpp>
-#endif
diff --git a/contrib/autoboost/boost/spirit/include/classic_operators.hpp b/contrib/autoboost/boost/spirit/include/classic_operators.hpp
deleted file mode 100644
index c05d94779..000000000
--- a/contrib/autoboost/boost/spirit/include/classic_operators.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-/*=============================================================================
-  Copyright (c) 2001-2008 Joel de Guzman
-  Copyright (c) 2001-2008 Hartmut Kaiser
-  http://spirit.sourceforge.net/
-
-  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_SPIRIT_INCLUDE_CLASSIC_OPERATORS
-#define BOOST_SPIRIT_INCLUDE_CLASSIC_OPERATORS
-#include <boost/spirit/home/classic/core/composite/operators.hpp>
-#endif
diff --git a/contrib/autoboost/boost/spirit/include/classic_rule.hpp b/contrib/autoboost/boost/spirit/include/classic_rule.hpp
deleted file mode 100644
index c2e0df1d3..000000000
--- a/contrib/autoboost/boost/spirit/include/classic_rule.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-/*=============================================================================
-  Copyright (c) 2001-2008 Joel de Guzman
-  Copyright (c) 2001-2008 Hartmut Kaiser
-  http://spirit.sourceforge.net/
-
-  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_SPIRIT_INCLUDE_CLASSIC_RULE
-#define BOOST_SPIRIT_INCLUDE_CLASSIC_RULE
-#include <boost/spirit/home/classic/core/non_terminal/rule.hpp>
-#endif
diff --git a/contrib/autoboost/boost/test/debug.hpp b/contrib/autoboost/boost/test/debug.hpp
deleted file mode 100644
index 90e4b6e60..000000000
--- a/contrib/autoboost/boost/test/debug.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2006-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines portable debug interfaces
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DEBUG_API_HPP_112006GER
-#define BOOST_TEST_DEBUG_API_HPP_112006GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/utils/callback.hpp>
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-
-// STL
-#include <string>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace debug {
-
-// ************************************************************************** //
-// **************  check if program is running under debugger  ************** //
-// ************************************************************************** //
-
-bool BOOST_TEST_DECL under_debugger();
-
-// ************************************************************************** //
-// **************       cause program to break execution       ************** //
-// **************           in debugger at call point          ************** //
-// ************************************************************************** //
-
-void BOOST_TEST_DECL debugger_break();
-
-// ************************************************************************** //
-// **************              gui debugger setup              ************** //
-// ************************************************************************** //
-
-struct dbg_startup_info {
-    long                    pid;
-    bool                    break_or_continue;
-    unit_test::const_string binary_path;
-    unit_test::const_string display;
-    unit_test::const_string init_done_lock;
-};
-
-typedef unit_test::callback1<dbg_startup_info const&> dbg_starter;
-
-// ************************************************************************** //
-// **************                debugger setup                ************** //
-// ************************************************************************** //
-
-#if BOOST_WORKAROUND( BOOST_MSVC, <1300)
-
-std::string BOOST_TEST_DECL set_debugger( unit_test::const_string dbg_id );
-
-#else 
-
-std::string BOOST_TEST_DECL set_debugger( unit_test::const_string dbg_id, dbg_starter s = dbg_starter() );
-
-#endif
-
-
-// ************************************************************************** //
-// **************    attach debugger to the current process    ************** //
-// ************************************************************************** //
-
-bool BOOST_TEST_DECL attach_debugger( bool break_or_continue = true );
-
-// ************************************************************************** //
-// **************   switch on/off detect memory leaks feature  ************** //
-// ************************************************************************** //
-
-void BOOST_TEST_DECL detect_memory_leaks( bool on_off );
-
-// ************************************************************************** //
-// **************      cause program to break execution in     ************** //
-// **************     debugger at specific allocation point    ************** //
-// ************************************************************************** //
-
-void BOOST_TEST_DECL break_memory_alloc( long mem_alloc_order_num );
-
-} // namespace debug
-
-} // namespace autoboost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif
diff --git a/contrib/autoboost/boost/test/debug_config.hpp b/contrib/autoboost/boost/test/debug_config.hpp
deleted file mode 100644
index 17f41a60a..000000000
--- a/contrib/autoboost/boost/test/debug_config.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2006-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : user's config for Boost.Test debugging support
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DEBUG_CONFIG_HPP_112006GER
-#define BOOST_TEST_DEBUG_CONFIG_HPP_112006GER
-
-// ';' separated list of supported debuggers
-// #define BOOST_TEST_DBG_LIST gdb;dbx
-
-// maximum size of /proc/pid/stat file
-// #define BOOST_TEST_STAT_LINE_MAX
-
-#endif
diff --git a/contrib/autoboost/boost/test/detail/config.hpp b/contrib/autoboost/boost/test/detail/config.hpp
deleted file mode 100644
index 4b12f0399..000000000
--- a/contrib/autoboost/boost/test/detail/config.hpp
+++ /dev/null
@@ -1,104 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : as a central place for global configuration switches
-// ***************************************************************************
-
-#ifndef BOOST_TEST_CONFIG_HPP_071894GER
-#define BOOST_TEST_CONFIG_HPP_071894GER
-
-// Boost
-#include <boost/config.hpp> // compilers workarounds
-#include <boost/detail/workaround.hpp>
-
-//____________________________________________________________________________//
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)) || \
-    BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))     || \
-    (defined __sgi && BOOST_WORKAROUND(_COMPILER_VERSION, BOOST_TESTED_AT(730)))
-#  define BOOST_TEST_SHIFTED_LINE
-#endif
-
-//____________________________________________________________________________//
-
-#if defined(BOOST_MSVC) || (defined(__BORLANDC__) && !defined(BOOST_DISABLE_WIN32))
-#  define BOOST_TEST_CALL_DECL __cdecl
-#else
-#  define BOOST_TEST_CALL_DECL /**/
-#endif
-
-//____________________________________________________________________________//
-
-#if !defined(BOOST_NO_STD_LOCALE) &&            \
-    !BOOST_WORKAROUND(BOOST_MSVC, < 1310)  &&   \
-    !defined(__MWERKS__) 
-#  define BOOST_TEST_USE_STD_LOCALE 1
-#endif
-
-//____________________________________________________________________________//
-
-#if BOOST_WORKAROUND(__BORLANDC__, <= 0x570)            || \
-    BOOST_WORKAROUND( __COMO__, <= 0x433 )              || \
-    BOOST_WORKAROUND( __INTEL_COMPILER, <= 800 )        || \
-    defined(__sgi) && _COMPILER_VERSION <= 730          || \
-    BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))  || \
-    defined(__DECCXX)                                   || \
-    defined(__DMC__)
-#  define BOOST_TEST_NO_PROTECTED_USING
-#endif
-
-//____________________________________________________________________________//
-
-#if defined(__GNUC__) || BOOST_WORKAROUND(BOOST_MSVC, == 1400)
-#define BOOST_TEST_PROTECTED_VIRTUAL virtual
-#else
-#define BOOST_TEST_PROTECTED_VIRTUAL
-#endif
-
-//____________________________________________________________________________//
-
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
-    !BOOST_WORKAROUND(BOOST_MSVC, <1310) && \
-    !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x530))
-#  define BOOST_TEST_SUPPORT_INTERACTION_TESTING 1
-#endif
-
-//____________________________________________________________________________//
-
-#if defined(BOOST_ALL_DYN_LINK) && !defined(BOOST_TEST_DYN_LINK)
-#  define BOOST_TEST_DYN_LINK
-#endif
-
-#if defined(BOOST_TEST_INCLUDED)
-#  undef BOOST_TEST_DYN_LINK
-#endif
-
-#if defined(BOOST_TEST_DYN_LINK)
-#  define BOOST_TEST_ALTERNATIVE_INIT_API
-
-#  ifdef BOOST_TEST_SOURCE
-#    define BOOST_TEST_DECL BOOST_SYMBOL_EXPORT
-#  else
-#    define BOOST_TEST_DECL BOOST_SYMBOL_IMPORT
-#  endif  // BOOST_TEST_SOURCE
-#else
-#  define BOOST_TEST_DECL
-#endif
-
-#if !defined(BOOST_TEST_MAIN) && defined(BOOST_AUTO_TEST_MAIN)
-#define BOOST_TEST_MAIN BOOST_AUTO_TEST_MAIN
-#endif
-
-#if !defined(BOOST_TEST_MAIN) && defined(BOOST_TEST_MODULE)
-#define BOOST_TEST_MAIN BOOST_TEST_MODULE
-#endif
-
-#endif // BOOST_TEST_CONFIG_HPP_071894GER
diff --git a/contrib/autoboost/boost/test/detail/enable_warnings.hpp b/contrib/autoboost/boost/test/detail/enable_warnings.hpp
deleted file mode 100644
index 7c11ba235..000000000
--- a/contrib/autoboost/boost/test/detail/enable_warnings.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2004-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : enable previosly suppressed warnings
-// ***************************************************************************
-
-#ifdef BOOST_MSVC
-# pragma warning(default: 4511) // copy constructor can't not be generated
-# pragma warning(default: 4512) // assignment operator can't not be generated
-# pragma warning(default: 4100) // unreferenced formal parameter 
-# pragma warning(default: 4996) // <symbol> was declared deprecated 
-# pragma warning(default: 4355) // 'this' : used in base member initializer list
-# pragma warning(default: 4706) // assignment within conditional expression
-# pragma warning(default: 4251) // class 'A<T>' needs to have dll-interface to be used by clients of class 'B'
-# pragma warning(default: 4127) // conditional expression is constant
-# pragma warning(default: 4290) // C++ exception specification ignored except to ...
-# pragma warning(default: 4180) // qualifier applied to function type has no meaning; ignored
-# pragma warning(default: 4275) // non dll-interface class ... used as base for dll-interface class ...
-# pragma warning(default: 4267) // 'var' : conversion from 'size_t' to 'type', possible loss of data
-# pragma warning(default: 4511) // 'class' : copy constructor could not be generated
-# pragma warning(pop)
-#endif
diff --git a/contrib/autoboost/boost/test/detail/fwd_decl.hpp b/contrib/autoboost/boost/test/detail/fwd_decl.hpp
deleted file mode 100644
index 274aca37c..000000000
--- a/contrib/autoboost/boost/test/detail/fwd_decl.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : contains forward eclarations for Boost.Test data types
-// ***************************************************************************
-
-#ifndef BOOST_TEST_FWD_DECL_HPP_011605GER
-#define BOOST_TEST_FWD_DECL_HPP_011605GER
-
-namespace autoboost {
-
-class  execution_monitor;
-class  execution_exception;
-
-namespace unit_test {
-
-class  test_unit;
-class  test_case;
-class  test_suite;
-class  master_test_suite_t;
-
-class  test_tree_visitor;
-class  test_observer;
-
-// singletons
-class  unit_test_monitor_t;
-class  unit_test_log_t;
-
-class  unit_test_log_formatter;
-struct log_entry_data;
-struct log_checkpoint_data;
-
-class lazy_ostream;
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-#endif // BOOST_TEST_FWD_DECL_HPP_011605GER
-
diff --git a/contrib/autoboost/boost/test/detail/global_typedef.hpp b/contrib/autoboost/boost/test/detail/global_typedef.hpp
deleted file mode 100644
index ef04ae97d..000000000
--- a/contrib/autoboost/boost/test/detail/global_typedef.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : some trivial global typedefs
-// ***************************************************************************
-
-#ifndef BOOST_TEST_GLOBAL_TYPEDEF_HPP_021005GER
-#define BOOST_TEST_GLOBAL_TYPEDEF_HPP_021005GER
-
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-#define BOOST_TEST_L( s )         autoboost::unit_test::const_string( s, sizeof( s ) - 1 )
-#define BOOST_TEST_STRINGIZE( s ) BOOST_TEST_L( BOOST_STRINGIZE( s ) )
-#define BOOST_TEST_EMPTY_STRING   BOOST_TEST_L( "" )
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-typedef unsigned long   counter_t;
-
-//____________________________________________________________________________//
-
-enum report_level  { INV_REPORT_LEVEL, CONFIRMATION_REPORT, SHORT_REPORT, DETAILED_REPORT, NO_REPORT };
-
-//____________________________________________________________________________//
-
-enum output_format { INV_OF, CLF /* compiler log format */, XML /* XML */ };
-
-//____________________________________________________________________________//
-
-enum test_unit_type { tut_case = 0x01, tut_suite = 0x10, tut_any = 0x11 };
-
-//____________________________________________________________________________//
-
-typedef unsigned long   test_unit_id;
-
-const test_unit_id INV_TEST_UNIT_ID  = 0xFFFFFFFF;
-const test_unit_id MAX_TEST_CASE_ID  = 0xFFFFFFFE;
-const test_unit_id MIN_TEST_CASE_ID  = 0x00010000;
-const test_unit_id MAX_TEST_SUITE_ID = 0x0000FF00;
-const test_unit_id MIN_TEST_SUITE_ID = 0x00000001;
-
-//____________________________________________________________________________//
-
-namespace ut_detail {
-
-inline test_unit_type
-test_id_2_unit_type( test_unit_id id )
-{
-    return (id & 0xFFFF0000) != 0 ? tut_case : tut_suite;
-}
-
-//____________________________________________________________________________//
-
-// helper templates to prevent ODR violations 
-template<class T> 
-struct static_constant { 
-    static T value; 
-}; 
-
-template<class T> 
-T static_constant<T>::value; 
-
-//____________________________________________________________________________// 
-
-} // namespace ut_detail
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_GLOBAL_TYPEDEF_HPP_021005GER
diff --git a/contrib/autoboost/boost/test/detail/log_level.hpp b/contrib/autoboost/boost/test/detail/log_level.hpp
deleted file mode 100644
index 7b47dbb3e..000000000
--- a/contrib/autoboost/boost/test/detail/log_level.hpp
+++ /dev/null
@@ -1,43 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : shared definition for unit test log levels
-// ***************************************************************************
-
-#ifndef BOOST_TEST_LOG_LEVEL_HPP_011605GER
-#define BOOST_TEST_LOG_LEVEL_HPP_011605GER
-
-namespace autoboost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                   log levels                 ************** //
-// ************************************************************************** //
-
-//  each log level includes all subsequent higher loging levels
-enum            log_level {
-    invalid_log_level        = -1,
-    log_successful_tests     = 0,
-    log_test_units           = 1,
-    log_messages             = 2,
-    log_warnings             = 3,
-    log_all_errors           = 4, // reported by unit test macros
-    log_cpp_exception_errors = 5, // uncaught C++ exceptions
-    log_system_errors        = 6, // including timeouts, signals, traps
-    log_fatal_errors         = 7, // including unit test macros or
-                                  // fatal system errors
-    log_nothing              = 8
-};
-
-} // namespace unit_test
-} // namespace autoboost
-
-#endif // BOOST_TEST_LOG_LEVEL_HPP_011605GER
diff --git a/contrib/autoboost/boost/test/detail/suppress_warnings.hpp b/contrib/autoboost/boost/test/detail/suppress_warnings.hpp
deleted file mode 100644
index d5c95266e..000000000
--- a/contrib/autoboost/boost/test/detail/suppress_warnings.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2004-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : suppress some warnings 
-// ***************************************************************************
-
-#ifdef BOOST_MSVC
-# pragma warning(push)
-# pragma warning(disable: 4511) // copy constructor can't not be generated
-# pragma warning(disable: 4512) // assignment operator can't not be generated
-# pragma warning(disable: 4100) // unreferenced formal parameter 
-# pragma warning(disable: 4996) // <symbol> was declared deprecated 
-# pragma warning(disable: 4355) // 'this' : used in base member initializer list
-# pragma warning(disable: 4706) // assignment within conditional expression
-# pragma warning(disable: 4251) // class 'A<T>' needs to have dll-interface to be used by clients of class 'B'
-# pragma warning(disable: 4127) // conditional expression is constant
-# pragma warning(disable: 4290) // C++ exception specification ignored except to ...
-# pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored
-# pragma warning(disable: 4275) // non dll-interface class ... used as base for dll-interface class ...
-# pragma warning(disable: 4267) // 'var' : conversion from 'size_t' to 'type', possible loss of data
-# pragma warning(disable: 4511) // 'class' : copy constructor could not be generated
-#endif
-
diff --git a/contrib/autoboost/boost/test/detail/unit_test_parameters.hpp b/contrib/autoboost/boost/test/detail/unit_test_parameters.hpp
deleted file mode 100644
index 513262668..000000000
--- a/contrib/autoboost/boost/test/detail/unit_test_parameters.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : storage for unit test framework parameters information
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_PARAMETERS_HPP_071894GER
-#define BOOST_TEST_UNIT_TEST_PARAMETERS_HPP_071894GER
-
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/log_level.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-// STL
-#include <iosfwd>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                 runtime_config               ************** //
-// ************************************************************************** //
-
-namespace runtime_config {
-
-BOOST_TEST_DECL void                     init( int& argc, char** argv );
-
-BOOST_TEST_DECL unit_test::log_level     log_level();
-BOOST_TEST_DECL bool                     no_result_code();
-BOOST_TEST_DECL unit_test::report_level  report_level();
-BOOST_TEST_DECL const_string             test_to_run();
-BOOST_TEST_DECL const_string             break_exec_path();
-BOOST_TEST_DECL bool                     save_pattern();
-BOOST_TEST_DECL bool                     show_build_info();
-BOOST_TEST_DECL bool                     show_progress();
-BOOST_TEST_DECL bool                     catch_sys_errors();
-BOOST_TEST_DECL bool                     auto_start_dbg();
-BOOST_TEST_DECL bool                     use_alt_stack();
-BOOST_TEST_DECL bool                     detect_fp_exceptions();
-BOOST_TEST_DECL output_format            report_format();
-BOOST_TEST_DECL output_format            log_format();
-BOOST_TEST_DECL std::ostream*            report_sink();
-BOOST_TEST_DECL std::ostream*            log_sink();
-BOOST_TEST_DECL long                     detect_memory_leaks();
-BOOST_TEST_DECL int                      random_seed();
-
-} // namespace runtime_config
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_PARAMETERS_HPP_071894GER
diff --git a/contrib/autoboost/boost/test/detail/workaround.hpp b/contrib/autoboost/boost/test/detail/workaround.hpp
deleted file mode 100644
index 6bbbdf80e..000000000
--- a/contrib/autoboost/boost/test/detail/workaround.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : contains mics. workarounds 
-// ***************************************************************************
-
-#ifndef BOOST_TEST_WORKAROUND_HPP_021005GER
-#define BOOST_TEST_WORKAROUND_HPP_021005GER
-
-// Boost
-#include <boost/config.hpp> // compilers workarounds and std::ptrdiff_t
-
-// STL
-#include <iterator>     // for std::distance
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-namespace ut_detail {
-
-#ifdef BOOST_NO_STD_DISTANCE
-template <class T>
-std::ptrdiff_t distance( T const& x_, T const& y_ )
-{ 
-    std::ptrdiff_t res = 0;
-
-    std::distance( x_, y_, res );
-
-    return res;
-}
-
-//____________________________________________________________________________//
-
-#else
-using std::distance;
-#endif
-
-template <class T> inline void ignore_unused_variable_warning(const T&) {}
-
-} // namespace ut_detail
-
-} // namespace unit_test
-
-namespace unit_test_framework = unit_test;
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_WORKAROUND_HPP_021005GER
diff --git a/contrib/autoboost/boost/test/execution_monitor.hpp b/contrib/autoboost/boost/test/execution_monitor.hpp
deleted file mode 100644
index 831f6bb4c..000000000
--- a/contrib/autoboost/boost/test/execution_monitor.hpp
+++ /dev/null
@@ -1,263 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  (C) Copyright Beman Dawes 2001.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines abstract monitor interfaces and implements execution exception
-//  The original Boost Test Library included an implementation detail function
-//  named catch_exceptions() which caught otherwise uncaught C++ exceptions.
-//  It was derived from an existing test framework by Beman Dawes.  The
-//  intent was to expand later to catch other detectable but platform dependent
-//  error events like Unix signals or Windows structured C exceptions.
-//
-//  Requests from early adopters of the Boost Test Library included
-//  configurable levels of error message detail, elimination of templates,
-//  separation of error reporting, and making the catch_exceptions() facilities
-//  available as a public interface.  Support for unit testing also stretched
-//  the function based design.  Implementation within the header became less
-//  attractive due to the need to include many huge system dependent headers,
-//  although still preferable in certain cases.
-//
-//  All those issues have been addressed by introducing the class-based
-//  design presented here.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_EXECUTION_MONITOR_HPP_071894GER
-#define BOOST_TEST_EXECUTION_MONITOR_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-#include <boost/test/utils/callback.hpp>
-#include <boost/test/utils/class_properties.hpp>
-
-// Boost
-#include <boost/scoped_ptr.hpp>
-#include <boost/scoped_array.hpp>
-#include <boost/type.hpp>
-#include <boost/cstdlib.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace detail {
-
-// ************************************************************************** //
-// **************       detail::translate_exception_base       ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL translate_exception_base {
-public:
-    // Constructor
-    explicit    translate_exception_base( autoboost::scoped_ptr<translate_exception_base>& next )
-    {
-        next.swap( m_next );
-    }
-
-    // Destructor
-    virtual     ~translate_exception_base() {}
-
-    virtual int operator()( unit_test::callback0<int> const& F ) = 0;
-
-protected:
-    // Data members
-    autoboost::scoped_ptr<translate_exception_base> m_next;
-};
-
-} // namespace detail
-
-// ************************************************************************** //
-// **************              execution_exception             ************** //
-// ************************************************************************** //
-    
-//  design rationale: fear of being out (or nearly out) of memory.
-    
-class BOOST_TEST_DECL execution_exception {
-    typedef autoboost::unit_test::const_string const_string;
-public:
-    enum error_code {
-        //  These values are sometimes used as program return codes.
-        //  The particular values have been chosen to avoid conflicts with
-        //  commonly used program return codes: values < 100 are often user
-        //  assigned, values > 255 are sometimes used to report system errors.
-        //  Gaps in values allow for orderly expansion.
-        
-        no_error               = 0,   // for completeness only; never returned
-        user_error             = 200, // user reported non-fatal error
-        cpp_exception_error    = 205, // see note (1) below
-        system_error           = 210, // see note (2) below
-        timeout_error          = 215, // only detectable on certain platforms
-        user_fatal_error       = 220, // user reported fatal error
-        system_fatal_error     = 225  // see note (2) below
-        
-        //  Note 1: Only uncaught C++ exceptions are treated as errors.
-        //  If the application catches a C++ exception, it will never reach
-        //  the execution_monitor.
-        
-        //  Note 2: These errors include Unix signals and Windows structured
-        //  exceptions.  They are often initiated by hardware traps.
-        //
-        //  The implementation decides what is a fatal_system_exception and what is
-        //  just a system_exception.  Fatal errors are so likely to have corrupted
-        //  machine state (like a stack overflow or addressing exception) that it
-        //  is unreasonable to continue execution.
-    };
-    
-    struct BOOST_TEST_DECL location {
-        explicit    location( char const* file_name = 0, size_t line_num = 0, char const* func = 0 );
-
-        const_string    m_file_name;
-        size_t          m_line_num;
-        const_string    m_function;
-    };
-
-    // Constructor
-    execution_exception( error_code ec_, const_string what_msg_, location const& location_ ); // max length 256 inc '\0'
-
-    // Access methods
-    error_code      code() const    { return m_error_code; }
-    const_string    what() const    { return m_what; }
-    location const& where() const   { return m_location; }
-
-private:
-    // Data members
-    error_code      m_error_code;
-    const_string    m_what;
-    location        m_location;
-}; // execution_exception
-
-// ************************************************************************** //
-// **************               execution_monitor              ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL execution_monitor {
-public:
-    // Constructor
-    execution_monitor()
-    : p_catch_system_errors( true )
-    , p_auto_start_dbg( false )
-    , p_timeout( 0 )
-    , p_use_alt_stack( true )
-    , p_detect_fp_exceptions( false )
-    {}
-
-    // Public properties
-    
-    //  The p_catch_system_errors parameter specifies whether the monitor should 
-    //  try to catch system errors/exceptions that would cause program to crash 
-    //  in regular case
-    unit_test::readwrite_property<bool> p_catch_system_errors; 
-    //  The p_auto_start_dbg parameter specifies whether the monitor should 
-    //  try to attach debugger in case of caught system error
-    unit_test::readwrite_property<bool> p_auto_start_dbg;
-    //  The p_timeout parameter specifies the seconds that elapse before
-    //  a timer_error occurs.  May be ignored on some platforms.
-    unit_test::readwrite_property<int>  p_timeout;
-    //  The p_use_alt_stack parameter specifies whether the monitor should
-    //  use alternative stack for the signal catching
-    unit_test::readwrite_property<bool> p_use_alt_stack;
-    //  The p_detect_fp_exceptions parameter specifies whether the monitor should
-    //  try to detect hardware floating point exceptions
-    unit_test::readwrite_property<bool> p_detect_fp_exceptions;
-
-    int         execute( unit_test::callback0<int> const& F ); 
-    //  Returns:  Value returned by function call F().
-    //
-    //  Effects:  Calls executes supplied function F inside a try/catch block which also may
-    //  include other unspecified platform dependent error detection code.
-    //
-    //  Throws: execution_exception on an uncaught C++ exception,
-    //  a hardware or software signal, trap, or other exception.
-    //
-    //  Note: execute() doesn't consider it an error for F to return a non-zero value.
-    
-    // register custom (user supplied) exception translator
-    template<typename Exception, typename ExceptionTranslator>
-    void        register_exception_translator( ExceptionTranslator const& tr, autoboost::type<Exception>* = 0 );
-
-private:
-    // implementation helpers
-    int         catch_signals( unit_test::callback0<int> const& F );
-
-    // Data members
-    autoboost::scoped_ptr<detail::translate_exception_base> m_custom_translators;
-    autoboost::scoped_array<char>                           m_alt_stack;
-}; // execution_monitor
-
-namespace detail {
-
-// ************************************************************************** //
-// **************         detail::translate_exception          ************** //
-// ************************************************************************** //
-
-template<typename Exception, typename ExceptionTranslator>
-class translate_exception : public translate_exception_base
-{
-    typedef autoboost::scoped_ptr<translate_exception_base> base_ptr;
-public:
-    explicit    translate_exception( ExceptionTranslator const& tr, base_ptr& next )
-    : translate_exception_base( next ), m_translator( tr ) {}
-
-    int operator()( unit_test::callback0<int> const& F )
-    {
-        try {
-            return m_next ? (*m_next)( F ) : F();
-        } catch( Exception const& e ) {
-            m_translator( e );
-            return autoboost::exit_exception_failure;
-        }
-    }
-
-private:
-    // Data members
-    ExceptionTranslator m_translator;
-};
-
-} // namespace detail
-
-template<typename Exception, typename ExceptionTranslator>
-void
-execution_monitor::register_exception_translator( ExceptionTranslator const& tr, autoboost::type<Exception>* )
-{
-    m_custom_translators.reset( 
-        new detail::translate_exception<Exception,ExceptionTranslator>( tr,m_custom_translators ) );
-}
-
-// ************************************************************************** //
-// **************               execution_aborted              ************** //
-// ************************************************************************** //
-
-struct execution_aborted {};
-
-// ************************************************************************** //
-// **************                  system_error                ************** //
-// ************************************************************************** //
-
-class system_error {
-public:
-    // Constructor
-    explicit    system_error( char const* exp );
-
-    unit_test::readonly_property<long>          p_errno; 
-    unit_test::readonly_property<char const*>   p_failed_exp; 
-};
-
-#define BOOST_TEST_SYS_ASSERT( exp ) if( (exp) ) ; else throw ::autoboost::system_error( BOOST_STRINGIZE( exp ) )
-
-}  // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif
diff --git a/contrib/autoboost/boost/test/floating_point_comparison.hpp b/contrib/autoboost/boost/test/floating_point_comparison.hpp
deleted file mode 100644
index 20adf9d08..000000000
--- a/contrib/autoboost/boost/test/floating_point_comparison.hpp
+++ /dev/null
@@ -1,286 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines algoirthms for comparing 2 floating point values
-// ***************************************************************************
-
-#ifndef BOOST_TEST_FLOATING_POINT_COMPARISON_HPP_071894GER
-#define BOOST_TEST_FLOATING_POINT_COMPARISON_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/utils/class_properties.hpp>
-#include <boost/test/predicate_result.hpp>
-
-// Boost
-#include <boost/limits.hpp>  // for std::numeric_limits
-#include <boost/numeric/conversion/conversion_traits.hpp> // for numeric::conversion_traits
-#include <boost/static_assert.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace test_tools {
-
-using unit_test::readonly_property;
-
-// ************************************************************************** //
-// **************        floating_point_comparison_type        ************** //
-// ************************************************************************** //
-
-enum floating_point_comparison_type {
-    FPC_STRONG, // "Very close"   - equation 1' in docs, the default
-    FPC_WEAK    // "Close enough" - equation 2' in docs.
-
-};
-
-// ************************************************************************** //
-// **************                    details                   ************** //
-// ************************************************************************** //
-
-namespace tt_detail {
-
-// FPT is Floating-Point Type: float, double, long double or User-Defined.
-template<typename FPT>
-inline FPT
-fpt_abs( FPT fpv ) 
-{
-    return fpv < static_cast<FPT>(0) ? -fpv : fpv;
-}
-
-//____________________________________________________________________________//
-
-template<typename FPT>
-struct fpt_limits {
-    static FPT    min_value()
-    {
-        return std::numeric_limits<FPT>::is_specialized
-                    ? (std::numeric_limits<FPT>::min)()
-                    : 0;
-    }
-    static FPT    max_value()
-    {
-        return std::numeric_limits<FPT>::is_specialized
-                    ? (std::numeric_limits<FPT>::max)()
-                    : static_cast<FPT>(1000000); // for the our purpuses it doesn't really matter what value is returned here
-    }
-};
-
-//____________________________________________________________________________//
-
-// both f1 and f2 are unsigned here
-template<typename FPT>
-inline FPT
-safe_fpt_division( FPT f1, FPT f2 )
-{
-    // Avoid overflow.
-    if( (f2 < static_cast<FPT>(1))  && (f1 > f2*fpt_limits<FPT>::max_value()) )
-        return fpt_limits<FPT>::max_value();
-
-    // Avoid underflow.
-    if( (f1 == static_cast<FPT>(0)) ||
-        ((f2 > static_cast<FPT>(1)) && (f1 < f2*fpt_limits<FPT>::min_value())) )
-        return static_cast<FPT>(0);
-
-    return f1/f2;
-}
-
-//____________________________________________________________________________//
-
-} // namespace tt_detail
-
-// ************************************************************************** //
-// **************         tolerance presentation types         ************** //
-// ************************************************************************** //
-
-template<typename FPT>
-struct percent_tolerance_t {
-    explicit    percent_tolerance_t( FPT v ) : m_value( v ) {}
-
-    FPT m_value;
-};
-
-//____________________________________________________________________________//
-
-template<typename Out,typename FPT>
-Out& operator<<( Out& out, percent_tolerance_t<FPT> t )
-{
-    return out << t.m_value;
-}
-
-//____________________________________________________________________________//
-
-template<typename FPT>
-inline percent_tolerance_t<FPT>
-percent_tolerance( FPT v )
-{
-    return percent_tolerance_t<FPT>( v );
-}
-
-//____________________________________________________________________________//
-
-template<typename FPT>
-struct fraction_tolerance_t {
-    explicit fraction_tolerance_t( FPT v ) : m_value( v ) {}
-
-    FPT m_value;
-};
-
-//____________________________________________________________________________//
-
-template<typename Out,typename FPT>
-Out& operator<<( Out& out, fraction_tolerance_t<FPT> t )
-{
-    return out << t.m_value;
-}
-
-//____________________________________________________________________________//
-
-template<typename FPT>
-inline fraction_tolerance_t<FPT>
-fraction_tolerance( FPT v )
-{
-    return fraction_tolerance_t<FPT>( v );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************             close_at_tolerance               ************** //
-// ************************************************************************** //
-
-template<typename FPT>
-class close_at_tolerance {
-public:
-    // Public typedefs
-    typedef bool result_type;
-
-    // Constructor
-    template<typename ToleranceBaseType>
-    explicit    close_at_tolerance( percent_tolerance_t<ToleranceBaseType>  tolerance, 
-                                    floating_point_comparison_type          fpc_type = FPC_STRONG ) 
-    : p_fraction_tolerance( tt_detail::fpt_abs( static_cast<FPT>(0.01)*tolerance.m_value ) )
-    , p_strong_or_weak( fpc_type ==  FPC_STRONG )
-    , m_report_modifier( 100. )
-    {}
-    template<typename ToleranceBaseType>
-    explicit    close_at_tolerance( fraction_tolerance_t<ToleranceBaseType> tolerance, 
-                                    floating_point_comparison_type          fpc_type = FPC_STRONG ) 
-    : p_fraction_tolerance( tt_detail::fpt_abs( tolerance.m_value ) )
-    , p_strong_or_weak( fpc_type ==  FPC_STRONG )
-    , m_report_modifier( 1. )
-    {}
-
-    predicate_result        operator()( FPT left, FPT right ) const
-    {
-        FPT diff = tt_detail::fpt_abs( left - right );
-        FPT d1   = tt_detail::safe_fpt_division( diff, tt_detail::fpt_abs( right ) );
-        FPT d2   = tt_detail::safe_fpt_division( diff, tt_detail::fpt_abs( left ) );
-        
-        predicate_result res( p_strong_or_weak 
-            ? (d1 <= p_fraction_tolerance.get() && d2 <= p_fraction_tolerance.get()) 
-            : (d1 <= p_fraction_tolerance.get() || d2 <= p_fraction_tolerance.get()) );
-
-        if( !res )
-            res.message() << (( d1 <= p_fraction_tolerance.get() ? d2 : d1 ) * m_report_modifier);
-
-        return res;
-    }
-
-    // Public properties
-    readonly_property<FPT>  p_fraction_tolerance;
-    readonly_property<bool> p_strong_or_weak;
-private:
-    // Data members
-    FPT                     m_report_modifier;
-};
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               check_is_close                 ************** //
-// ************************************************************************** //
-
-struct BOOST_TEST_DECL check_is_close_t {
-    // Public typedefs
-    typedef bool result_type;
-
-    template<typename FPT1, typename FPT2, typename ToleranceBaseType>
-    predicate_result
-    operator()( FPT1 left, FPT2 right, percent_tolerance_t<ToleranceBaseType> tolerance, 
-                floating_point_comparison_type fpc_type = FPC_STRONG ) const
-    {
-        // deduce "better" type from types of arguments being compared
-        // if one type is floating and the second integral we use floating type and 
-        // value of integral type is promoted to the floating. The same for float and double
-        // But we don't want to compare two values of integral types using this tool.
-        typedef typename numeric::conversion_traits<FPT1,FPT2>::supertype FPT;
-        BOOST_STATIC_ASSERT( !is_integral<FPT>::value );
-
-        close_at_tolerance<FPT> pred( tolerance, fpc_type );
-
-        return pred( left, right );
-    }
-    template<typename FPT1, typename FPT2, typename ToleranceBaseType>
-    predicate_result
-    operator()( FPT1 left, FPT2 right, fraction_tolerance_t<ToleranceBaseType> tolerance, 
-                floating_point_comparison_type fpc_type = FPC_STRONG ) const
-    {
-        // same as in a comment above
-        typedef typename numeric::conversion_traits<FPT1,FPT2>::supertype FPT;
-        BOOST_STATIC_ASSERT( !is_integral<FPT>::value );
-
-        close_at_tolerance<FPT> pred( tolerance, fpc_type );
-
-        return pred( left, right );
-    }
-};
-
-namespace {
-check_is_close_t const& check_is_close = unit_test::ut_detail::static_constant<check_is_close_t>::value;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               check_is_small                 ************** //
-// ************************************************************************** //
-
-struct BOOST_TEST_DECL check_is_small_t {
-    // Public typedefs
-    typedef bool result_type;
-
-    template<typename FPT>
-    bool
-    operator()( FPT fpv, FPT tolerance ) const
-    {
-        return tt_detail::fpt_abs( fpv ) < tt_detail::fpt_abs( tolerance );
-    }
-};
-
-namespace {
-check_is_small_t const& check_is_small = unit_test::ut_detail::static_constant<check_is_small_t>::value;
-}
-
-//____________________________________________________________________________//
-
-} // namespace test_tools
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_FLOATING_POINT_COMAPARISON_HPP_071894GER
diff --git a/contrib/autoboost/boost/test/framework.hpp b/contrib/autoboost/boost/test/framework.hpp
deleted file mode 100644
index 3fb87abba..000000000
--- a/contrib/autoboost/boost/test/framework.hpp
+++ /dev/null
@@ -1,112 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines framework interface
-// ***************************************************************************
-
-#ifndef BOOST_TEST_FRAMEWORK_HPP_020805GER
-#define BOOST_TEST_FRAMEWORK_HPP_020805GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-#include <boost/test/utils/trivial_singleton.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-// STL
-#include <stdexcept>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************              init_unit_test_func             ************** //
-// ************************************************************************** //
-
-#ifdef BOOST_TEST_ALTERNATIVE_INIT_API
-typedef bool        (*init_unit_test_func)();
-#else
-typedef test_suite* (*init_unit_test_func)( int, char* [] );
-#endif
-
-// ************************************************************************** //
-// **************                   framework                  ************** //
-// ************************************************************************** //
-
-namespace framework {
-
-// initialization
-BOOST_TEST_DECL void    init( init_unit_test_func init_func, int argc, char* argv[] );
-BOOST_TEST_DECL bool    is_initialized();
-
-// mutation access methods
-BOOST_TEST_DECL void    register_test_unit( test_case* tc );
-BOOST_TEST_DECL void    register_test_unit( test_suite* ts );
-BOOST_TEST_DECL void    deregister_test_unit( test_unit* tu );
-BOOST_TEST_DECL void    clear();
-
-BOOST_TEST_DECL void    register_observer( test_observer& );
-BOOST_TEST_DECL void    deregister_observer( test_observer& );
-BOOST_TEST_DECL void    reset_observers();
-
-BOOST_TEST_DECL master_test_suite_t& master_test_suite();
-
-// constant access methods
-BOOST_TEST_DECL test_case const&    current_test_case();
-
-BOOST_TEST_DECL test_unit&  get( test_unit_id, test_unit_type );
-template<typename UnitType>
-UnitType&               get( test_unit_id id )
-{
-    return static_cast<UnitType&>( get( id, static_cast<test_unit_type>(UnitType::type) ) );
-}
-
-// test initiation
-BOOST_TEST_DECL void    run( test_unit_id = INV_TEST_UNIT_ID, bool continue_test = true );
-BOOST_TEST_DECL void    run( test_unit const*, bool continue_test = true );
-
-// public test events dispatchers
-BOOST_TEST_DECL void    assertion_result( bool passed );
-BOOST_TEST_DECL void    exception_caught( execution_exception const& );
-BOOST_TEST_DECL void    test_unit_aborted( test_unit const& );
-
-// ************************************************************************** //
-// **************                framework errors              ************** //
-// ************************************************************************** //
-
-struct internal_error : std::runtime_error {
-    internal_error( const_string m ) : std::runtime_error( std::string( m.begin(), m.size() ) ) {}
-};
-
-struct setup_error : std::runtime_error {
-    setup_error( const_string m ) : std::runtime_error( std::string( m.begin(), m.size() ) ) {}
-};
-
-#define BOOST_TEST_SETUP_ASSERT( cond, msg ) if( cond ) {} else throw unit_test::framework::setup_error( msg )
-
-struct nothing_to_test {}; // not really an error
-
-} // namespace framework
-
-} // unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_FRAMEWORK_HPP_020805GER
-
diff --git a/contrib/autoboost/boost/test/impl/compiler_log_formatter.ipp b/contrib/autoboost/boost/test/impl/compiler_log_formatter.ipp
deleted file mode 100644
index 66c617023..000000000
--- a/contrib/autoboost/boost/test/impl/compiler_log_formatter.ipp
+++ /dev/null
@@ -1,222 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : implements compiler like Log formatter
-// ***************************************************************************
-
-#ifndef BOOST_TEST_COMPILER_LOG_FORMATTER_IPP_020105GER
-#define BOOST_TEST_COMPILER_LOG_FORMATTER_IPP_020105GER
-
-// Boost.Test
-#include <boost/test/output/compiler_log_formatter.hpp>
-#include <boost/test/unit_test_suite_impl.hpp>
-#include <boost/test/framework.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-#include <boost/test/utils/lazy_ostream.hpp>
-
-// Boost
-#include <boost/version.hpp>
-
-// STL
-#include <iostream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-namespace output {
-
-// ************************************************************************** //
-// **************            compiler_log_formatter            ************** //
-// ************************************************************************** //
-
-namespace {
-
-const_string
-test_phase_identifier()
-{
-    return framework::is_initialized() 
-            ? const_string( framework::current_test_case().p_name.get() )
-            : BOOST_TEST_L( "Test setup" );
-}
-
-} // local namespace
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_start( std::ostream& output, counter_t test_cases_amount )
-{
-    if( test_cases_amount > 0 )
-        output  << "Running " << test_cases_amount << " test "
-                << (test_cases_amount > 1 ? "cases" : "case") << "...\n";
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_finish( std::ostream& ostr )
-{
-    ostr.flush();
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_build_info( std::ostream& output )
-{
-    output  << "Platform: " << BOOST_PLATFORM            << '\n'
-            << "Compiler: " << BOOST_COMPILER            << '\n'
-            << "STL     : " << BOOST_STDLIB              << '\n'
-            << "Boost   : " << BOOST_VERSION/100000      << "."
-                            << BOOST_VERSION/100 % 1000  << "."
-                            << BOOST_VERSION % 100       << std::endl;
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::test_unit_start( std::ostream& output, test_unit const& tu )
-{
-    output << "Entering test " << tu.p_type_name << " \"" << tu.p_name << "\"" << std::endl;
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::test_unit_finish( std::ostream& output, test_unit const& tu, unsigned long elapsed )
-{
-    output << "Leaving test " << tu.p_type_name << " \"" << tu.p_name << "\"";
-
-    if( elapsed > 0 ) {
-        output << "; testing time: ";
-        if( elapsed % 1000 == 0 )
-            output << elapsed/1000 << "ms";
-        else
-            output << elapsed << "mks";
-    }
-
-    output << std::endl;
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::test_unit_skipped( std::ostream& output, test_unit const& tu )
-{
-    output  << "Test " << tu.p_type_name << " \"" << tu.p_name << "\"" << "is skipped" << std::endl;
-}
-    
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_exception( std::ostream& output, log_checkpoint_data const& checkpoint_data, execution_exception const& ex )
-{
-    execution_exception::location const& loc = ex.where();
-    print_prefix( output, loc.m_file_name, loc.m_line_num );
-
-    output << "fatal error in \"" << (loc.m_function.is_empty() ? test_phase_identifier() : loc.m_function ) << "\": ";
-
-    output << ex.what();
-
-    if( !checkpoint_data.m_file_name.is_empty() ) {
-        output << '\n';
-        print_prefix( output, checkpoint_data.m_file_name, checkpoint_data.m_line_num );
-        output << "last checkpoint";
-        if( !checkpoint_data.m_message.empty() )
-            output << ": " << checkpoint_data.m_message;
-    }
-    
-    output << std::endl;
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_entry_start( std::ostream& output, log_entry_data const& entry_data, log_entry_types let )
-{
-    switch( let ) {
-        case BOOST_UTL_ET_INFO:
-            print_prefix( output, entry_data.m_file_name, entry_data.m_line_num );
-            output << "info: ";
-            break;
-        case BOOST_UTL_ET_MESSAGE:
-            break;
-        case BOOST_UTL_ET_WARNING:
-            print_prefix( output, entry_data.m_file_name, entry_data.m_line_num );
-            output << "warning in \"" << test_phase_identifier() << "\": ";
-            break;
-        case BOOST_UTL_ET_ERROR:
-            print_prefix( output, entry_data.m_file_name, entry_data.m_line_num );
-            output << "error in \"" << test_phase_identifier() << "\": ";
-            break;
-        case BOOST_UTL_ET_FATAL_ERROR:
-            print_prefix( output, entry_data.m_file_name, entry_data.m_line_num );
-            output << "fatal error in \"" << test_phase_identifier() << "\": ";
-            break;
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_entry_value( std::ostream& output, const_string value )
-{
-    output << value;
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_entry_value( std::ostream& output, lazy_ostream const& value )
-{
-    output << value;
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_entry_finish( std::ostream& output )
-{
-    output << std::endl;
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::print_prefix( std::ostream& output, const_string file, std::size_t line )
-{
-#ifdef __APPLE_CC__
-    // Xcode-compatible logging format, idea by Richard Dingwall at 
-    // <http://richarddingwall.name/2008/06/01/using-the-boost-unit-test-framework-with-xcode-3/>. 
-    output << file << ':' << line << ": ";
-#else
-    output << file << '(' << line << "): ";
-#endif
-}
-
-//____________________________________________________________________________//
-
-} // namespace output
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_COMPILER_LOG_FORMATTER_IPP_020105GER
diff --git a/contrib/autoboost/boost/test/impl/cpp_main.ipp b/contrib/autoboost/boost/test/impl/cpp_main.ipp
deleted file mode 100644
index 60b70ced5..000000000
--- a/contrib/autoboost/boost/test/impl/cpp_main.ipp
+++ /dev/null
@@ -1,139 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  (C) Copyright Beman Dawes 1995-2001.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : main function implementation for Program Executon Monitor
-// ***************************************************************************
-
-#ifndef BOOST_TEST_CPP_MAIN_IPP_012205GER
-#define BOOST_TEST_CPP_MAIN_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/execution_monitor.hpp>
-#include <boost/test/detail/config.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-
-// Boost
-#include <boost/cstdlib.hpp>    // for exit codes
-#include <boost/config.hpp>     // for workarounds
-
-// STL
-#include <iostream>
-#include <cstdlib>      // std::getenv
-#include <cstring>      // std::strerror
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::getenv; using ::strerror; }
-#endif
-
-namespace {
-
-struct cpp_main_caller {
-    cpp_main_caller( int (*cpp_main_func)( int argc, char* argv[] ), int argc, char** argv ) 
-    : m_cpp_main_func( cpp_main_func )
-    , m_argc( argc )
-    , m_argv( argv ) {}
-    
-    int operator()() { return (*m_cpp_main_func)( m_argc, m_argv ); }
-  
-private:
-    // Data members    
-    int (*m_cpp_main_func)( int argc, char* argv[] );
-    int      m_argc;
-    char**   m_argv;
-};
-
-} // local namespace
-
-// ************************************************************************** //
-// **************             prg_exec_monitor_main            ************** //
-// ************************************************************************** //
-
-namespace autoboost {
-
-int BOOST_TEST_DECL
-prg_exec_monitor_main( int (*cpp_main)( int argc, char* argv[] ), int argc, char* argv[] )
-{
-    int result = 0;
-
-    try {
-        autoboost::unit_test::const_string p( std::getenv( "BOOST_TEST_CATCH_SYSTEM_ERRORS" ) );
-        ::autoboost::execution_monitor ex_mon;
-
-        ex_mon.p_catch_system_errors.value = p != "no";
-        
-        result = ex_mon.execute( 
-            ::autoboost::unit_test::callback0<int>( cpp_main_caller( cpp_main, argc, argv ) ) );
-        
-        if( result == 0 )
-            result = ::autoboost::exit_success;
-        else if( result != ::autoboost::exit_success ) {
-            std::cout << "\n**** error return code: " << result << std::endl;
-            result = ::autoboost::exit_failure;
-        }
-    }
-    catch( ::autoboost::execution_exception const& exex ) {
-        std::cout << "\n**** exception(" << exex.code() << "): " << exex.what() << std::endl;
-        result = ::autoboost::exit_exception_failure;
-    }
-    catch( ::autoboost::system_error const& ex ) {
-        std::cout << "\n**** failed to initialize execution monitor."
-                  << "\n**** expression at fault: " << ex.p_failed_exp 
-                  << "\n**** error(" << ex.p_errno << "): " << std::strerror( ex.p_errno ) << std::endl;
-        result = ::autoboost::exit_exception_failure;
-    }
-
-    if( result != ::autoboost::exit_success ) {
-        std::cerr << "******** errors detected; see standard output for details ********" << std::endl;
-    }
-    else {
-        //  Some prefer a confirming message when all is well, while others don't
-        //  like the clutter.  Use an environment variable to avoid command
-        //  line argument modifications; for use in production programs
-        //  that's a no-no in some organizations.
-        ::autoboost::unit_test::const_string p( std::getenv( "BOOST_PRG_MON_CONFIRM" ) );
-        if( p != "no" ) { 
-            std::cerr << std::flush << "no errors detected" << std::endl; 
-        }
-    }
-
-    return result;
-}
-
-} // namespace autoboost
-
-#if !defined(BOOST_TEST_DYN_LINK) && !defined(BOOST_TEST_NO_MAIN)
-
-// ************************************************************************** //
-// **************        main function for tests using lib     ************** //
-// ************************************************************************** //
-
-int cpp_main( int argc, char* argv[] );  // prototype for user's cpp_main()
-
-int BOOST_TEST_CALL_DECL
-main( int argc, char* argv[] )
-{
-    return ::autoboost::prg_exec_monitor_main( &cpp_main, argc, argv );
-}
-
-//____________________________________________________________________________//
-
-#endif // !BOOST_TEST_DYN_LINK && !BOOST_TEST_NO_MAIN
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_CPP_MAIN_IPP_012205GER
diff --git a/contrib/autoboost/boost/test/impl/debug.ipp b/contrib/autoboost/boost/test/impl/debug.ipp
deleted file mode 100644
index d056128fa..000000000
--- a/contrib/autoboost/boost/test/impl/debug.ipp
+++ /dev/null
@@ -1,970 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2006-2008.
-//  Use, modification, and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : debug interfaces implementation
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DEBUG_API_IPP_112006GER
-#define BOOST_TEST_DEBUG_API_IPP_112006GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/detail/workaround.hpp>
-#include <boost/test/detail/global_typedef.hpp>
-
-#include <boost/test/debug.hpp>
-#include <boost/test/debug_config.hpp>
-
-// Implementation on Windows
-#if defined(_WIN32) && !defined(UNDER_CE) && !defined(BOOST_DISABLE_WIN32) // ******* WIN32
-
-#  define BOOST_WIN32_BASED_DEBUG
-
-// SYSTEM API
-#  include <windows.h>
-#  include <winreg.h>
-#  include <cstdio>
-#  include <cstring>
-
-#  if !defined(NDEBUG) && defined(_MSC_VER)
-#    define BOOST_MS_CRT_BASED_DEBUG
-#    include <crtdbg.h>
-#  endif
-
-
-#  if BOOST_WORKAROUND( BOOST_MSVC, <1300)
-#    define snprintf _snprintf
-#  endif
-
-#  ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::memset; using ::sprintf; }
-#  endif
-
-#elif defined(unix) || defined(__unix) // ********************* UNIX
-
-#  define BOOST_UNIX_BASED_DEBUG
-
-// Boost.Test
-#include <boost/test/utils/class_properties.hpp>
-#include <boost/test/utils/algorithm.hpp>
-
-// STL
-#include <cstring>  // std::memcpy
-#include <map>
-#include <cstdio>
-#include <stdarg.h> // !! ?? cstdarg
-
-// SYSTEM API
-#  include <unistd.h>
-#  include <signal.h>
-#  include <fcntl.h>
-
-#  include <sys/types.h>
-#  include <sys/stat.h>
-#  include <sys/wait.h>
-#  include <sys/time.h>
-#  include <stdio.h>
-#  include <stdlib.h>
-
-#  if defined(sun) || defined(__sun)
-
-#    define BOOST_SUN_BASED_DEBUG
-
-#    ifndef BOOST_TEST_DBG_LIST
-#      define BOOST_TEST_DBG_LIST dbx;gdb
-#    endif
-
-#    define BOOST_TEST_CNL_DBG  dbx
-#    define BOOST_TEST_GUI_DBG  dbx-ddd
-
-#    include <procfs.h>
-
-#  elif defined(linux) || defined(__linux)
-
-#    define BOOST_LINUX_BASED_DEBUG
-
-#    include <sys/ptrace.h>
-
-#    ifndef BOOST_TEST_STAT_LINE_MAX
-#      define BOOST_TEST_STAT_LINE_MAX 500
-#    endif
-
-#    ifndef BOOST_TEST_DBG_LIST
-#      define BOOST_TEST_DBG_LIST gdb
-#    endif
-
-#    define BOOST_TEST_CNL_DBG  gdb
-#    define BOOST_TEST_GUI_DBG  gdb-xterm
-
-#  endif
-
-#endif
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace debug {
-
-using unit_test::const_string;
-
-// ************************************************************************** //
-// **************                debug::info_t                 ************** //
-// ************************************************************************** //
-
-namespace {
-
-#if defined(BOOST_WIN32_BASED_DEBUG) // *********************** WIN32
-
-template<typename T>
-inline void
-dyn_symbol( T& res, char const* module_name, char const* symbol_name )
-{
-    HMODULE m = ::GetModuleHandleA( module_name );
-
-    if( !m )
-        m = ::LoadLibraryA( module_name );
-
-    res = reinterpret_cast<T>( ::GetProcAddress( m, symbol_name ) );
-}
-
-//____________________________________________________________________________//
-
-static struct info_t {
-    typedef BOOL (WINAPI* IsDebuggerPresentT)();
-    typedef LONG (WINAPI* RegQueryValueExT)( HKEY, char const* /*LPTSTR*/, LPDWORD, LPDWORD, LPBYTE, LPDWORD );
-    typedef LONG (WINAPI* RegOpenKeyT)( HKEY, char const* /*LPCTSTR*/, PHKEY );
-    typedef LONG (WINAPI* RegCloseKeyT)( HKEY );
-
-    info_t();
-
-    IsDebuggerPresentT  m_is_debugger_present;
-    RegOpenKeyT         m_reg_open_key;
-    RegQueryValueExT    m_reg_query_value;
-    RegCloseKeyT        m_reg_close_key;
-
-} s_info;
-
-//____________________________________________________________________________//
-
-info_t::info_t()
-{
-    dyn_symbol( m_is_debugger_present, "kernel32", "IsDebuggerPresent" );
-    dyn_symbol( m_reg_open_key, "advapi32", "RegOpenKeyA" );
-    dyn_symbol( m_reg_query_value, "advapi32", "RegQueryValueExA" );
-    dyn_symbol( m_reg_close_key, "advapi32", "RegCloseKey" );
-}
-
-//____________________________________________________________________________//
-
-#elif defined(BOOST_UNIX_BASED_DEBUG)
-
-// ************************************************************************** //
-// **************                   fd_holder                  ************** //
-// ************************************************************************** //
-
-struct fd_holder {
-    explicit fd_holder( int fd ) : m_fd( fd ) {}
-    ~fd_holder()
-    {
-        if( m_fd != -1 )
-            ::close( m_fd );
-    }
-
-    operator int() { return m_fd; }
-
-private:
-    // Data members
-    int m_fd;
-};
-
-
-// ************************************************************************** //
-// **************                 process_info                 ************** //
-// ************************************************************************** //
-
-struct process_info {
-    // Constructor
-    explicit        process_info( int pid );
-
-    // access methods
-    int             parent_pid() const  { return m_parent_pid; }
-    const_string    binary_name() const { return m_binary_name; }
-    const_string    binary_path() const { return m_binary_path; }
-
-private:
-    // Data members
-    int             m_parent_pid;
-    const_string    m_binary_name;
-    const_string    m_binary_path;
-
-#if defined(BOOST_SUN_BASED_DEBUG)
-    struct psinfo   m_psi;
-#elif defined(BOOST_LINUX_BASED_DEBUG)
-    char            m_stat_line[BOOST_TEST_STAT_LINE_MAX+1];
-#endif
-    char            m_binary_path_buff[500+1]; // !! ??
-};
-
-//____________________________________________________________________________//
-
-process_info::process_info( int pid )
-: m_parent_pid( 0 )
-{
-#if defined(BOOST_SUN_BASED_DEBUG)
-    char fname_buff[30];
-
-    ::snprintf( fname_buff, sizeof(fname_buff), "/proc/%d/psinfo", pid );
-
-    fd_holder psinfo_fd( ::open( fname_buff, O_RDONLY ) );
-
-    if( psinfo_fd == -1 )
-        return;
-
-    if( ::read( psinfo_fd, &m_psi, sizeof(m_psi) ) == -1 )
-        return;
-
-    m_parent_pid = m_psi.pr_ppid;
-
-    m_binary_name.assign( m_psi.pr_fname );
-
-    //-------------------------- //
-    
-    ::snprintf( fname_buff, sizeof(fname_buff), "/proc/%d/as", pid );
-
-    fd_holder as_fd( ::open( fname_buff, O_RDONLY ) );
-    uintptr_t   binary_name_pos;
-  
-    // !! ?? could we avoid reading whole m_binary_path_buff?
-    if( as_fd == -1 ||
-        ::lseek( as_fd, m_psi.pr_argv, SEEK_SET ) == -1 ||
-        ::read ( as_fd, &binary_name_pos, sizeof(binary_name_pos) ) == -1 ||
-        ::lseek( as_fd, binary_name_pos, SEEK_SET ) == -1 ||
-        ::read ( as_fd, m_binary_path_buff, sizeof(m_binary_path_buff) ) == -1 )
-        return;
-        
-    m_binary_path.assign( m_binary_path_buff );
-        
-#elif defined(BOOST_LINUX_BASED_DEBUG)
-    char fname_buff[30];
-
-    ::snprintf( fname_buff, sizeof(fname_buff), "/proc/%d/stat", pid );
-
-    fd_holder psinfo_fd( ::open( fname_buff, O_RDONLY ) );
-
-    if( psinfo_fd == -1 )
-        return;
-
-    ssize_t num_read = ::read( psinfo_fd, m_stat_line, sizeof(m_stat_line)-1 );
-    if( num_read == -1 )
-        return;
-
-    m_stat_line[num_read] = 0;
-
-    char const* name_beg = m_stat_line;
-    while( *name_beg && *name_beg != '(' )
-        ++name_beg;
-
-    char const* name_end = name_beg+1;
-    while( *name_end && *name_end != ')' )
-        ++name_end;
-
-    std::sscanf( name_end+1, "%*s%d", &m_parent_pid );
-
-    m_binary_name.assign( name_beg+1, name_end );
-
-    ::snprintf( fname_buff, sizeof(fname_buff), "/proc/%d/exe", pid );
-    num_read = ::readlink( fname_buff, m_binary_path_buff, sizeof(m_binary_path_buff)-1 );
-
-    if( num_read == -1 )
-        return;
-
-    m_binary_path_buff[num_read] = 0;
-    m_binary_path.assign( m_binary_path_buff, num_read );
-#endif
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************             prepare_window_title             ************** //
-// ************************************************************************** //
-
-static char*
-prepare_window_title( dbg_startup_info const& dsi )
-{
-    typedef unit_test::const_string str_t;
-
-    static char title_str[50];
-
-    str_t path_sep( "\\/" );
-
-    str_t::iterator  it = unit_test::find_last_of( dsi.binary_path.begin(), dsi.binary_path.end(),
-                                                   path_sep.begin(), path_sep.end() );
-
-    if( it == dsi.binary_path.end() )
-        it = dsi.binary_path.begin();
-    else
-        ++it;
-
-    ::snprintf( title_str, sizeof(title_str), "%*s %ld", (int)(dsi.binary_path.end()-it), it, dsi.pid );
-
-    return title_str;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  save_execlp                 ************** //
-// ************************************************************************** //
-
-typedef unit_test::basic_cstring<char> mbuffer;
-
-inline char*
-copy_arg( mbuffer& dest, const_string arg )
-{
-    if( dest.size() < arg.size()+1 )
-        return 0;
-
-    char* res = dest.begin();
-
-    std::memcpy( res, arg.begin(), arg.size()+1 );
-
-    dest.trim_left( arg.size()+1 );
-
-    return res;
-}
-
-//____________________________________________________________________________//
-
-bool
-safe_execlp( char const* file, ... )
-{
-    static char* argv_buff[200];
-
-    va_list     args;
-    char const* arg;
-
-    // first calculate actual number of arguments
-    int         num_args = 2; // file name and 0 at least
-
-    va_start( args, file );
-    while( !!(arg = va_arg( args, char const* )) )
-        num_args++;
-    va_end( args );
-
-    // reserve space for the argument pointers array
-    char**      argv_it  = argv_buff;
-    mbuffer     work_buff( reinterpret_cast<char*>(argv_buff), sizeof(argv_buff) );
-    work_buff.trim_left( num_args * sizeof(char*) );
-
-    // copy all the argument values into local storage
-    if( !(*argv_it++ = copy_arg( work_buff, file )) )
-        return false;
-
-    printf( "!! %s\n", file );
-
-    va_start( args, file );
-    while( !!(arg = va_arg( args, char const* )) ) {
-        printf( "!! %s\n", arg );
-        if( !(*argv_it++ = copy_arg( work_buff, arg )) )
-            return false;
-    }
-    va_end( args );
-
-    *argv_it = 0;
-
-    return ::execvp( file, argv_buff ) != -1;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************            start_debugger_in_emacs           ************** //
-// ************************************************************************** //
-
-static void
-start_debugger_in_emacs( dbg_startup_info const& dsi, char const* emacs_name, char const* dbg_command )
-{
-    char const* title = prepare_window_title( dsi );
-
-    if( !title )
-        return;
-
-    dsi.display.is_empty()
-        ? safe_execlp( emacs_name, "-title", title, "--eval", dbg_command, 0 )
-        : safe_execlp( emacs_name, "-title", title, "-display", dsi.display.begin(), "--eval", dbg_command, 0 );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 gdb starters                 ************** //
-// ************************************************************************** //
-
-static char const*
-prepare_gdb_cmnd_file( dbg_startup_info const& dsi )
-{
-    // prepare pid value
-    char pid_buff[16];
-    ::snprintf( pid_buff, sizeof(pid_buff), "%ld", dsi.pid );
-    unit_test::const_string pid_str( pid_buff );
-
-    static char cmd_file_name[] = "/tmp/btl_gdb_cmd_XXXXXX"; // !! ??
-
-    // prepare commands
-    fd_holder cmd_fd( ::mkstemp( cmd_file_name ) );
-
-    if( cmd_fd == -1 )
-        return 0;
-
-#define WRITE_STR( str )  if( ::write( cmd_fd, str.begin(), str.size() ) == -1 ) return 0;
-#define WRITE_CSTR( str ) if( ::write( cmd_fd, str, sizeof( str )-1 ) == -1 ) return 0;
-
-    WRITE_CSTR( "file " );
-    WRITE_STR( dsi.binary_path );
-    WRITE_CSTR( "\nattach " );
-    WRITE_STR( pid_str );
-    WRITE_CSTR( "\nshell unlink " );
-    WRITE_STR( dsi.init_done_lock );
-    WRITE_CSTR( "\ncont" );
-    if( dsi.break_or_continue )
-        WRITE_CSTR( "\nup 4" );
-            
-    WRITE_CSTR( "\necho \\n" ); // !! ??
-    WRITE_CSTR( "\nlist -" );
-    WRITE_CSTR( "\nlist" );
-    WRITE_CSTR( "\nshell unlink " );
-    WRITE_CSTR( cmd_file_name );
-
-    return cmd_file_name;
-}
-
-//____________________________________________________________________________//
-
-static void
-start_gdb_in_console( dbg_startup_info const& dsi )
-{
-    char const* cmnd_file_name = prepare_gdb_cmnd_file( dsi );
-
-    if( !cmnd_file_name )
-        return;
-
-    safe_execlp( "gdb", "-q", "-x", cmnd_file_name, 0 );
-}
-
-//____________________________________________________________________________//
-
-static void
-start_gdb_in_xterm( dbg_startup_info const& dsi )
-{
-    char const* title           = prepare_window_title( dsi );
-    char const* cmnd_file_name  = prepare_gdb_cmnd_file( dsi );
-
-    if( !title || !cmnd_file_name )
-        return;
-
-    safe_execlp( "xterm", "-T", title, "-display", dsi.display.begin(),
-                    "-bg", "black", "-fg", "white", "-geometry", "88x30+10+10", "-fn", "9x15", "-e",
-                 "gdb", "-q", "-x", cmnd_file_name, 0 );
-}
-
-//____________________________________________________________________________//
-
-static void
-start_gdb_in_emacs( dbg_startup_info const& dsi )
-{
-    char const* cmnd_file_name  = prepare_gdb_cmnd_file( dsi );
-    if( !cmnd_file_name )
-        return;
-
-    char dbg_cmd_buff[500]; // !! ??
-    ::snprintf( dbg_cmd_buff, sizeof(dbg_cmd_buff), "(progn (gdb \"gdb -q -x %s\"))", cmnd_file_name );
-
-    start_debugger_in_emacs( dsi, "emacs", dbg_cmd_buff );
-}
-
-//____________________________________________________________________________//
-
-static void
-start_gdb_in_xemacs( dbg_startup_info const& )
-{
-    // !! ??
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 dbx starters                 ************** //
-// ************************************************************************** //
-
-static char const*
-prepare_dbx_cmd_line( dbg_startup_info const& dsi, bool list_source = true )
-{
-    static char cmd_line_buff[500]; // !! ??
-
-    ::snprintf( cmd_line_buff, sizeof(cmd_line_buff), "unlink %s;cont;%s%s", 
-                   dsi.init_done_lock.begin(), 
-                   dsi.break_or_continue ? "up 2;": "", 
-                   list_source ? "echo \" \";list -w3;" : "" );
-
-    return cmd_line_buff;
-}
-
-//____________________________________________________________________________//
-
-static void
-start_dbx_in_console( dbg_startup_info const& dsi )
-{
-    char pid_buff[16];
-    ::snprintf( pid_buff, sizeof(pid_buff), "%ld", dsi.pid );
-
-    safe_execlp( "dbx", "-q", "-c", prepare_dbx_cmd_line( dsi ), dsi.binary_path.begin(), pid_buff, 0 );
-}
-
-//____________________________________________________________________________//
-
-static void
-start_dbx_in_xterm( dbg_startup_info const& dsi )
-{
-    char const* title = prepare_window_title( dsi );
-    if( !title )
-        return;
-
-    char pid_buff[16]; // !! ??
-    ::snprintf( pid_buff, sizeof(pid_buff), "%ld", dsi.pid );
-    
-    safe_execlp( "xterm", "-T", title, "-display", dsi.display.begin(), 
-                    "-bg", "black", "-fg", "white", "-geometry", "88x30+10+10", "-fn", "9x15", "-e",
-                 "dbx", "-q", "-c", prepare_dbx_cmd_line( dsi ), dsi.binary_path.begin(), pid_buff, 0 );
-}
-
-//____________________________________________________________________________//
-
-static void
-start_dbx_in_emacs( dbg_startup_info const& /*dsi*/ )
-{
-//    char dbg_cmd_buff[500]; // !! ??
-//
-//    ::snprintf( dbg_cmd_buff, sizeof(dbg_cmd_buff), "(progn (dbx \"dbx -q -c cont %s %ld\"))", dsi.binary_path.begin(), dsi.pid );
-
-//    start_debugger_in_emacs( dsi, "emacs", dbg_cmd_buff );
-}
-
-//____________________________________________________________________________//
-
-static void
-start_dbx_in_xemacs( dbg_startup_info const& )
-{
-    // !! ??
-}
-
-//____________________________________________________________________________//
-
-static void
-start_dbx_in_ddd( dbg_startup_info const& dsi )
-{
-    char const* title = prepare_window_title( dsi );
-    if( !title )
-        return;
-
-    char pid_buff[16]; // !! ??
-    ::snprintf( pid_buff, sizeof(pid_buff), "%ld", dsi.pid );
-    
-    safe_execlp( "ddd", "-display", dsi.display.begin(),
-                 "--dbx", "-q", "-c", prepare_dbx_cmd_line( dsi, false ), dsi.binary_path.begin(), pid_buff, 0 );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                debug::info_t                 ************** //
-// ************************************************************************** //
-
-static struct info_t {
-    // Constructor
-    info_t();
-
-    // Public properties
-    unit_test::readwrite_property<std::string>  p_dbg;
-    
-    // Data members
-    std::map<std::string,dbg_starter>           m_dbg_starter_reg;
-} s_info;
-
-//____________________________________________________________________________//
-
-info_t::info_t()
-{
-    p_dbg.value = ::getenv( "DISPLAY" )
-        ? std::string( BOOST_STRINGIZE( BOOST_TEST_GUI_DBG ) )
-        : std::string( BOOST_STRINGIZE( BOOST_TEST_CNL_DBG ) );
-        
-    m_dbg_starter_reg[std::string("gdb")]           = &start_gdb_in_console;
-    m_dbg_starter_reg[std::string("gdb-emacs")]     = &start_gdb_in_emacs;
-    m_dbg_starter_reg[std::string("gdb-xterm")]     = &start_gdb_in_xterm;
-    m_dbg_starter_reg[std::string("gdb-xemacs")]    = &start_gdb_in_xemacs;
-
-    m_dbg_starter_reg[std::string("dbx")]           = &start_dbx_in_console;
-    m_dbg_starter_reg[std::string("dbx-emacs")]     = &start_dbx_in_emacs;
-    m_dbg_starter_reg[std::string("dbx-xterm")]     = &start_dbx_in_xterm;
-    m_dbg_starter_reg[std::string("dbx-xemacs")]    = &start_dbx_in_xemacs;
-    m_dbg_starter_reg[std::string("dbx-ddd")]       = &start_dbx_in_ddd;
-}
-
-//____________________________________________________________________________//
-
-#endif
-
-} // local namespace
-
-// ************************************************************************** //
-// **************  check if program is running under debugger  ************** //
-// ************************************************************************** //
-
-bool
-under_debugger()
-{
-#if defined(BOOST_WIN32_BASED_DEBUG) // *********************** WIN32
-
-    return !!s_info.m_is_debugger_present && s_info.m_is_debugger_present();
-
-#elif defined(BOOST_UNIX_BASED_DEBUG) // ********************** UNIX
-
-    // !! ?? could/should we cache the result somehow?
-    const_string    dbg_list = BOOST_TEST_STRINGIZE( BOOST_TEST_DBG_LIST );
-
-    pid_t pid = ::getpid();
-
-    while( pid != 0 ) {
-        process_info pi( pid );
-
-        // !! ?? should we use tokenizer here instead?
-        if( dbg_list.find( pi.binary_name() ) != const_string::npos )
-            return true;
-
-        pid = (pi.parent_pid() == pid ? 0 : pi.parent_pid());
-    }
-
-    return false;
-
-#else // ****************************************************** default
-
-    return false;
-
-#endif
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************       cause program to break execution       ************** //
-// **************           in debugger at call point          ************** //
-// ************************************************************************** //
-
-void
-debugger_break()
-{
-    // !! ?? auto-start debugger?
-
-#if defined(BOOST_WIN32_BASED_DEBUG) // *********************** WIN32
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1300)                       ||  \
-    BOOST_WORKAROUND(__GNUC__, >= 3) && !defined(__MINGW32__)   ||  \
-    defined(__INTEL_COMPILER)
-#   define BOOST_DEBUG_BREAK    __debugbreak
-#else
-#   define BOOST_DEBUG_BREAK    DebugBreak
-#endif
-
-#ifndef __MINGW32__
-    if( !under_debugger() ) {
-        __try {
-            __try {
-                BOOST_DEBUG_BREAK();
-            }
-            __except( UnhandledExceptionFilter(GetExceptionInformation()) )
-            {
-                // User opted to ignore the breakpoint
-                return;
-            }
-        }
-        __except (EXCEPTION_EXECUTE_HANDLER)
-        {
-            // If we got here, the user has pushed Debug. Debugger is already attached to our process and we
-            // continue to let the another BOOST_DEBUG_BREAK to be called.
-        }
-    }
-#endif
-
-    BOOST_DEBUG_BREAK();
-
-#elif defined(BOOST_UNIX_BASED_DEBUG) // ********************** UNIX
-
-    ::kill( ::getpid(), SIGTRAP );
-
-#else // ****************************************************** default
-
-#endif
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************            console debugger setup            ************** //
-// ************************************************************************** //
-
-#if defined(BOOST_UNIX_BASED_DEBUG) // ************************ UNIX
-
-std::string
-set_debugger( unit_test::const_string dbg_id, dbg_starter s )
-{
-    std::string old = s_info.p_dbg;
-
-    assign_op( s_info.p_dbg.value, dbg_id, 0 );
-
-    if( !!s )
-        s_info.m_dbg_starter_reg[s_info.p_dbg] = s;
-
-    return old;
-}
-
-#else  // ***************************************************** default
-
-std::string
-set_debugger( unit_test::const_string, dbg_starter )
-{
-    return std::string();
-}
-
-#endif
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************    attach debugger to the current process    ************** //
-// ************************************************************************** //
-
-bool
-attach_debugger( bool break_or_continue )
-{
-    if( under_debugger() )
-        return false;
-
-#if defined(BOOST_WIN32_BASED_DEBUG) // *********************** WIN32
-
-    const int MAX_CMD_LINE = 200;
-
-    // *************************************************** //
-    // Debugger "ready" event
-
-    SECURITY_ATTRIBUTES attr;
-    attr.nLength                = sizeof(attr);
-    attr.lpSecurityDescriptor   = NULL;
-    attr.bInheritHandle         = true;
-
-    // manual resettable, initially non signaled, unnamed event,
-    // that will signal me that debugger initialization is done
-    HANDLE dbg_init_done_ev = ::CreateEvent(
-        &attr,          // pointer to security attributes
-        true,           // flag for manual-reset event
-        false,          // flag for initial state
-        NULL            // pointer to event-object name
-    );
-
-    if( !dbg_init_done_ev )
-        return false;
-
-    // *************************************************** //
-    // Debugger command line format
-
-    HKEY reg_key;
-
-    if( !s_info.m_reg_open_key || (*s_info.m_reg_open_key)(
-            HKEY_LOCAL_MACHINE,                                         // handle of open key
-            "Software\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug", // name of subkey to open
-            &reg_key ) != ERROR_SUCCESS )                               // address of handle of open key
-        return false;
-
-    char  format[MAX_CMD_LINE];
-    DWORD format_size = MAX_CMD_LINE;
-    DWORD type = REG_SZ;
-
-    if( !s_info.m_reg_query_value || (*s_info.m_reg_query_value)(
-            reg_key,                            // handle of open key
-            "Debugger",                         // name of subkey to query
-            0,                                  // reserved
-            &type,                              // value type
-            (LPBYTE)format,                     // buffer for returned string
-            &format_size ) != ERROR_SUCCESS )   // in: buffer size; out: actual size of returned string
-        return false;
-
-    if( !s_info.m_reg_close_key || (*s_info.m_reg_close_key)( reg_key ) != ERROR_SUCCESS )
-        return false;
-
-    // *************************************************** //
-    // Debugger command line
-
-    char cmd_line[MAX_CMD_LINE];
-    std::sprintf( cmd_line, format, ::GetCurrentProcessId(), dbg_init_done_ev );
-
-    // *************************************************** //
-    // Debugger window parameters
-
-    STARTUPINFOA    startup_info;
-    std::memset( &startup_info, 0, sizeof(startup_info) );
-
-    startup_info.cb             = sizeof(startup_info);
-    startup_info.dwFlags        = STARTF_USESHOWWINDOW;
-    startup_info.wShowWindow    = SW_SHOWNORMAL;
-
-    // debugger process s_info
-    PROCESS_INFORMATION debugger_info;
-
-    bool created = !!::CreateProcessA(
-        NULL,           // pointer to name of executable module; NULL - use the one in command line
-        cmd_line,       // pointer to command line string
-        NULL,           // pointer to process security attributes; NULL - debugger's handle can't be inherited
-        NULL,           // pointer to thread security attributes; NULL - debugger's handle can't be inherited
-        true,           // debugger inherit opened handles
-        0,              // priority flags; 0 - normal priority
-        NULL,           // pointer to new environment block; NULL - use this process environment
-        NULL,           // pointer to current directory name; NULL - use this process correct directory
-        &startup_info,  // pointer to STARTUPINFO that specifies main window appearance
-        &debugger_info  // pointer to PROCESS_INFORMATION that will contain the new process identification
-    );
-
-    if( created )
-        ::WaitForSingleObject( dbg_init_done_ev, INFINITE );
-
-    ::CloseHandle( dbg_init_done_ev );
-
-    if( !created )
-        return false;
-
-    if( break_or_continue )
-        debugger_break();
-
-    return true;
-
-#elif defined(BOOST_UNIX_BASED_DEBUG) // ********************** UNIX
-
-    char init_done_lock_fn[] = "/tmp/btl_dbg_init_done_XXXXXX";
-    fd_holder init_done_lock_fd( ::mkstemp( init_done_lock_fn ) );
-
-    if( init_done_lock_fd == -1 )
-        return false;
-    
-    pid_t child_pid = fork();
-
-    if( child_pid == -1 )
-        return false;
-
-    if( child_pid != 0 ) { // parent process - here we will start the debugger
-        dbg_startup_info dsi;
-    
-        process_info pi( child_pid );
-        if( pi.binary_path().is_empty() )
-            ::exit( -1 );
-
-        dsi.pid                 = child_pid;
-        dsi.break_or_continue   = break_or_continue;
-        dsi.binary_path         = pi.binary_path();
-        dsi.display             = ::getenv( "DISPLAY" );
-        dsi.init_done_lock      = init_done_lock_fn;
-        
-        dbg_starter starter = s_info.m_dbg_starter_reg[s_info.p_dbg];
-        if( !!starter )
-            starter( dsi );
-
-        ::perror( "Boost.Test execution monitor failed to start a debugger:" );
-
-        ::exit( -1 );
-    }
-
-    // child process - here we will continue our test module execution ; // !! ?? should it be vice versa
-
-    while( ::access( init_done_lock_fn, F_OK ) == 0 ) {
-        struct timeval to = { 0, 100 };
-
-        ::select( 0, 0, 0, 0, &to );
-    }
-
-//    char dummy;
-//    while( ::read( init_done_lock_fd, &dummy, sizeof(char) ) == 0 );
-
-    if( break_or_continue )
-        debugger_break();
-
-    return true;
-
-#else // ****************************************************** default
-
-    return false;
-
-#endif
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************   switch on/off detect memory leaks feature  ************** //
-// ************************************************************************** //
-
-void
-detect_memory_leaks( bool on_off )
-{
-    unit_test::ut_detail::ignore_unused_variable_warning( on_off );
-
-#ifdef BOOST_MS_CRT_BASED_DEBUG
-    int flags = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG );
-
-    if( !on_off )
-        flags &= ~_CRTDBG_LEAK_CHECK_DF;
-    else  {
-        flags |= _CRTDBG_LEAK_CHECK_DF;
-        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
-        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDOUT);
-    }
-
-    _CrtSetDbgFlag ( flags );
-#endif // BOOST_MS_CRT_BASED_DEBUG
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************      cause program to break execution in     ************** //
-// **************     debugger at specific allocation point    ************** //
-// ************************************************************************** //
-
-void
-break_memory_alloc( long mem_alloc_order_num )
-{
-    unit_test::ut_detail::ignore_unused_variable_warning( mem_alloc_order_num );
-
-#ifdef BOOST_MS_CRT_BASED_DEBUG
-    _CrtSetBreakAlloc( mem_alloc_order_num );
-#endif // BOOST_MS_CRT_BASED_DEBUG
-}
-
-} // namespace debug
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DEBUG_API_IPP_112006GER
-
diff --git a/contrib/autoboost/boost/test/impl/exception_safety.ipp b/contrib/autoboost/boost/test/impl/exception_safety.ipp
deleted file mode 100644
index cf697ebcf..000000000
--- a/contrib/autoboost/boost/test/impl/exception_safety.ipp
+++ /dev/null
@@ -1,537 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : Facilities to perform exception safety tests
-// ***************************************************************************
-
-#ifndef BOOST_TEST_EXECUTION_SAFETY_IPP_112005GER
-#define BOOST_TEST_EXECUTION_SAFETY_IPP_112005GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-
-#if BOOST_TEST_SUPPORT_INTERACTION_TESTING
-
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/unit_test_parameters.hpp>
-
-#include <boost/test/utils/callback.hpp>
-#include <boost/test/utils/wrap_stringstream.hpp>
-#include <boost/test/utils/iterator/token_iterator.hpp>
-
-#include <boost/test/interaction_based.hpp>
-#include <boost/test/test_tools.hpp>
-#include <boost/test/unit_test_log.hpp>
-#include <boost/test/framework.hpp>
-#include <boost/test/test_observer.hpp>
-#include <boost/test/debug.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-// Boost
-#include <boost/lexical_cast.hpp>
-
-// STL
-#include <vector>
-#include <cstdlib>
-#include <map>
-#include <iomanip>
-#include <cctype>
-#include <boost/limits.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-using namespace ::autoboost::unit_test;
- 
-namespace itest {
-
-// ************************************************************************** //
-// **************             execution_path_point             ************** //
-// ************************************************************************** //
-
-enum exec_path_point_type { EPP_SCOPE, EPP_EXCEPT, EPP_DECISION, EPP_ALLOC };
-
-struct execution_path_point {
-    execution_path_point( exec_path_point_type t, const_string file, std::size_t line_num )
-    : m_type( t )
-    , m_file_name( file )
-    , m_line_num( line_num )
-    {}
-
-    exec_path_point_type    m_type;
-    const_string             m_file_name;
-    std::size_t             m_line_num;
-
-    // Execution path point specific
-    struct decision_data {
-        bool            value;
-        unsigned        forced_exception_point;
-    };
-    struct scope_data {
-        unsigned        size;
-        char const*     name;
-    };
-    struct except_data {
-        char const*     description;
-    };
-    struct alloc_data {
-        void*           ptr;
-        std::size_t     size;
-    };
-
-    union {
-        struct decision_data    m_decision;
-        struct scope_data       m_scope;
-        struct except_data      m_except;
-        struct alloc_data       m_alloc;
-    };
-};
-
-// ************************************************************************** //
-// **************     exception safety test implementation     ************** //
-// ************************************************************************** //
-
-struct exception_safety_tester : itest::manager, test_observer {
-    // helpers types
-    struct unique_exception {};
-
-    // Constructor
-    explicit            exception_safety_tester( const_string test_name );
-    ~exception_safety_tester();
-
-    // check last run and prepare for next
-    bool                next_execution_path();
-
-    // memory tracking
-
-    // manager interface implementation
-    virtual void        exception_point( const_string file, std::size_t line_num, const_string description );
-    virtual bool        decision_point( const_string file, std::size_t line_num );
-    virtual unsigned    enter_scope( const_string file, std::size_t line_num, const_string scope_name );
-    virtual void        leave_scope( unsigned enter_scope_point );
-    virtual void        allocated( const_string file, std::size_t line_num, void* p, std::size_t s );
-    virtual void        freed( void* p );
-
-    // test observer interface
-    virtual void        assertion_result( bool passed );
-    virtual int         priority() { return (std::numeric_limits<int>::max)(); } // we want this observer to run the last
-
-private:
-    void                failure_point();
-    void                report_error();
-
-    typedef std::vector<execution_path_point>   exec_path;
-    typedef std::map<void*,unsigned>            registry;
-
-    // Data members
-    bool        m_internal_activity;
-    
-    unsigned    m_exception_point_counter;
-    unsigned    m_forced_exception_point;
-
-    unsigned    m_exec_path_point;
-    exec_path   m_execution_path;
-
-    unsigned    m_exec_path_counter;
-    unsigned    m_break_exec_path;
-    
-    bool        m_invairant_failed;
-    registry    m_memory_in_use;
-};
-
-//____________________________________________________________________________//
-
-struct activity_guard {
-    bool& m_v;
-
-    activity_guard( bool& v ) : m_v( v )    { m_v = true; }
-    ~activity_guard()                       { m_v = false; }
-};
-
-//____________________________________________________________________________//
-
-exception_safety_tester::exception_safety_tester( const_string test_name )
-: m_internal_activity( true )
-, m_exception_point_counter( 0 )
-, m_forced_exception_point( 1 )
-, m_exec_path_point( 0 )
-, m_exec_path_counter( 1 )
-, m_break_exec_path( static_cast<unsigned>(-1) )
-, m_invairant_failed( false )
-{
-    framework::register_observer( *this );
-
-    if( !runtime_config::break_exec_path().is_empty() ) {
-        using namespace unit_test;
-        
-        string_token_iterator tit( runtime_config::break_exec_path(), 
-                                   (dropped_delimeters = ":",kept_delimeters = " ") );
-        
-        const_string test_to_break = *tit;
-        
-        if( test_to_break == test_name ) {
-            ++tit;
-            
-            m_break_exec_path = lexical_cast<unsigned>( *tit );
-        }
-    }
-    
-    m_internal_activity = false;
-}
-
-//____________________________________________________________________________//
-
-exception_safety_tester::~exception_safety_tester()
-{
-    m_internal_activity = true;
-    
-    framework::deregister_observer( *this );
-}
-
-//____________________________________________________________________________//
-
-bool
-exception_safety_tester::next_execution_path()
-{
-    activity_guard ag( m_internal_activity );
-
-    // check memory usage
-    if( m_execution_path.size() > 0 ) {
-        bool errors_detected = m_invairant_failed || (m_memory_in_use.size() != 0);
-        framework::assertion_result( !errors_detected );
-
-        if( errors_detected )
-            report_error();
-
-        m_memory_in_use.clear();
-    }
-
-    m_exec_path_point           = 0;
-    m_exception_point_counter   = 0;
-    m_invairant_failed          = false;
-    ++m_exec_path_counter;
-
-    while( m_execution_path.size() > 0 ) {
-        switch( m_execution_path.back().m_type ) {
-        case EPP_SCOPE:
-        case EPP_ALLOC:
-            m_execution_path.pop_back();
-            break;
-
-        case EPP_DECISION:
-            if( !m_execution_path.back().m_decision.value ) {
-                m_execution_path.pop_back();
-                break;
-            }
-
-            m_execution_path.back().m_decision.value = false;
-            m_forced_exception_point = m_execution_path.back().m_decision.forced_exception_point;
-            return true;
-
-        case EPP_EXCEPT:
-            m_execution_path.pop_back();
-            ++m_forced_exception_point;
-            return true;
-        }
-    }
-
-    BOOST_TEST_MESSAGE( "Total tested " << --m_exec_path_counter << " execution path" );
-
-    return false;
-}
-
-//____________________________________________________________________________//
-
-void
-exception_safety_tester::exception_point( const_string file, std::size_t line_num, const_string description )
-{
-    activity_guard ag( m_internal_activity );
-
-    if( ++m_exception_point_counter == m_forced_exception_point ) {
-        m_execution_path.push_back(
-            execution_path_point( EPP_EXCEPT, file, line_num ) );
-
-        m_execution_path.back().m_except.description = description.begin();
-
-        ++m_exec_path_point;
-
-        failure_point();
-    }
-}
-
-//____________________________________________________________________________//
-
-bool
-exception_safety_tester::decision_point( const_string file, std::size_t line_num )
-{
-    activity_guard ag( m_internal_activity );
-
-    if( m_exec_path_point < m_execution_path.size() ) {
-        BOOST_REQUIRE_MESSAGE( m_execution_path[m_exec_path_point].m_type == EPP_DECISION &&
-                               m_execution_path[m_exec_path_point].m_file_name == file &&
-                               m_execution_path[m_exec_path_point].m_line_num == line_num,
-                               "Function under test exibit non-deterministic behavior" );
-    }
-    else {
-        m_execution_path.push_back(
-            execution_path_point( EPP_DECISION, file, line_num ) );
-
-        m_execution_path.back().m_decision.value = true;
-        m_execution_path.back().m_decision.forced_exception_point = m_forced_exception_point;
-    }
-
-    return m_execution_path[m_exec_path_point++].m_decision.value;
-}
-
-//____________________________________________________________________________//
-
-unsigned
-exception_safety_tester::enter_scope( const_string file, std::size_t line_num, const_string scope_name )
-{
-    activity_guard ag( m_internal_activity );
-
-    if( m_exec_path_point < m_execution_path.size() ) {
-        BOOST_REQUIRE_MESSAGE( m_execution_path[m_exec_path_point].m_type == EPP_SCOPE &&
-                               m_execution_path[m_exec_path_point].m_file_name == file &&
-                               m_execution_path[m_exec_path_point].m_line_num == line_num,
-                               "Function under test exibit non-deterministic behavior" );
-    }
-    else {
-        m_execution_path.push_back(
-            execution_path_point( EPP_SCOPE, file, line_num ) );
-    }
-
-    m_execution_path[m_exec_path_point].m_scope.size = 0;
-    m_execution_path[m_exec_path_point].m_scope.name = scope_name.begin();
-
-    return m_exec_path_point++;
-}
-
-//____________________________________________________________________________//
-
-void
-exception_safety_tester::leave_scope( unsigned enter_scope_point )
-{
-    activity_guard ag( m_internal_activity );
-
-    BOOST_REQUIRE_MESSAGE( m_execution_path[enter_scope_point].m_type == EPP_SCOPE,
-                           "Function under test exibit non-deterministic behavior" );
-
-    m_execution_path[enter_scope_point].m_scope.size = m_exec_path_point - enter_scope_point;
-}
-
-//____________________________________________________________________________//
-
-void
-exception_safety_tester::allocated( const_string file, std::size_t line_num, void* p, std::size_t s )
-{
-    if( m_internal_activity )
-        return;
-
-    activity_guard ag( m_internal_activity );
-
-    if( m_exec_path_point < m_execution_path.size() )
-        BOOST_REQUIRE_MESSAGE( m_execution_path[m_exec_path_point].m_type == EPP_ALLOC,
-                               "Function under test exibit non-deterministic behavior" );
-    else
-        m_execution_path.push_back(
-            execution_path_point( EPP_ALLOC, file, line_num ) );
-
-    m_execution_path[m_exec_path_point].m_alloc.ptr  = p;
-    m_execution_path[m_exec_path_point].m_alloc.size = s;
-
-    m_memory_in_use.insert( std::make_pair( p, m_exec_path_point++ ) );
-}
-
-//____________________________________________________________________________//
-
-void
-exception_safety_tester::freed( void* p )
-{
-    if( m_internal_activity )
-        return;
-
-    activity_guard ag( m_internal_activity );
-
-    registry::iterator it = m_memory_in_use.find( p );
-    if( it != m_memory_in_use.end() ) {
-        m_execution_path[it->second].m_alloc.ptr = 0;
-        m_memory_in_use.erase( it );
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-exception_safety_tester::assertion_result( bool passed )
-{
-    if( !m_internal_activity && !passed ) {
-        m_invairant_failed = true;
-
-        failure_point();
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-exception_safety_tester::failure_point()
-{
-    if( m_exec_path_counter == m_break_exec_path )
-        debug::debugger_break();
-    
-    throw unique_exception();
-}
-
-//____________________________________________________________________________//
-    
-namespace {
-
-inline void
-format_location( wrap_stringstream& formatter, execution_path_point const& /*p*/, unsigned indent )
-{
-    if( indent )
-        formatter << std::left << std::setw( indent ) << "";
-
-// !! ?? optional   if( p.m_file_name )
-//        formatter << p.m_file_name << '(' << p.m_line_num << "): ";
-}
-
-//____________________________________________________________________________//
-
-template<typename ExecPathIt>
-inline void
-format_execution_path( wrap_stringstream& formatter, ExecPathIt it, ExecPathIt end, unsigned indent = 0 )
-{
-    while( it != end ) {
-        switch( it->m_type ) {
-        case EPP_SCOPE:
-            format_location( formatter, *it, indent );
-            formatter << "> \"" << it->m_scope.name << "\"\n";
-            format_execution_path( formatter, it+1, it + it->m_scope.size, indent + 2 );
-            format_location( formatter, *it, indent );
-            formatter << "< \"" << it->m_scope.name << "\"\n";
-            it += it->m_scope.size;
-            break;
-
-        case EPP_DECISION:
-            format_location( formatter, *it, indent );
-            formatter << "Decision made as " << std::boolalpha << it->m_decision.value << '\n';
-            ++it;
-            break;
-
-        case EPP_EXCEPT:
-            format_location( formatter, *it, indent );
-            formatter << "Forced failure";
-            if( it->m_except.description )
-                formatter << ": " << it->m_except.description;
-            formatter << "\n";
-            ++it;
-            break;
-
-        case EPP_ALLOC:
-            if( it->m_alloc.ptr ) {
-                format_location( formatter, *it, indent );
-                formatter << "Allocated memory block 0x" << std::uppercase << it->m_alloc.ptr 
-                          << ", " << it->m_alloc.size << " bytes long: <";
-
-                unsigned i;
-                for( i = 0; i < std::min<std::size_t>( it->m_alloc.size, 8 ); i++ ) {
-                    unsigned char c = static_cast<unsigned char*>(it->m_alloc.ptr)[i];
-                    if( (std::isprint)( c ) )
-                        formatter << c;
-                    else
-                        formatter << '.';
-                }
-
-                formatter << "> ";
-
-                for( i = 0; i < std::min<std::size_t>( it->m_alloc.size, 8 ); i++ ) {
-                    unsigned c = static_cast<unsigned char*>(it->m_alloc.ptr)[i];
-                    formatter << std::hex << std::uppercase << c << ' ';
-                }
-
-                formatter << "\n";
-            }
-            ++it;
-            break;
-        }
-    }
-}
-
-//____________________________________________________________________________//
-
-} // local namespace
-
-void
-exception_safety_tester::report_error()
-{
-    activity_guard ag( m_internal_activity );
-
-    unit_test_log << unit_test::log::begin( m_execution_path.back().m_file_name,
-                                            m_execution_path.back().m_line_num )
-                  << log_all_errors;
-
-    wrap_stringstream formatter;
-
-    if( m_invairant_failed )
-        formatter << "Failed invariant";
-
-    if( m_memory_in_use.size() != 0 ) {
-        if( m_invairant_failed )
-            formatter << " and ";
-
-        formatter << static_cast<unsigned int>(m_memory_in_use.size()) << " memory leak";
-        if( m_memory_in_use.size() > 1 )
-            formatter << 's';
-    }
-    formatter << " detected in the execution path " << m_exec_path_counter << ":\n";
-
-    format_execution_path( formatter, m_execution_path.begin(), m_execution_path.end() );
-
-    unit_test_log << const_string( formatter.str() ) << unit_test::log::end();
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************             exception safety test            ************** //
-// ************************************************************************** //
-
-void BOOST_TEST_DECL
-exception_safety( callback0<> const& F, const_string test_name )
-{
-    exception_safety_tester est( test_name );
-
-    do {
-        try {
-            F();
-        }
-        catch( exception_safety_tester::unique_exception const& ) {}
-
-    } while( est.next_execution_path() );
-}
-
-//____________________________________________________________________________//
-
-}  // namespace itest
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // non-ancient compiler
-
-#endif // BOOST_TEST_EXECUTION_SAFETY_IPP_112005GER
diff --git a/contrib/autoboost/boost/test/impl/execution_monitor.ipp b/contrib/autoboost/boost/test/impl/execution_monitor.ipp
deleted file mode 100644
index b73fc5bec..000000000
--- a/contrib/autoboost/boost/test/impl/execution_monitor.ipp
+++ /dev/null
@@ -1,1367 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  (C) Copyright Beman Dawes and Ullrich Koethe 1995-2001.
-//  Use, modification, and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : provides execution monitor implementation for all supported
-//  configurations, including Microsoft structured exception based, unix signals
-//  based and special workarounds for borland
-//
-//  Note that when testing requirements or user wishes preclude use of this
-//  file as a separate compilation unit, it may be included as a header file.
-//
-//  Header dependencies are deliberately restricted to reduce coupling to other
-//  boost libraries.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_EXECUTION_MONITOR_IPP_012205GER
-#define BOOST_TEST_EXECUTION_MONITOR_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/detail/workaround.hpp>
-#include <boost/test/execution_monitor.hpp>
-#include <boost/test/debug.hpp>
-
-// Boost
-#include <boost/cstdlib.hpp>    // for exit codes
-#include <boost/config.hpp>     // for workarounds
-#include <boost/exception/get_error_info.hpp> // for get_error_info
-#include <boost/exception/current_exception_cast.hpp> // for current_exception_cast
-
-// STL
-#include <string>               // for std::string
-#include <new>                  // for std::bad_alloc
-#include <typeinfo>             // for std::bad_cast, std::bad_typeid
-#include <exception>            // for std::exception, std::bad_exception
-#include <stdexcept>            // for std exception hierarchy
-#include <cstring>              // for C string API
-#include <cassert>              // for assert
-#include <cstddef>              // for NULL
-#include <cstdio>               // for vsnprintf
-#include <cstdarg>              // for varargs
-
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::strerror; using ::strlen; using ::strncat; }
-#endif
-
-// to use vsnprintf
-#if defined(__SUNPRO_CC) || defined(__SunOS)
-#  include <stdio.h>
-#  include <stdarg.h>
-using std::va_list;
-#endif
-
-// to use vsnprintf 
-#if defined(__QNXNTO__) 
-#  include <stdio.h> 
-#endif
-
-#if defined(_WIN32) && !defined(BOOST_DISABLE_WIN32) &&                  \
-    (!defined(__COMO__) && !defined(__MWERKS__) && !defined(__GNUC__) || \
-     BOOST_WORKAROUND(__MWERKS__, >= 0x3000))
-
-#  define BOOST_SEH_BASED_SIGNAL_HANDLING
-
-#  include <windows.h>
-
-#  if defined(__MWERKS__) || (defined(_MSC_VER) && !defined(UNDER_CE))
-#    include <eh.h>
-#  endif
-
-#  if defined(__BORLANDC__) && __BORLANDC__ >= 0x560 || defined(__MWERKS__)
-#    include <stdint.h>
-#  endif
-
-#  if defined(__BORLANDC__) && __BORLANDC__ < 0x560
-    typedef unsigned uintptr_t;
-#  endif
-
-#  if BOOST_WORKAROUND(_MSC_VER,  < 1300 ) || defined(UNDER_CE)
-typedef void* uintptr_t;
-#  endif
-
-// for the FP control routines
-#include <float.h>
-
-#ifndef EM_INVALID
-#define EM_INVALID _EM_INVALID
-#endif
-
-#ifndef EM_DENORMAL
-#define EM_DENORMAL _EM_DENORMAL
-#endif
-
-#ifndef EM_ZERODIVIDE
-#define EM_ZERODIVIDE _EM_ZERODIVIDE
-#endif
-
-#ifndef EM_OVERFLOW
-#define EM_OVERFLOW _EM_OVERFLOW
-#endif
-
-#ifndef EM_UNDERFLOW
-#define EM_UNDERFLOW _EM_UNDERFLOW
-#endif
-
-#ifndef MCW_EM
-#define MCW_EM _MCW_EM
-#endif
-
-#  if !defined(NDEBUG) && defined(_MSC_VER) && !defined(UNDER_CE)
-#    include <crtdbg.h>
-#    define BOOST_TEST_CRT_HOOK_TYPE    _CRT_REPORT_HOOK
-#    define BOOST_TEST_CRT_ASSERT       _CRT_ASSERT
-#    define BOOST_TEST_CRT_ERROR        _CRT_ERROR
-#    define BOOST_TEST_CRT_SET_HOOK(H)  _CrtSetReportHook(H)
-#  else
-#    define BOOST_TEST_CRT_HOOK_TYPE    void*
-#    define BOOST_TEST_CRT_ASSERT       2
-#    define BOOST_TEST_CRT_ERROR        1
-#    define BOOST_TEST_CRT_SET_HOOK(H)  (void*)(H)
-#  endif
-
-#  if !BOOST_WORKAROUND(_MSC_VER,  >= 1400 ) || defined(UNDER_CE)
-
-typedef void* _invalid_parameter_handler;
-
-inline _invalid_parameter_handler
-_set_invalid_parameter_handler( _invalid_parameter_handler arg )
-{
-    return arg;
-}
-
-#  endif
-
-#  if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0564)) || defined(UNDER_CE)
-
-namespace { void _set_se_translator( void* ) {} }
-
-#  endif
-
-#elif defined(BOOST_HAS_SIGACTION)
-
-#  define BOOST_SIGACTION_BASED_SIGNAL_HANDLING
-
-#  include <unistd.h>
-#  include <signal.h>
-#  include <setjmp.h>
-
-#  if defined(__FreeBSD__)  
-
-#    ifndef SIGPOLL
-#      define SIGPOLL SIGIO
-#    endif
-
-#    if (__FreeBSD_version < 70100)
-
-#      define ILL_ILLADR 0 // ILL_RESAD_FAULT
-#      define ILL_PRVOPC ILL_PRIVIN_FAULT
-#      define ILL_ILLOPN 2 // ILL_RESOP_FAULT
-#      define ILL_COPROC ILL_FPOP_FAULT
-
-#      define BOOST_TEST_LIMITED_SIGNAL_DETAILS
-#      define BOOST_TEST_IGNORE_SIGCHLD
-
-#    endif 
-#  endif 
-
-#  if !defined(__CYGWIN__) && !defined(__QNXNTO__)
-#   define BOOST_TEST_USE_ALT_STACK
-#  endif
-
-#  if defined(SIGPOLL) && !defined(__CYGWIN__)                              && \
-      !(defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__))  && \
-      !defined(__NetBSD__)                                                  && \
-      !defined(__QNXNTO__)
-#    define BOOST_TEST_CATCH_SIGPOLL
-#  endif
-
-#  ifdef BOOST_TEST_USE_ALT_STACK
-#    define BOOST_TEST_ALT_STACK_SIZE SIGSTKSZ
-#  endif
-
-#else
-
-#  define BOOST_NO_SIGNAL_HANDLING
-
-#endif
-
-#ifndef UNDER_CE
-#include <errno.h>
-#endif
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-// ************************************************************************** //
-// **************                  report_error                ************** //
-// ************************************************************************** //
-
-namespace detail {
-
-#ifdef __BORLANDC__
-#  define BOOST_TEST_VSNPRINTF( a1, a2, a3, a4 ) std::vsnprintf( (a1), (a2), (a3), (a4) )
-#elif BOOST_WORKAROUND(_MSC_VER, <= 1310) || \
-      BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3000)) || \
-      defined(UNDER_CE)
-#  define BOOST_TEST_VSNPRINTF( a1, a2, a3, a4 ) _vsnprintf( (a1), (a2), (a3), (a4) )
-#else
-#  define BOOST_TEST_VSNPRINTF( a1, a2, a3, a4 ) vsnprintf( (a1), (a2), (a3), (a4) )
-#endif
-
-template <typename ErrorInfo>
-typename ErrorInfo::value_type
-extract( autoboost::exception const* ex )
-{
-    if( !ex )
-        return 0;
-
-    typename ErrorInfo::value_type const * val = autoboost::get_error_info<ErrorInfo>( *ex );
-
-    return val ? *val : 0;
-}
-
-//____________________________________________________________________________//
-
-static void
-report_error( execution_exception::error_code ec, autoboost::exception const* be, char const* format, va_list* args )
-{
-    static const int REPORT_ERROR_BUFFER_SIZE = 512;
-    static char buf[REPORT_ERROR_BUFFER_SIZE];
-
-    BOOST_TEST_VSNPRINTF( buf, sizeof(buf)-1, format, *args ); 
-    buf[sizeof(buf)-1] = 0;
-
-    va_end( *args );
-
-    throw execution_exception( ec, buf, execution_exception::location( extract<throw_file>( be ), 
-                                                                       extract<throw_line>( be ),
-                                                                       extract<throw_function>( be ) ) );
-}
-
-//____________________________________________________________________________//
-
-static void
-report_error( execution_exception::error_code ec, char const* format, ... )
-{
-    va_list args;
-    va_start( args, format );
-
-    report_error( ec, 0, format, &args );
-}
-
-//____________________________________________________________________________//
-
-static void
-report_error( execution_exception::error_code ec, autoboost::exception const* be, char const* format, ... )
-{
-    va_list args;
-    va_start( args, format );
-
-    report_error( ec, be, format, &args );
-}
-
-//____________________________________________________________________________//
-
-template<typename Tr,typename Functor>
-inline int
-do_invoke( Tr const& tr, Functor const& F )
-{
-    return tr ? (*tr)( F ) : F();
-}
-
-//____________________________________________________________________________//
-
-} // namespace detail
-
-#if defined(BOOST_SIGACTION_BASED_SIGNAL_HANDLING)
-
-// ************************************************************************** //
-// **************       Sigaction based signal handling        ************** //
-// ************************************************************************** //
-
-namespace detail {
-
-// ************************************************************************** //
-// **************    autoboost::detail::system_signal_exception    ************** //
-// ************************************************************************** //
-
-class system_signal_exception {
-public:
-    // Constructor
-    system_signal_exception()
-    : m_sig_info( 0 )
-    , m_context( 0 )
-    {}
-
-    // Access methods
-    void        operator()( siginfo_t* i, void* c )
-    {
-        m_sig_info  = i;
-        m_context   = c;
-    }
-    void        report() const;
-
-private:
-    // Data members
-    siginfo_t*  m_sig_info; // system signal detailed info
-    void*       m_context;  // signal context
-};
-
-//____________________________________________________________________________//
-
-void
-system_signal_exception::report() const
-{
-    if( !m_sig_info )
-        return; // no error actually occur?
-
-    switch( m_sig_info->si_code ) {
-    case SI_USER:
-        report_error( execution_exception::system_error,
-                      "signal: generated by kill() (or family); uid=%d; pid=%d",
-                      (int)m_sig_info->si_uid, (int)m_sig_info->si_pid );
-        break;
-    case SI_QUEUE:
-        report_error( execution_exception::system_error,
-                      "signal: sent by sigqueue()" );
-        break;
-    case SI_TIMER:
-        report_error( execution_exception::system_error,
-                      "signal: the expiration of a timer set by timer_settimer()" );
-        break;
-    case SI_ASYNCIO:
-        report_error( execution_exception::system_error,
-                      "signal: generated by the completion of an asynchronous I/O request" );
-        break;
-    case SI_MESGQ:
-        report_error( execution_exception::system_error,
-                      "signal: generated by the the arrival of a message on an empty message queue" );
-        break;
-    default:
-        break;
-    }
-
-    switch( m_sig_info->si_signo ) {
-    case SIGILL:
-        switch( m_sig_info->si_code ) {
-#ifndef BOOST_TEST_LIMITED_SIGNAL_DETAILS
-        case ILL_ILLOPC:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: illegal opcode; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case ILL_ILLTRP:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: illegal trap; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case ILL_PRVREG:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: privileged register; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case ILL_BADSTK:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: internal stack error; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-#endif
-        case ILL_ILLOPN:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: illegal operand; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case ILL_ILLADR:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: illegal addressing mode; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case ILL_PRVOPC:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: privileged opcode; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case ILL_COPROC:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: co-processor error; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        default: 
-            report_error( execution_exception::system_fatal_error, 
-                          "signal: SIGILL, si_code: %d (illegal instruction; address of failing instruction: 0x%08lx)", 
-                          m_sig_info->si_addr, m_sig_info->si_code ); 
-            break;
-        }
-        break;
-
-    case SIGFPE:
-        switch( m_sig_info->si_code ) {
-        case FPE_INTDIV:
-            report_error( execution_exception::system_error,
-                          "signal: integer divide by zero; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case FPE_INTOVF:
-            report_error( execution_exception::system_error,
-                          "signal: integer overflow; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case FPE_FLTDIV:
-            report_error( execution_exception::system_error,
-                          "signal: floating point divide by zero; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case FPE_FLTOVF:
-            report_error( execution_exception::system_error,
-                          "signal: floating point overflow; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case FPE_FLTUND:
-            report_error( execution_exception::system_error,
-                          "signal: floating point underflow; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case FPE_FLTRES:
-            report_error( execution_exception::system_error,
-                          "signal: floating point inexact result; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case FPE_FLTINV:
-            report_error( execution_exception::system_error,
-                          "signal: invalid floating point operation; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case FPE_FLTSUB:
-            report_error( execution_exception::system_error,
-                          "signal: subscript out of range; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        default:
-            report_error( execution_exception::system_error,
-                          "signal: SIGFPE, si_code: %d (errnoneous arithmetic operations; address of failing instruction: 0x%08lx)",
-                          m_sig_info->si_addr, m_sig_info->si_code );
-            break;
-        }
-        break;
-
-    case SIGSEGV:
-        switch( m_sig_info->si_code ) {
-#ifndef BOOST_TEST_LIMITED_SIGNAL_DETAILS
-        case SEGV_MAPERR:
-            report_error( execution_exception::system_fatal_error,
-                          "memory access violation at address: 0x%08lx: no mapping at fault address",
-                          m_sig_info->si_addr );
-            break;
-        case SEGV_ACCERR:
-            report_error( execution_exception::system_fatal_error,
-                          "memory access violation at address: 0x%08lx: invalid permissions",
-                          m_sig_info->si_addr );
-            break;
-#endif
-        default:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: SIGSEGV, si_code: %d (memory access violation at address: 0x%08lx)",
-                          m_sig_info->si_addr, m_sig_info->si_code );
-            break;
-        }
-        break;
-
-    case SIGBUS:
-        switch( m_sig_info->si_code ) {
-#ifndef BOOST_TEST_LIMITED_SIGNAL_DETAILS
-        case BUS_ADRALN:
-            report_error( execution_exception::system_fatal_error,
-                          "memory access violation at address: 0x%08lx: invalid address alignment",
-                          m_sig_info->si_addr );
-            break;
-        case BUS_ADRERR:
-            report_error( execution_exception::system_fatal_error,
-                          "memory access violation at address: 0x%08lx: non-existent physical address",
-                          m_sig_info->si_addr );
-            break;
-        case BUS_OBJERR:
-            report_error( execution_exception::system_fatal_error,
-                          "memory access violation at address: 0x%08lx: object specific hardware error",
-                          m_sig_info->si_addr );
-            break;
-#endif
-        default:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: SIGSEGV, si_code: %d (memory access violation at address: 0x%08lx)",
-                          m_sig_info->si_addr, m_sig_info->si_code );
-            break;
-        }
-        break;
-
-    case SIGCHLD:
-        switch( m_sig_info->si_code ) {
-#ifndef BOOST_TEST_LIMITED_SIGNAL_DETAILS
-        case CLD_EXITED:
-            report_error( execution_exception::system_error,
-                          "child has exited; pid: %d; uid: %d; exit value: %d",
-                          (int)m_sig_info->si_pid, (int)m_sig_info->si_uid, (int)m_sig_info->si_status );
-            break;
-        case CLD_KILLED:
-            report_error( execution_exception::system_error,
-                          "child was killed; pid: %d; uid: %d; exit value: %d",
-                          (int)m_sig_info->si_pid, (int)m_sig_info->si_uid, (int)m_sig_info->si_status );
-            break;
-        case CLD_DUMPED:
-            report_error( execution_exception::system_error,
-                          "child terminated abnormally; pid: %d; uid: %d; exit value: %d",
-                          (int)m_sig_info->si_pid, (int)m_sig_info->si_uid, (int)m_sig_info->si_status );
-            break;
-        case CLD_TRAPPED:
-            report_error( execution_exception::system_error,
-                          "traced child has trapped; pid: %d; uid: %d; exit value: %d",
-                          (int)m_sig_info->si_pid, (int)m_sig_info->si_uid, (int)m_sig_info->si_status );
-            break;
-        case CLD_STOPPED:
-            report_error( execution_exception::system_error,
-                          "child has stopped; pid: %d; uid: %d; exit value: %d",
-                          (int)m_sig_info->si_pid, (int)m_sig_info->si_uid, (int)m_sig_info->si_status );
-            break;
-        case CLD_CONTINUED:
-            report_error( execution_exception::system_error,
-                          "stopped child had continued; pid: %d; uid: %d; exit value: %d",
-                          (int)m_sig_info->si_pid, (int)m_sig_info->si_uid, (int)m_sig_info->si_status );
-            break;
-#endif
-        default:
-            report_error( execution_exception::system_error,
-                          "signal: SIGCHLD, si_code: %d (child process has terminated; pid: %d; uid: %d; exit value: %d)",
-                          (int)m_sig_info->si_pid, (int)m_sig_info->si_uid, (int)m_sig_info->si_status, m_sig_info->si_code );
-            break;
-        }
-        break;
-
-#if defined(BOOST_TEST_CATCH_SIGPOLL)
-
-    case SIGPOLL:
-        switch( m_sig_info->si_code ) {
-#ifndef BOOST_TEST_LIMITED_SIGNAL_DETAILS
-        case POLL_IN:
-            report_error( execution_exception::system_error,
-                          "data input available; band event %d",
-                          (int)m_sig_info->si_band );
-            break;
-        case POLL_OUT:
-            report_error( execution_exception::system_error,
-                          "output buffers available; band event %d",
-                          (int)m_sig_info->si_band );
-            break;
-        case POLL_MSG:
-            report_error( execution_exception::system_error,
-                          "input message available; band event %d",
-                          (int)m_sig_info->si_band );
-            break;
-        case POLL_ERR:
-            report_error( execution_exception::system_error,
-                          "i/o error; band event %d",
-                          (int)m_sig_info->si_band );
-            break;
-        case POLL_PRI:
-            report_error( execution_exception::system_error,
-                          "high priority input available; band event %d",
-                          (int)m_sig_info->si_band );
-            break;
-#if defined(POLL_ERR) && defined(POLL_HUP) && (POLL_ERR - POLL_HUP)
-        case POLL_HUP:
-            report_error( execution_exception::system_error,
-                          "device disconnected; band event %d",
-                          (int)m_sig_info->si_band );
-            break;
-#endif
-#endif
-        default: 
-            report_error( execution_exception::system_error, 
-                          "signal: SIGPOLL, si_code: %d (asynchronous I/O event occured; band event %d)", 
-                          (int)m_sig_info->si_band, m_sig_info->si_code ); 
-            break; 
-        }
-        break;
-
-#endif
-
-    case SIGABRT:
-        report_error( execution_exception::system_error,
-                      "signal: SIGABRT (application abort requested)" );
-        break;
-
-    case SIGALRM:
-        report_error( execution_exception::timeout_error,
-                      "signal: SIGALRM (timeout while executing function)" );
-        break;
-
-    default:
-        report_error( execution_exception::system_error, "unrecognized signal" );
-    }
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************         autoboost::detail::signal_action         ************** //
-// ************************************************************************** //
-
-// Forward declaration
-extern "C" {
-static void execution_monitor_jumping_signal_handler( int sig, siginfo_t* info, void* context );
-static void execution_monitor_attaching_signal_handler( int sig, siginfo_t* info, void* context );
-}
-
-class signal_action {
-    typedef struct sigaction* sigaction_ptr;
-public:
-    //Constructor
-    signal_action();
-    signal_action( int sig, bool install, bool attach_dbg, char* alt_stack );
-    ~signal_action();
-
-private:
-    // Data members
-    int                 m_sig;
-    bool                m_installed;
-    struct sigaction    m_new_action;
-    struct sigaction    m_old_action;
-};
-
-//____________________________________________________________________________//
-
-signal_action::signal_action()
-: m_installed( false )
-{}
-
-//____________________________________________________________________________//
-
-signal_action::signal_action( int sig, bool install, bool attach_dbg, char* alt_stack )
-: m_sig( sig )
-, m_installed( install )
-{
-    if( !install )
-        return;
-
-    std::memset( &m_new_action, 0, sizeof(struct sigaction) );
-
-    BOOST_TEST_SYS_ASSERT( ::sigaction( m_sig , sigaction_ptr(), &m_new_action ) != -1 );
-
-    if( m_new_action.sa_sigaction || m_new_action.sa_handler ) {
-        m_installed = false;
-        return;
-    }
-
-    m_new_action.sa_flags     |= SA_SIGINFO;
-    m_new_action.sa_sigaction  = attach_dbg ? &execution_monitor_attaching_signal_handler
-                                            : &execution_monitor_jumping_signal_handler;
-    BOOST_TEST_SYS_ASSERT( sigemptyset( &m_new_action.sa_mask ) != -1 );
-
-#ifdef BOOST_TEST_USE_ALT_STACK
-    if( alt_stack )
-        m_new_action.sa_flags |= SA_ONSTACK;
-#endif
-
-    BOOST_TEST_SYS_ASSERT( ::sigaction( m_sig, &m_new_action, &m_old_action ) != -1 );
-}
-
-//____________________________________________________________________________//
-
-signal_action::~signal_action()
-{
-    if( m_installed )
-        ::sigaction( m_sig, &m_old_action , sigaction_ptr() );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************        autoboost::detail::signal_handler         ************** //
-// ************************************************************************** //
-
-class signal_handler {
-public:
-    // Constructor
-    explicit signal_handler( bool catch_system_errors, int timeout, bool attach_dbg, char* alt_stack );
-
-    // Destructor
-    ~signal_handler();
-
-    // access methods
-    static sigjmp_buf&      jump_buffer()
-    {
-        assert( !!s_active_handler );
-
-        return s_active_handler->m_sigjmp_buf;
-    }
-
-    static system_signal_exception&  sys_sig()
-    {
-        assert( !!s_active_handler );
-
-        return s_active_handler->m_sys_sig;
-    }
-
-private:
-    // Data members
-    signal_handler*         m_prev_handler;
-    int                     m_timeout;
-
-    signal_action           m_ILL_action;
-    signal_action           m_FPE_action;
-    signal_action           m_SEGV_action;
-    signal_action           m_BUS_action;
-    signal_action           m_CHLD_action;
-    signal_action           m_POLL_action;
-    signal_action           m_ABRT_action;
-    signal_action           m_ALRM_action;
-
-    sigjmp_buf              m_sigjmp_buf;
-    system_signal_exception m_sys_sig;
-
-    static signal_handler*  s_active_handler;
-};
-
-// !! need to be placed in thread specific storage
-typedef signal_handler* signal_handler_ptr;
-signal_handler* signal_handler::s_active_handler = signal_handler_ptr();
-
-//____________________________________________________________________________//
-
-signal_handler::signal_handler( bool catch_system_errors, int timeout, bool attach_dbg, char* alt_stack )
-: m_prev_handler( s_active_handler )
-, m_timeout( timeout )
-, m_ILL_action ( SIGILL , catch_system_errors, attach_dbg, alt_stack )
-, m_FPE_action ( SIGFPE , catch_system_errors, attach_dbg, alt_stack )
-, m_SEGV_action( SIGSEGV, catch_system_errors, attach_dbg, alt_stack )
-, m_BUS_action ( SIGBUS , catch_system_errors, attach_dbg, alt_stack )
-#ifndef BOOST_TEST_IGNORE_SIGCHLD
-, m_CHLD_action( SIGCHLD, catch_system_errors, attach_dbg, alt_stack )
-#endif
-#ifdef BOOST_TEST_CATCH_SIGPOLL
-, m_POLL_action( SIGPOLL, catch_system_errors, attach_dbg, alt_stack )
-#endif
-, m_ABRT_action( SIGABRT, catch_system_errors, attach_dbg, alt_stack )
-, m_ALRM_action( SIGALRM, timeout > 0        , attach_dbg, alt_stack )
-{
-    s_active_handler = this;
-
-    if( m_timeout > 0 ) {
-        ::alarm( 0 );
-        ::alarm( timeout );
-    }
-
-#ifdef BOOST_TEST_USE_ALT_STACK
-    if( alt_stack ) {
-        stack_t sigstk;
-        std::memset( &sigstk, 0, sizeof(stack_t) );
-
-        BOOST_TEST_SYS_ASSERT( ::sigaltstack( 0, &sigstk ) != -1 );
-
-        if( sigstk.ss_flags & SS_DISABLE ) {
-            sigstk.ss_sp    = alt_stack;
-            sigstk.ss_size  = BOOST_TEST_ALT_STACK_SIZE;
-            sigstk.ss_flags = 0;
-            BOOST_TEST_SYS_ASSERT( ::sigaltstack( &sigstk, 0 ) != -1 );
-        }
-    }
-#endif
-}
-
-//____________________________________________________________________________//
-
-signal_handler::~signal_handler()
-{
-    assert( s_active_handler == this );
-
-    if( m_timeout > 0 )
-        ::alarm( 0 );
-
-#ifdef BOOST_TEST_USE_ALT_STACK
-#ifdef __GNUC__
-    // We shouldn't need to explicitly initialize all the members here,
-    // but gcc warns if we don't, so add initializers for each of the
-    // members specified in the POSIX std:
-    stack_t sigstk = { 0, 0, 0 };
-#else
-    stack_t sigstk = { };
-#endif
-
-    sigstk.ss_size  = MINSIGSTKSZ;
-    sigstk.ss_flags = SS_DISABLE;
-    BOOST_TEST_SYS_ASSERT( ::sigaltstack( &sigstk, 0 ) != -1 );
-#endif
-
-    s_active_handler = m_prev_handler;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************       execution_monitor_signal_handler       ************** //
-// ************************************************************************** //
-
-extern "C" {
-
-static bool ignore_sigchild( siginfo_t* info )
-{
-    return info->si_signo == SIGCHLD
-#ifndef BOOST_TEST_LIMITED_SIGNAL_DETAILS
-            && info->si_code == CLD_EXITED 
-#endif
-#ifdef BOOST_TEST_IGNORE_NON_ZERO_CHILD_CODE
-            ;
-#else
-            && (int)info->si_status == 0;
-#endif
-}
-
-//____________________________________________________________________________//
-
-static void execution_monitor_jumping_signal_handler( int sig, siginfo_t* info, void* context )
-{
-    if( ignore_sigchild( info ) )
-        return;
-
-    signal_handler::sys_sig()( info, context );
-
-    siglongjmp( signal_handler::jump_buffer(), sig );
-}
-
-//____________________________________________________________________________//
-
-static void execution_monitor_attaching_signal_handler( int sig, siginfo_t* info, void* context )
-{
-    if( ignore_sigchild( info ) )
-        return;
-
-    if( !debug::attach_debugger( false ) )
-        execution_monitor_jumping_signal_handler( sig, info, context );
-
-    // debugger attached; it will handle the signal
-    BOOST_TEST_SYS_ASSERT( ::signal( sig, SIG_DFL ) != SIG_ERR );
-}
-
-//____________________________________________________________________________//
-
-}
-
-} // namespace detail
-
-// ************************************************************************** //
-// **************        execution_monitor::catch_signals      ************** //
-// ************************************************************************** //
-
-int
-execution_monitor::catch_signals( unit_test::callback0<int> const& F )
-{
-    using namespace detail;
-
-#if defined(__CYGWIN__)
-    p_catch_system_errors.value = false;
-#endif
-
-#ifdef BOOST_TEST_USE_ALT_STACK
-    if( !!p_use_alt_stack && !m_alt_stack )
-        m_alt_stack.reset( new char[BOOST_TEST_ALT_STACK_SIZE] );
-#else
-    p_use_alt_stack.value = false;
-#endif
-
-    signal_handler local_signal_handler( p_catch_system_errors, p_timeout, p_auto_start_dbg, 
-                                         !p_use_alt_stack ? 0 : m_alt_stack.get() );
-
-    if( !sigsetjmp( signal_handler::jump_buffer(), 1 ) )
-        return detail::do_invoke( m_custom_translators , F );
-    else
-        throw local_signal_handler.sys_sig();
-}
-
-//____________________________________________________________________________//
-
-#elif defined(BOOST_SEH_BASED_SIGNAL_HANDLING)
-
-// ************************************************************************** //
-// **************   Microsoft structured exception handling    ************** //
-// ************************************************************************** //
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0564))
-namespace { void _set_se_translator( void* ) {} }
-#endif
-
-namespace detail {
-
-// ************************************************************************** //
-// **************    autoboost::detail::system_signal_exception    ************** //
-// ************************************************************************** //
-
-class system_signal_exception {
-public:
-    // Constructor
-    explicit            system_signal_exception( execution_monitor* em )
-    : m_em( em )
-    , m_se_id( 0 )
-    , m_fault_address( 0 )
-    , m_dir( false )
-    {}
-
-    void                report() const;
-    int                 operator()( unsigned int id, _EXCEPTION_POINTERS* exps );
-
-private:
-    // Data members
-    execution_monitor*  m_em;
-
-    unsigned int        m_se_id;
-    void*               m_fault_address;
-    bool                m_dir;
-};
-
-static void
-seh_catch_preventer( unsigned int /* id */, _EXCEPTION_POINTERS* /* exps */ )
-{
-    throw;
-}
-
-//____________________________________________________________________________//
-
-int
-system_signal_exception::operator()( unsigned int id, _EXCEPTION_POINTERS* exps )
-{
-    const unsigned int MSFT_CPP_EXCEPT = 0xE06d7363; // EMSC
-
-    if( !m_em->p_catch_system_errors || (id == MSFT_CPP_EXCEPT) )
-        return EXCEPTION_CONTINUE_SEARCH;
-
-    if( !!m_em->p_auto_start_dbg && debug::attach_debugger( false ) ) {
-        m_em->p_catch_system_errors.value = false;
-        _set_se_translator( &seh_catch_preventer );
-
-        return EXCEPTION_CONTINUE_EXECUTION;
-    }
-
-    m_se_id = id;
-    if( m_se_id == EXCEPTION_ACCESS_VIOLATION && exps->ExceptionRecord->NumberParameters == 2 ) {
-        m_fault_address = (void*)exps->ExceptionRecord->ExceptionInformation[1];
-        m_dir           = exps->ExceptionRecord->ExceptionInformation[0] == 0;
-    }
-
-    return EXCEPTION_EXECUTE_HANDLER;
-}
-
-//____________________________________________________________________________//
-
-void
-system_signal_exception::report() const
-{
-    switch( m_se_id ) {
-    // cases classified as system_fatal_error
-    case EXCEPTION_ACCESS_VIOLATION: {
-        if( !m_fault_address )
-            detail::report_error( execution_exception::system_fatal_error, "memory access violation" );
-        else
-            detail::report_error(
-                execution_exception::system_fatal_error,
-                    "memory access violation occurred at address 0x%08lx, while attempting to %s",
-                    m_fault_address,
-                    m_dir ? " read inaccessible data"
-                          : " write to an inaccessible (or protected) address"
-                    );
-        break;
-    }
-
-    case EXCEPTION_ILLEGAL_INSTRUCTION:
-        detail::report_error( execution_exception::system_fatal_error, "illegal instruction" );
-        break;
-
-    case EXCEPTION_PRIV_INSTRUCTION:
-        detail::report_error( execution_exception::system_fatal_error, "tried to execute an instruction whose operation is not allowed in the current machine mode" );
-        break;
-
-    case EXCEPTION_IN_PAGE_ERROR:
-        detail::report_error( execution_exception::system_fatal_error, "access to a memory page that is not present" );
-        break;
-
-    case EXCEPTION_STACK_OVERFLOW:
-        detail::report_error( execution_exception::system_fatal_error, "stack overflow" );
-        break;
-
-    case EXCEPTION_NONCONTINUABLE_EXCEPTION:
-        detail::report_error( execution_exception::system_fatal_error, "tried to continue execution after a non continuable exception occurred" );
-        break;
-
-    // cases classified as (non-fatal) system_trap
-    case EXCEPTION_DATATYPE_MISALIGNMENT:
-        detail::report_error( execution_exception::system_error, "data misalignment" );
-        break;
-
-    case EXCEPTION_INT_DIVIDE_BY_ZERO:
-        detail::report_error( execution_exception::system_error, "integer divide by zero" );
-        break;
-
-    case EXCEPTION_INT_OVERFLOW:
-        detail::report_error( execution_exception::system_error, "integer overflow" );
-        break;
-
-    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
-        detail::report_error( execution_exception::system_error, "array bounds exceeded" );
-        break;
-
-    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-        detail::report_error( execution_exception::system_error, "floating point divide by zero" );
-        break;
-
-    case EXCEPTION_FLT_STACK_CHECK:
-        detail::report_error( execution_exception::system_error,
-                              "stack overflowed or underflowed as the result of a floating-point operation" );
-        break;
-
-    case EXCEPTION_FLT_DENORMAL_OPERAND:
-        detail::report_error( execution_exception::system_error,
-                              "operand of floating point operation is denormal" );
-        break;
-
-# if 0 // !! ?? 
-    case EXCEPTION_FLT_INEXACT_RESULT:
-        detail::report_error( execution_exception::system_error,
-                              "result of a floating-point operation cannot be represented exactly" );
-        break;
-#endif
-
-    case EXCEPTION_FLT_OVERFLOW:
-        detail::report_error( execution_exception::system_error,
-                              "exponent of a floating-point operation is greater than the magnitude allowed by the corresponding type" );
-        break;
-
-    case EXCEPTION_FLT_UNDERFLOW:
-        detail::report_error( execution_exception::system_error,
-                              "exponent of a floating-point operation is less than the magnitude allowed by the corresponding type" );
-        break;
-
-    case EXCEPTION_FLT_INVALID_OPERATION:
-        detail::report_error( execution_exception::system_error, "floating point error" );
-        break;
-
-    case EXCEPTION_BREAKPOINT:
-        detail::report_error( execution_exception::system_error, "breakpoint encountered" );
-        break;
-
-    default:
-        detail::report_error( execution_exception::system_error, "unrecognized exception. Id: 0x%08lx", m_se_id );
-        break;
-    }
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************          assert_reporting_function           ************** //
-// ************************************************************************** //
-
-int BOOST_TEST_CALL_DECL
-assert_reporting_function( int reportType, char* userMessage, int* )
-{
-    switch( reportType ) {
-    case BOOST_TEST_CRT_ASSERT:
-        detail::report_error( execution_exception::user_error, userMessage );
-
-        return 1; // return value and retVal are not important since we never reach this line
-    case BOOST_TEST_CRT_ERROR:
-        detail::report_error( execution_exception::system_error, userMessage );
-
-        return 1; // return value and retVal are not important since we never reach this line
-    default:
-        return 0; // use usual reporting method
-    }
-} // assert_reporting_function
-
-//____________________________________________________________________________//
-
-void BOOST_TEST_CALL_DECL
-invalid_param_handler( wchar_t const* /* expr */, 
-                       wchar_t const* /* func */, 
-                       wchar_t const* /* file */, 
-                       unsigned int   /* line */,
-                       uintptr_t      /* reserved */)
-{
-    detail::report_error( execution_exception::user_error, 
-                          "Invalid parameter detected by C runtime library" );
-}
-
-//____________________________________________________________________________//
-
-void BOOST_TEST_CALL_DECL
-switch_fp_exceptions( bool on_off )
-{
-    if( !on_off )
-        _clearfp();
-
-    int cw = ::_controlfp( 0, 0 );
-
-    int exceptions_mask = EM_INVALID|EM_DENORMAL|EM_ZERODIVIDE|EM_OVERFLOW|EM_UNDERFLOW;
-
-    if( on_off )
-        cw &= ~exceptions_mask; // Set the exception masks on, turn exceptions off
-    else
-        cw |= exceptions_mask;  // Set the exception masks off, turn exceptions on
-
-    if( on_off )
-        _clearfp();
-        
-    // Set the control word
-    ::_controlfp( cw, MCW_EM );
-}
-
-//____________________________________________________________________________//
-
-} // namespace detail
-
-// ************************************************************************** //
-// **************        execution_monitor::catch_signals      ************** //
-// ************************************************************************** //
-
-int
-execution_monitor::catch_signals( unit_test::callback0<int> const& F )
-{
-    _invalid_parameter_handler old_iph = _invalid_parameter_handler();
-    BOOST_TEST_CRT_HOOK_TYPE old_crt_hook = 0;
-
-    if( !p_catch_system_errors )
-        _set_se_translator( &detail::seh_catch_preventer );
-    else {
-        if( !!p_detect_fp_exceptions )
-            detail::switch_fp_exceptions( true );
-
-       old_crt_hook = BOOST_TEST_CRT_SET_HOOK( &detail::assert_reporting_function );
-
-       old_iph = _set_invalid_parameter_handler( 
-           reinterpret_cast<_invalid_parameter_handler>( &detail::invalid_param_handler ) );
-    }
-
-    detail::system_signal_exception SSE( this );
-    
-    int ret_val = 0;
-
-    __try {
-        __try {
-            ret_val = detail::do_invoke( m_custom_translators, F );
-        }
-        __except( SSE( GetExceptionCode(), GetExceptionInformation() ) ) {
-            throw SSE;
-        }
-    }
-    __finally {
-        if( !!p_catch_system_errors ) {
-            if( !!p_detect_fp_exceptions )
-                detail::switch_fp_exceptions( false );
-
-            BOOST_TEST_CRT_SET_HOOK( old_crt_hook );
-
-           _set_invalid_parameter_handler( old_iph );
-        }
-    }
-
-    return ret_val;
-}
-
-//____________________________________________________________________________//
-
-#else  // default signal handler
-
-namespace detail {
-
-class system_signal_exception {
-public:
-    void   report() const {}
-};
-
-} // namespace detail
-
-int
-execution_monitor::catch_signals( unit_test::callback0<int> const& F )
-{
-    return detail::do_invoke( m_custom_translators , F );
-}
-
-//____________________________________________________________________________//
-
-#endif  // choose signal handler
-
-// ************************************************************************** //
-// **************          execution_monitor::execute          ************** //
-// ************************************************************************** //
-
-int
-execution_monitor::execute( unit_test::callback0<int> const& F )
-{
-    if( debug::under_debugger() )
-        p_catch_system_errors.value = false;
-
-    try {
-        return catch_signals( F );
-    }
-
-    //  Catch-clause reference arguments are a bit different from function
-    //  arguments (ISO 15.3 paragraphs 18 & 19).  Apparently const isn't
-    //  required.  Programmers ask for const anyhow, so we supply it.  That's
-    //  easier than answering questions about non-const usage.
-
-    catch( char const* ex )
-      { detail::report_error( execution_exception::cpp_exception_error,
-                              "C string: %s", ex ); }
-    catch( std::string const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              "std::string: %s", ex.c_str() ); }
-
-    //  std:: exceptions
-
-    catch( std::bad_alloc const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::bad_alloc: %s", ex.what() ); }
-
-#if BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)
-    catch( std::bad_cast const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::bad_cast" ); }
-    catch( std::bad_typeid const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::bad_typeid" ); }
-#else
-    catch( std::bad_cast const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::bad_cast: %s", ex.what() ); }
-    catch( std::bad_typeid const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::bad_typeid: %s", ex.what() ); }
-#endif
-
-    catch( std::bad_exception const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::bad_exception: %s", ex.what() ); }
-    catch( std::domain_error const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::domain_error: %s", ex.what() ); }
-    catch( std::invalid_argument const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::invalid_argument: %s", ex.what() ); }
-    catch( std::length_error const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::length_error: %s", ex.what() ); }
-    catch( std::out_of_range const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::out_of_range: %s", ex.what() ); }
-    catch( std::range_error const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::range_error: %s", ex.what() ); }
-    catch( std::overflow_error const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::overflow_error: %s", ex.what() ); }
-    catch( std::underflow_error const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::underflow_error: %s", ex.what() ); }
-    catch( std::logic_error const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::logic_error: %s", ex.what() ); }
-    catch( std::runtime_error const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::runtime_error: %s", ex.what() ); }
-    catch( std::exception const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              current_exception_cast<autoboost::exception const>(),
-                              "std::exception: %s", ex.what() ); }
-
-    catch( autoboost::exception const& ex )
-    { detail::report_error( execution_exception::cpp_exception_error, 
-                            &ex,
-                            "unknown autoboost::exception" ); }
-
-    // system errors
-    catch( system_error const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error, 
-                              "system_error produced by: %s: %s", ex.p_failed_exp.get(), std::strerror( ex.p_errno ) ); }
-    catch( detail::system_signal_exception const& ex )
-      { ex.report(); }
-
-    // not an error
-    catch( execution_aborted const& )
-      { return 0; }
-
-    // just forward
-    catch( execution_exception const& )
-      { throw; }
-
-    // unknown error
-    catch( ... )
-      { detail::report_error( execution_exception::cpp_exception_error, "unknown type" ); }
-
-    return 0;  // never reached; supplied to quiet compiler warnings
-} // execute
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  system_error                ************** //
-// ************************************************************************** //
-
-system_error::system_error( char const* exp )
-#ifdef UNDER_CE
-: p_errno( GetLastError() )
-#else
-: p_errno( errno )
-#endif
-, p_failed_exp( exp )
-{}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************              execution_exception             ************** //
-// ************************************************************************** //
-
-execution_exception::execution_exception( error_code ec_, const_string what_msg_, location const& location_ )
-: m_error_code( ec_ )
-, m_what( what_msg_.empty() ? BOOST_TEST_L( "uncaught exception, system error or abort requested" ) : what_msg_ )
-, m_location( location_ )
-{}
-
-//____________________________________________________________________________//
-
-execution_exception::location::location( char const* file_name, size_t line_num, char const* func )
-: m_file_name( file_name ? file_name : "unknown location" )
-, m_line_num( line_num )
-, m_function( func )
-{}
-
-//____________________________________________________________________________//
-
-} // namespace autoboost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_EXECUTION_MONITOR_IPP_012205GER
-
diff --git a/contrib/autoboost/boost/test/impl/framework.ipp b/contrib/autoboost/boost/test/impl/framework.ipp
deleted file mode 100644
index 7a87efb81..000000000
--- a/contrib/autoboost/boost/test/impl/framework.ipp
+++ /dev/null
@@ -1,503 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : implements framework API - main driver for the test
-// ***************************************************************************
-
-#ifndef BOOST_TEST_FRAMEWORK_IPP_021005GER
-#define BOOST_TEST_FRAMEWORK_IPP_021005GER
-
-// Boost.Test
-#include <boost/test/framework.hpp>
-#include <boost/test/execution_monitor.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/test/unit_test_suite_impl.hpp>
-#include <boost/test/unit_test_log.hpp>
-#include <boost/test/unit_test_monitor.hpp>
-#include <boost/test/test_observer.hpp>
-#include <boost/test/results_collector.hpp>
-#include <boost/test/progress_monitor.hpp>
-#include <boost/test/results_reporter.hpp>
-#include <boost/test/test_tools.hpp>
-
-#include <boost/test/detail/unit_test_parameters.hpp>
-#include <boost/test/detail/global_typedef.hpp>
-
-#include <boost/test/utils/foreach.hpp>
-
-// Boost
-#include <boost/timer.hpp>
-
-// STL
-#include <map>
-#include <set>
-#include <cstdlib>
-#include <ctime>
-
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::time; using ::srand; }
-#endif
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************            test_start calls wrapper          ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-struct test_start_caller {
-    test_start_caller( test_observer* to, counter_t tc_amount )
-    : m_to( to )
-    , m_tc_amount( tc_amount )
-    {}
-
-    int operator()()
-    {
-        m_to->test_start( m_tc_amount );
-        return 0;
-    }
-
-private:
-    // Data members
-    test_observer*  m_to;
-    counter_t       m_tc_amount;
-};
-
-//____________________________________________________________________________//
-
-struct test_init_caller {
-    explicit    test_init_caller( init_unit_test_func init_func ) 
-    : m_init_func( init_func )
-    {}
-    int         operator()()
-    {
-#ifdef BOOST_TEST_ALTERNATIVE_INIT_API
-        if( !(*m_init_func)() )
-            throw std::runtime_error( "test module initialization failed" );
-#else
-        test_suite*  manual_test_units = (*m_init_func)( framework::master_test_suite().argc, framework::master_test_suite().argv );
-
-        if( manual_test_units )
-            framework::master_test_suite().add( manual_test_units );
-#endif
-        return 0;
-    }
-
-    // Data members
-    init_unit_test_func m_init_func;
-};
-
-}
-
-// ************************************************************************** //
-// **************                   framework                  ************** //
-// ************************************************************************** //
-
-class framework_impl : public test_tree_visitor {
-public:
-    framework_impl()
-    : m_master_test_suite( 0 )
-    , m_curr_test_case( INV_TEST_UNIT_ID )
-    , m_next_test_case_id( MIN_TEST_CASE_ID )
-    , m_next_test_suite_id( MIN_TEST_SUITE_ID )
-    , m_is_initialized( false )
-    , m_test_in_progress( false )
-    {}
-
-    ~framework_impl() { clear(); }
-
-    void            clear()
-    {
-        while( !m_test_units.empty() ) {
-            test_unit_store::value_type const& tu     = *m_test_units.begin();
-            test_unit*                         tu_ptr = tu.second;
-
-            // the delete will erase this element from map
-            if( ut_detail::test_id_2_unit_type( tu.second->p_id ) == tut_suite )
-                delete  (test_suite const*)tu_ptr;
-            else
-                delete  (test_case const*)tu_ptr;
-        }
-    }
-
-    void            set_tu_id( test_unit& tu, test_unit_id id ) { tu.p_id.value = id; }
-
-    // test_tree_visitor interface implementation
-    void            visit( test_case const& tc )
-    {
-        if( !tc.check_dependencies() ) {
-            BOOST_TEST_FOREACH( test_observer*, to, m_observers )
-                to->test_unit_skipped( tc );
-
-            return;
-        }
-
-        BOOST_TEST_FOREACH( test_observer*, to, m_observers )
-            to->test_unit_start( tc );
-
-        autoboost::timer tc_timer;
-        test_unit_id bkup = m_curr_test_case;
-        m_curr_test_case = tc.p_id;
-        unit_test_monitor_t::error_level run_result = unit_test_monitor.execute_and_translate( tc );
-
-        unsigned long elapsed = static_cast<unsigned long>( tc_timer.elapsed() * 1e6 );
-
-        if( unit_test_monitor.is_critical_error( run_result ) ) {
-            BOOST_TEST_FOREACH( test_observer*, to, m_observers )
-                to->test_aborted();
-        }
-
-        BOOST_TEST_FOREACH( test_observer*, to, m_observers )
-            to->test_unit_finish( tc, elapsed );
-
-        m_curr_test_case = bkup;
-
-        if( unit_test_monitor.is_critical_error( run_result ) )
-            throw test_being_aborted();
-    }
-
-    bool            test_suite_start( test_suite const& ts )
-    {
-        if( !ts.check_dependencies() ) {
-            BOOST_TEST_FOREACH( test_observer*, to, m_observers )
-                to->test_unit_skipped( ts );
-
-            return false;
-        }
-
-        BOOST_TEST_FOREACH( test_observer*, to, m_observers )
-            to->test_unit_start( ts );
-
-        return true;
-    }
-
-    void            test_suite_finish( test_suite const& ts )
-    {
-        BOOST_TEST_FOREACH( test_observer*, to, m_observers )
-            to->test_unit_finish( ts, 0 );
-    }
-
-    //////////////////////////////////////////////////////////////////
-    struct priority_order {
-        bool operator()( test_observer* lhs, test_observer* rhs ) const
-        {
-            return (lhs->priority() < rhs->priority()) || ((lhs->priority() == rhs->priority()) && (lhs < rhs));
-        }
-    };
-
-    typedef std::map<test_unit_id,test_unit*>       test_unit_store;
-    typedef std::set<test_observer*,priority_order> observer_store;
-
-    master_test_suite_t* m_master_test_suite;
-    test_unit_id    m_curr_test_case;
-    test_unit_store m_test_units;
-
-    test_unit_id    m_next_test_case_id;
-    test_unit_id    m_next_test_suite_id;
-
-    bool            m_is_initialized;
-    bool            m_test_in_progress;
-
-    observer_store  m_observers;
-};
-
-//____________________________________________________________________________//
-
-namespace {
-
-#if defined(__CYGWIN__)
-framework_impl& s_frk_impl() { static framework_impl* the_inst = 0; if(!the_inst) the_inst = new framework_impl; return *the_inst; }
-#else
-framework_impl& s_frk_impl() { static framework_impl the_inst; return the_inst; }
-#endif
-
-} // local namespace
-
-//____________________________________________________________________________//
-
-namespace framework {
-
-void
-init( init_unit_test_func init_func, int argc, char* argv[] )
-{
-    runtime_config::init( argc, argv );
-
-    // set the log level and format
-    unit_test_log.set_threshold_level( runtime_config::log_level() );
-    unit_test_log.set_format( runtime_config::log_format() );
-
-    // set the report level and format
-    results_reporter::set_level( runtime_config::report_level() );
-    results_reporter::set_format( runtime_config::report_format() );
-
-    register_observer( results_collector );
-    register_observer( unit_test_log );
-
-    if( runtime_config::show_progress() )
-        register_observer( progress_monitor );
-
-    if( runtime_config::detect_memory_leaks() > 0 ) {
-        debug::detect_memory_leaks( true );
-        debug::break_memory_alloc( runtime_config::detect_memory_leaks() );
-    }
-
-    // init master unit test suite
-    master_test_suite().argc = argc;
-    master_test_suite().argv = argv;
-
-    try {
-        autoboost::execution_monitor em;
-
-        ut_detail::test_init_caller tic( init_func );
-
-        em.execute( tic );
-    }
-    catch( execution_exception const& ex )  {
-        throw setup_error( ex.what() );
-    }
-
-    s_frk_impl().m_is_initialized = true;
-}
-
-//____________________________________________________________________________//
-
-bool
-is_initialized()
-{
-    return  s_frk_impl().m_is_initialized;
-}
-
-//____________________________________________________________________________//
-
-void
-register_test_unit( test_case* tc )
-{
-    BOOST_TEST_SETUP_ASSERT( tc->p_id == INV_TEST_UNIT_ID, BOOST_TEST_L( "test case already registered" ) );
-
-    test_unit_id new_id = s_frk_impl().m_next_test_case_id;
-
-    BOOST_TEST_SETUP_ASSERT( new_id != MAX_TEST_CASE_ID, BOOST_TEST_L( "too many test cases" ) );
-
-    typedef framework_impl::test_unit_store::value_type map_value_type;
-
-    s_frk_impl().m_test_units.insert( map_value_type( new_id, tc ) );
-    s_frk_impl().m_next_test_case_id++;
-
-    s_frk_impl().set_tu_id( *tc, new_id );
-}
-
-//____________________________________________________________________________//
-
-void
-register_test_unit( test_suite* ts )
-{
-    BOOST_TEST_SETUP_ASSERT( ts->p_id == INV_TEST_UNIT_ID, BOOST_TEST_L( "test suite already registered" ) );
-
-    test_unit_id new_id = s_frk_impl().m_next_test_suite_id;
-
-    BOOST_TEST_SETUP_ASSERT( new_id != MAX_TEST_SUITE_ID, BOOST_TEST_L( "too many test suites" ) );
-
-    typedef framework_impl::test_unit_store::value_type map_value_type;
-    s_frk_impl().m_test_units.insert( map_value_type( new_id, ts ) );
-    s_frk_impl().m_next_test_suite_id++;
-
-    s_frk_impl().set_tu_id( *ts, new_id );
-}
-
-//____________________________________________________________________________//
-
-void
-deregister_test_unit( test_unit* tu )
-{
-    s_frk_impl().m_test_units.erase( tu->p_id );
-}
-
-//____________________________________________________________________________//
-
-void
-clear()
-{
-    s_frk_impl().clear();
-}
-
-//____________________________________________________________________________//
-
-void
-register_observer( test_observer& to )
-{
-    s_frk_impl().m_observers.insert( &to );
-}
-
-//____________________________________________________________________________//
-
-void
-deregister_observer( test_observer& to )
-{
-    s_frk_impl().m_observers.erase( &to );
-}
-
-//____________________________________________________________________________//
-
-void
-reset_observers()
-{
-    s_frk_impl().m_observers.clear();
-}
-
-//____________________________________________________________________________//
-
-master_test_suite_t&
-master_test_suite()
-{
-    if( !s_frk_impl().m_master_test_suite )
-        s_frk_impl().m_master_test_suite = new master_test_suite_t;
-
-    return *s_frk_impl().m_master_test_suite;
-}
-
-//____________________________________________________________________________//
-
-test_case const&
-current_test_case()
-{
-    return get<test_case>( s_frk_impl().m_curr_test_case );
-}
-
-//____________________________________________________________________________//
-
-test_unit&
-get( test_unit_id id, test_unit_type t )
-{
-    test_unit* res = s_frk_impl().m_test_units[id];
-
-    if( (res->p_type & t) == 0 )
-        throw internal_error( "Invalid test unit type" );
-
-    return *res;
-}
-
-//____________________________________________________________________________//
-
-void
-run( test_unit_id id, bool continue_test )
-{
-    if( id == INV_TEST_UNIT_ID )
-        id = master_test_suite().p_id;
-
-    test_case_counter tcc;
-    traverse_test_tree( id, tcc );
-
-    BOOST_TEST_SETUP_ASSERT( tcc.p_count != 0 , runtime_config::test_to_run().is_empty() 
-        ? BOOST_TEST_L( "test tree is empty" ) 
-        : BOOST_TEST_L( "no test cases matching filter" ) );
-
-    bool    call_start_finish   = !continue_test || !s_frk_impl().m_test_in_progress;
-    bool    was_in_progress     = s_frk_impl().m_test_in_progress;
-
-    s_frk_impl().m_test_in_progress = true;
-
-    if( call_start_finish ) {
-        BOOST_TEST_FOREACH( test_observer*, to, s_frk_impl().m_observers ) {
-            autoboost::execution_monitor em;
-
-            try {
-                em.execute( ut_detail::test_start_caller( to, tcc.p_count ) );
-            }
-            catch( execution_exception const& ex )  {
-                throw setup_error( ex.what() );
-            }
-        }
-    }
-
-    switch( runtime_config::random_seed() ) {
-    case 0:
-        break;
-    case 1: {
-        unsigned int seed = static_cast<unsigned int>( std::time( 0 ) );
-        BOOST_TEST_MESSAGE( "Test cases order is shuffled using seed: " << seed );
-        std::srand( seed );
-        break;
-    }
-    default:
-        BOOST_TEST_MESSAGE( "Test cases order is shuffled using seed: " << runtime_config::random_seed() );
-        std::srand( runtime_config::random_seed() );
-    }
-
-    try {
-        traverse_test_tree( id, s_frk_impl() );
-    }
-    catch( test_being_aborted const& ) {
-        // abort already reported
-    }
-
-    if( call_start_finish ) {
-        BOOST_TEST_FOREACH( test_observer*, to, s_frk_impl().m_observers )
-            to->test_finish();
-    }
-
-    s_frk_impl().m_test_in_progress = was_in_progress;
-}
-
-//____________________________________________________________________________//
-
-void
-run( test_unit const* tu, bool continue_test )
-{
-    run( tu->p_id, continue_test );
-}
-
-//____________________________________________________________________________//
-
-void
-assertion_result( bool passed )
-{
-    BOOST_TEST_FOREACH( test_observer*, to, s_frk_impl().m_observers )
-        to->assertion_result( passed );
-}
-
-//____________________________________________________________________________//
-
-void
-exception_caught( execution_exception const& ex )
-{
-    BOOST_TEST_FOREACH( test_observer*, to, s_frk_impl().m_observers )
-        to->exception_caught( ex );
-}
-
-//____________________________________________________________________________//
-
-void
-test_unit_aborted( test_unit const& tu )
-{
-    BOOST_TEST_FOREACH( test_observer*, to, s_frk_impl().m_observers )
-        to->test_unit_aborted( tu );
-}
-
-//____________________________________________________________________________//
-
-} // namespace framework
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_FRAMEWORK_IPP_021005GER
diff --git a/contrib/autoboost/boost/test/impl/interaction_based.ipp b/contrib/autoboost/boost/test/impl/interaction_based.ipp
deleted file mode 100644
index 7d627849d..000000000
--- a/contrib/autoboost/boost/test/impl/interaction_based.ipp
+++ /dev/null
@@ -1,90 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : Facilities to perform interaction-based testing
-// ***************************************************************************
-
-#ifndef BOOST_TEST_INTERACTION_BASED_IPP_112105GER
-#define BOOST_TEST_INTERACTION_BASED_IPP_112105GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-
-#if BOOST_TEST_SUPPORT_INTERACTION_TESTING
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/utils/callback.hpp>
-#include <boost/test/interaction_based.hpp>
-#include <boost/test/mock_object.hpp>
-#include <boost/test/framework.hpp>     // for setup_error
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-// STL
-#include <stdexcept>
-#include <string>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace itest { // interaction-based testing
-
-// ************************************************************************** //
-// **************                    manager                   ************** //
-// ************************************************************************** //
-
-manager::manager()
-{
-    instance_ptr( true, this );
-}
-
-//____________________________________________________________________________//
-
-manager::~manager()
-{
-    instance_ptr( true );
-}
-
-//____________________________________________________________________________//
-    
-manager*
-manager::instance_ptr( bool reset, manager* new_ptr )
-{
-    static manager dummy( 0 );
-    
-    static manager* ptr = &dummy;
-    
-    if( reset ) {
-        if( new_ptr ) {
-            BOOST_TEST_SETUP_ASSERT( ptr == &dummy, BOOST_TEST_L( "Can't run two interation based test the same time" ) );
-                
-            ptr = new_ptr;
-        }
-        else
-            ptr = &dummy;
-    }
-    
-    return ptr;
-}
-    
-}  // namespace itest
-
-}  // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // not ancient compiler
-
-#endif // BOOST_TEST_INTERACTION_BASED_IPP_112105GER
diff --git a/contrib/autoboost/boost/test/impl/logged_expectations.ipp b/contrib/autoboost/boost/test/impl/logged_expectations.ipp
deleted file mode 100644
index a92809d2f..000000000
--- a/contrib/autoboost/boost/test/impl/logged_expectations.ipp
+++ /dev/null
@@ -1,246 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to the
-//  Boost Software License, ELOG_VER 1.0. (See accompanying file
-//  http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : Facilities to perform interaction based testng of logged expectations
-// ***************************************************************************
-
-#ifndef BOOST_TEST_LOGGED_EXPECTATIONS_IPP_120905GER
-#define BOOST_TEST_LOGGED_EXPECTATIONS_IPP_120905GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-
-#if BOOST_TEST_SUPPORT_INTERACTION_TESTING
-
-#include <boost/test/detail/global_typedef.hpp>
-
-#include <boost/test/utils/callback.hpp>
-#include <boost/test/utils/iterator/token_iterator.hpp>
-
-#include <boost/test/interaction_based.hpp>
-#include <boost/test/test_tools.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-// Boost
-#include <boost/lexical_cast.hpp>
-
-// STL
-#include <fstream>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-using namespace ::autoboost::unit_test;
-
-namespace itest {
-
-// ************************************************************************** //
-// **************    logged expectation test implementation    ************** //
-// ************************************************************************** //
-
-struct expectations_logger : itest::manager {
-    // Constructor
-    expectations_logger( const_string log_file_name, bool test_or_log );
-
-    virtual bool        decision_point( const_string, std::size_t );
-    virtual unsigned    enter_scope( const_string, std::size_t, const_string scope_name );
-    virtual void        allocated( const_string, std::size_t, void*, std::size_t s );
-    virtual void        data_flow( const_string d );
-    virtual std::string return_value( const_string default_value );
-    
-private:
-    // Data members
-    bool            m_test_or_log;
-    std::fstream    m_log_file;
-};
-
-literal_string ELOG_VER     = "1.0";
-literal_string CLMN_SEP     = "|";
-static const char LINE_SEP  = '\n';
-
-literal_string FILE_SIG     = "ELOG";
-literal_string SCOPE_SIG    = "SCOPE";
-literal_string ALLOC_SIG    = "ALLOC";
-literal_string DP_SIG       = "SWITCH";
-literal_string DATA_SIG     = "DATA";
-literal_string RETURN_SIG   = "RETURN";
-
-//____________________________________________________________________________//
-
-expectations_logger::expectations_logger( const_string log_file_name, bool test_or_log )
-: m_test_or_log( test_or_log )
-{
-    BOOST_REQUIRE_MESSAGE( !log_file_name.is_empty(), "Empty expectations log file name" );
-
-    m_log_file.open( log_file_name.begin(), test_or_log ? std::ios::in : std::ios::out );
-
-    BOOST_REQUIRE_MESSAGE( m_log_file.is_open(),
-                           "Can't open expectations log file " << log_file_name
-                                << " for " << ( m_test_or_log ? "reading" : "writing") );
-
-    if( m_test_or_log ) {
-        std::string line;
-        
-        std::getline( m_log_file, line, LINE_SEP );
-        
-        const_string cline( line );
-        string_token_iterator tit( cline, (dropped_delimeters = CLMN_SEP, kept_delimeters = dt_none));
-
-        BOOST_CHECK_EQUAL( *tit, FILE_SIG ); 
-        ++tit;
-        BOOST_CHECK_EQUAL( *tit, ELOG_VER );
-    }
-    else {
-        m_log_file << FILE_SIG << CLMN_SEP << ELOG_VER << LINE_SEP;
-    }
-}
-
-//____________________________________________________________________________//
-
-bool
-expectations_logger::decision_point( const_string, std::size_t )
-{
-    if( m_test_or_log ) {
-        std::string line;
-        
-        std::getline( m_log_file, line, LINE_SEP );
-        
-        const_string cline( line );
-        string_token_iterator tit( cline, (dropped_delimeters = CLMN_SEP, kept_delimeters = dt_none));
-        
-        BOOST_CHECK_EQUAL( *tit, DP_SIG ); ++tit;
-        return lexical_cast<bool>( *tit );
-    }
-    else {
-        m_log_file << DP_SIG << CLMN_SEP << std::boolalpha << true << LINE_SEP;
-        
-        return true;
-    }
-}
-
-//____________________________________________________________________________//
-    
-unsigned
-expectations_logger::enter_scope( const_string, std::size_t, const_string scope_name )
-{
-    if( m_test_or_log ) {
-        std::string line;
-        
-        std::getline( m_log_file, line, LINE_SEP );
-        
-        const_string cline( line );
-        string_token_iterator tit( cline, (dropped_delimeters = CLMN_SEP, kept_delimeters = dt_none));
-        
-        BOOST_CHECK_EQUAL( *tit, SCOPE_SIG ); ++tit;
-        BOOST_CHECK_EQUAL( *tit, scope_name );
-    }
-    else {
-        m_log_file << SCOPE_SIG << CLMN_SEP << scope_name << LINE_SEP;
-    }
-    
-    return 0;
-}
-    
-//____________________________________________________________________________//
-
-void
-expectations_logger::allocated( const_string, std::size_t, void*, std::size_t s )
-{
-    if( m_test_or_log ) {
-        std::string line;
-        
-        std::getline( m_log_file, line, LINE_SEP );
-        
-        const_string cline( line );
-        string_token_iterator tit( cline, (dropped_delimeters = CLMN_SEP, kept_delimeters = dt_none));
-        
-        BOOST_CHECK_EQUAL( *tit, ALLOC_SIG ); ++tit;
-        BOOST_CHECK_EQUAL( lexical_cast<std::size_t>( *tit ), s );
-    }
-    else {
-        m_log_file << ALLOC_SIG << CLMN_SEP << s << LINE_SEP;
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-expectations_logger::data_flow( const_string d )
-{
-    if( m_test_or_log ) {
-        std::string line;
-        
-        std::getline( m_log_file, line, LINE_SEP );
-        
-        const_string cline( line );
-        string_token_iterator tit( cline, (dropped_delimeters = CLMN_SEP, kept_delimeters = dt_none));
-        
-        BOOST_CHECK_EQUAL( *tit, DATA_SIG ); ++tit;
-        BOOST_CHECK_EQUAL( *tit, d );
-    }
-    else {
-        m_log_file << DATA_SIG << CLMN_SEP << d << LINE_SEP;
-    }
-}
-
-//____________________________________________________________________________//
-
-std::string
-expectations_logger::return_value( const_string default_value )
-{
-    if( m_test_or_log ) {
-        std::string line;
-        
-        std::getline( m_log_file, line, LINE_SEP );
-        
-        const_string cline( line );
-        string_token_iterator tit( cline, (dropped_delimeters = CLMN_SEP, kept_delimeters = dt_none));
-        
-        BOOST_CHECK_EQUAL( *tit, RETURN_SIG ); ++tit;
-        
-        return std::string( tit->begin(), tit->size() );
-    }
-    else {
-        m_log_file << RETURN_SIG << CLMN_SEP << default_value << LINE_SEP;
-                                 
-        return std::string();
-    }
-}
-
-//____________________________________________________________________________//
-    
-// ************************************************************************** //
-// **************           logged expectations test           ************** //
-// ************************************************************************** //
-
-void BOOST_TEST_DECL
-logged_expectations( callback0<> const& F, const_string log_file_name, bool test_or_log )
-{
-    expectations_logger el( log_file_name, test_or_log );
-
-    F();
-}
-
-//____________________________________________________________________________//
-
-}  // namespace itest
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // not ancient compiler
-
-#endif // BOOST_TEST_LOGGED_EXPECTATIONS_IPP_120905GER
diff --git a/contrib/autoboost/boost/test/impl/plain_report_formatter.ipp b/contrib/autoboost/boost/test/impl/plain_report_formatter.ipp
deleted file mode 100644
index f9969ccc0..000000000
--- a/contrib/autoboost/boost/test/impl/plain_report_formatter.ipp
+++ /dev/null
@@ -1,198 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : plain report formatter definition
-// ***************************************************************************
-
-#ifndef BOOST_TEST_PLAIN_REPORT_FORMATTER_IPP_020105GER
-#define BOOST_TEST_PLAIN_REPORT_FORMATTER_IPP_020105GER
-
-// Boost.Test
-#include <boost/test/output/plain_report_formatter.hpp>
-#include <boost/test/utils/custom_manip.hpp>
-#include <boost/test/results_collector.hpp>
-#include <boost/test/unit_test_suite_impl.hpp>
-
-#include <boost/test/utils/basic_cstring/io.hpp>
-
-// STL
-#include <iomanip>
-#include <boost/config/no_tr1/cmath.hpp>
-#include <iostream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-# ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::log10; }
-# endif
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-namespace output {
-
-namespace {
-
-typedef custom_manip<struct quote_t> quote;
-
-template<typename T>
-inline std::ostream&
-operator<<( custom_printer<quote> const& p, T const& value )
-{
-    *p << '"' << value << '"';
-
-    return *p;
-}
-
-//____________________________________________________________________________//
-
-void
-print_stat_value( std::ostream& ostr, counter_t v, counter_t indent, counter_t total,
-                  const_string name, const_string res )
-{
-    if( v > 0 ) {
-        ostr << std::setw( indent ) << ""
-             << v << ' ' << name << ( v != 1 ? "s" : "" );
-        if( total > 0 )
-            ostr << " out of " << total;
-
-        ostr << ' ' << res << '\n';
-    }
-}
-
-//____________________________________________________________________________//
-
-} // local namespace
-
-// ************************************************************************** //
-// **************             plain_report_formatter           ************** //
-// ************************************************************************** //
-
-void
-plain_report_formatter::results_report_start( std::ostream& ostr )
-{
-    m_indent = 0;
-    ostr << '\n';
-}
-
-//____________________________________________________________________________//
-
-void
-plain_report_formatter::results_report_finish( std::ostream& ostr )
-{
-    ostr.flush();
-}
-
-//____________________________________________________________________________//
-
-void
-plain_report_formatter::test_unit_report_start( test_unit const& tu, std::ostream& ostr )
-{
-    test_results const& tr = results_collector.results( tu.p_id );
-
-    const_string descr;
-
-    if( tr.passed() )
-        descr = "passed";
-    else if( tr.p_skipped )
-        descr = "skipped";
-    else if( tr.p_aborted )
-        descr = "aborted";
-    else
-        descr = "failed";
-
-    ostr << std::setw( m_indent ) << ""
-         << "Test " << (tu.p_type == tut_case ? "case " : "suite " ) << quote() << tu.p_name << ' ' << descr;
-
-    if( tr.p_skipped ) {
-        ostr << " due to " << (tu.check_dependencies() ? "test aborting\n" : "failed dependancy\n" );
-        m_indent += 2;
-        return;
-    }
-    
-    counter_t total_assertions  = tr.p_assertions_passed + tr.p_assertions_failed;
-    counter_t total_tc          = tr.p_test_cases_passed + tr.p_test_cases_failed + tr.p_test_cases_skipped;
-
-    if( total_assertions > 0 || total_tc > 0 )
-        ostr << " with:";
-
-    ostr << '\n';
-    m_indent += 2;
-
-    print_stat_value( ostr, tr.p_assertions_passed, m_indent, total_assertions, "assertion", "passed" );
-    print_stat_value( ostr, tr.p_assertions_failed, m_indent, total_assertions, "assertion", "failed" );
-    print_stat_value( ostr, tr.p_expected_failures, m_indent, 0               , "failure"  , "expected" );
-    print_stat_value( ostr, tr.p_test_cases_passed, m_indent, total_tc        , "test case", "passed" );
-    print_stat_value( ostr, tr.p_test_cases_failed, m_indent, total_tc        , "test case", "failed" );
-    print_stat_value( ostr, tr.p_test_cases_skipped, m_indent, total_tc       , "test case", "skipped" );
-    print_stat_value( ostr, tr.p_test_cases_aborted, m_indent, total_tc       , "test case", "aborted" );
-    
-    ostr << '\n';
-}
-
-//____________________________________________________________________________//
-
-void
-plain_report_formatter::test_unit_report_finish( test_unit const&, std::ostream& )
-{
-    m_indent -= 2;
-}
-
-//____________________________________________________________________________//
-
-void
-plain_report_formatter::do_confirmation_report( test_unit const& tu, std::ostream& ostr )
-{
-    test_results const& tr = results_collector.results( tu.p_id );
-    
-    if( tr.passed() ) {
-        ostr << "*** No errors detected\n";
-        return;
-    }
-        
-    if( tr.p_skipped ) {
-        ostr << "*** Test " << tu.p_type_name << " skipped due to " 
-             << (tu.check_dependencies() ? "test aborting\n" : "failed dependancy\n" );
-        return;
-    }
-
-    if( tr.p_assertions_failed == 0 ) {
-        ostr << "*** errors detected in test " << tu.p_type_name << " " << quote() << tu.p_name
-             << "; see standard output for details\n";
-        return;
-    }
-
-    counter_t num_failures = tr.p_assertions_failed;
-    
-    ostr << "*** " << num_failures << " failure" << ( num_failures != 1 ? "s" : "" ) << " detected";
-    
-    if( tr.p_expected_failures > 0 )
-        ostr << " (" << tr.p_expected_failures << " failure" << ( tr.p_expected_failures != 1 ? "s" : "" ) << " expected)";
-    
-    ostr << " in test " << tu.p_type_name << " " << quote() << tu.p_name << "\n";
-}
-
-//____________________________________________________________________________//
-
-} // namespace output
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_PLAIN_REPORT_FORMATTER_IPP_020105GER
diff --git a/contrib/autoboost/boost/test/impl/progress_monitor.ipp b/contrib/autoboost/boost/test/impl/progress_monitor.ipp
deleted file mode 100644
index 630b49e87..000000000
--- a/contrib/autoboost/boost/test/impl/progress_monitor.ipp
+++ /dev/null
@@ -1,110 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : implements simple text based progress monitor
-// ***************************************************************************
-
-#ifndef BOOST_TEST_PROGRESS_MONITOR_IPP_020105GER
-#define BOOST_TEST_PROGRESS_MONITOR_IPP_020105GER
-
-// Boost.Test
-#include <boost/test/progress_monitor.hpp>
-#include <boost/test/unit_test_suite_impl.hpp>
-
-#include <boost/test/detail/unit_test_parameters.hpp>
-
-// Boost
-#include <boost/progress.hpp>
-#include <boost/scoped_ptr.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                progress_monitor              ************** //
-// ************************************************************************** //
-
-namespace {
-
-struct progress_monitor_impl {
-    // Constructor
-    progress_monitor_impl()
-        : m_stream( runtime_config::log_sink() )
-    {}
-
-    std::ostream*                m_stream;
-    scoped_ptr<progress_display> m_progress_display;
-};
-
-progress_monitor_impl& s_pm_impl() { static progress_monitor_impl the_inst; return the_inst; }
-
-} // local namespace
-
-//____________________________________________________________________________//
-
-void
-progress_monitor_t::test_start( counter_t test_cases_amount )
-{
-    s_pm_impl().m_progress_display.reset( new progress_display( test_cases_amount, *s_pm_impl().m_stream ) );
-}
-
-//____________________________________________________________________________//
-
-void
-progress_monitor_t::test_aborted()
-{
-    (*s_pm_impl().m_progress_display) += s_pm_impl().m_progress_display->count();
-}
-
-//____________________________________________________________________________//
-
-void
-progress_monitor_t::test_unit_finish( test_unit const& tu, unsigned long )
-{
-    if( tu.p_type == tut_case )
-        ++(*s_pm_impl().m_progress_display);
-}
-
-//____________________________________________________________________________//
-
-void
-progress_monitor_t::test_unit_skipped( test_unit const& tu )
-{
-    test_case_counter tcc;
-    traverse_test_tree( tu, tcc );
-    
-    (*s_pm_impl().m_progress_display) += tcc.p_count;
-}
-
-//____________________________________________________________________________//
-
-void
-progress_monitor_t::set_stream( std::ostream& ostr )
-{
-    s_pm_impl().m_stream = &ostr;
-}
-
-//____________________________________________________________________________//
-    
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_PROGRESS_MONITOR_IPP_020105GER
diff --git a/contrib/autoboost/boost/test/impl/results_collector.ipp b/contrib/autoboost/boost/test/impl/results_collector.ipp
deleted file mode 100644
index 2d5699ccf..000000000
--- a/contrib/autoboost/boost/test/impl/results_collector.ipp
+++ /dev/null
@@ -1,294 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : implements Unit Test results collecting facility.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_RESULTS_COLLECTOR_IPP_021105GER
-#define BOOST_TEST_RESULTS_COLLECTOR_IPP_021105GER
-
-// Boost.Test
-#include <boost/test/unit_test_suite_impl.hpp>
-#include <boost/test/unit_test_log.hpp>
-#include <boost/test/results_collector.hpp>
-#include <boost/test/framework.hpp>
-
-// Boost
-#include <boost/cstdlib.hpp>
-
-// STL
-#include <map>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                 test_results                 ************** //
-// ************************************************************************** //
-
-test_results::test_results()
-{
-    clear();
-}
-
-//____________________________________________________________________________//
-
-bool
-test_results::passed() const
-{
-    return  !p_skipped                                  &&
-            p_test_cases_failed == 0                    &&
-            p_assertions_failed <= p_expected_failures  &&
-            !p_aborted;
-}
-
-//____________________________________________________________________________//
-
-int
-test_results::result_code() const
-{
-    return passed() ? exit_success
-           : ( (p_assertions_failed > p_expected_failures || p_skipped )
-                    ? exit_test_failure
-                    : exit_exception_failure );
-}
-
-//____________________________________________________________________________//
-
-void
-test_results::operator+=( test_results const& tr )
-{
-    p_assertions_passed.value   += tr.p_assertions_passed;
-    p_assertions_failed.value   += tr.p_assertions_failed;
-    p_test_cases_passed.value   += tr.p_test_cases_passed;
-    p_test_cases_failed.value   += tr.p_test_cases_failed;
-    p_test_cases_skipped.value  += tr.p_test_cases_skipped;
-    p_test_cases_aborted.value  += tr.p_test_cases_aborted;
-}
-
-//____________________________________________________________________________//
-
-void
-test_results::clear()
-{
-    p_assertions_passed.value    = 0;
-    p_assertions_failed.value    = 0;
-    p_expected_failures.value    = 0;
-    p_test_cases_passed.value    = 0;
-    p_test_cases_failed.value    = 0;
-    p_test_cases_skipped.value   = 0;
-    p_test_cases_aborted.value   = 0;
-    p_aborted.value              = false;
-    p_skipped.value              = true;
-}
-
-//____________________________________________________________________________//
-    
-// ************************************************************************** //
-// **************               results_collector              ************** //
-// ************************************************************************** //
-
-#if !BOOST_WORKAROUND(BOOST_MSVC, <1300)
-
-namespace {
-
-struct results_collector_impl {
-    std::map<test_unit_id,test_results> m_results_store;
-};
-
-results_collector_impl& s_rc_impl() { static results_collector_impl the_inst; return the_inst; }
-
-} // local namespace
-
-#else
-
-struct results_collector_impl {
-    std::map<test_unit_id,test_results> m_results_store;
-};
-
-static results_collector_impl& s_rc_impl() { static results_collector_impl the_inst; return the_inst; }
-
-#endif
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::test_start( counter_t )
-{
-    s_rc_impl().m_results_store.clear();
-}
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::test_finish()
-{
-    // do nothing
-}
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::test_aborted()
-{
-    // do nothing
-}
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::test_unit_start( test_unit const& tu )
-{
-    // init test_results entry
-    test_results& tr = s_rc_impl().m_results_store[tu.p_id];
-
-    tr.clear();
-    
-    tr.p_expected_failures.value    = tu.p_expected_failures;
-    tr.p_skipped.value              = false;
-}
-
-//____________________________________________________________________________//
-
-class results_collect_helper : public test_tree_visitor {
-public:
-    explicit results_collect_helper( test_results& tr, test_unit const& ts ) : m_tr( tr ), m_ts( ts ) {}
-
-    void    visit( test_case const& tc )
-    {
-        test_results const& tr = results_collector.results( tc.p_id );
-        m_tr += tr;
-
-        if( tr.passed() )
-            m_tr.p_test_cases_passed.value++;
-        else if( tr.p_skipped )
-            m_tr.p_test_cases_skipped.value++;
-        else {
-            if( tr.p_aborted )
-                m_tr.p_test_cases_aborted.value++;
-            m_tr.p_test_cases_failed.value++;
-        }
-    }
-    bool    test_suite_start( test_suite const& ts )
-    {
-        if( m_ts.p_id == ts.p_id )
-            return true;
-        else {
-            m_tr += results_collector.results( ts.p_id );
-            return false;
-        }
-    }
-
-private:
-    // Data members
-    test_results&       m_tr;
-    test_unit const&    m_ts;
-};
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::test_unit_finish( test_unit const& tu, unsigned long )
-{
-    if( tu.p_type == tut_suite ) {
-        results_collect_helper ch( s_rc_impl().m_results_store[tu.p_id], tu );
-
-        traverse_test_tree( tu, ch );
-    }
-    else {
-        test_results const& tr = s_rc_impl().m_results_store[tu.p_id];
-        
-        bool num_failures_match = tr.p_aborted || tr.p_assertions_failed >= tr.p_expected_failures;
-        if( !num_failures_match )
-            BOOST_TEST_MESSAGE( "Test case " << tu.p_name << " has fewer failures than expected" );
-
-        bool check_any_assertions = tr.p_aborted || (tr.p_assertions_failed != 0) || (tr.p_assertions_passed != 0);
-        if( !check_any_assertions )
-            BOOST_TEST_MESSAGE( "Test case " << tu.p_name << " did not check any assertions" );
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::test_unit_skipped( test_unit const& tu )
-{
-    if( tu.p_type == tut_suite ) {
-        test_case_counter tcc;
-        traverse_test_tree( tu, tcc );
-
-        test_results& tr = s_rc_impl().m_results_store[tu.p_id];
-
-        tr.clear();
-    
-        tr.p_skipped.value              = true;
-        tr.p_test_cases_skipped.value   = tcc.p_count;
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::assertion_result( bool passed )
-{
-    test_results& tr = s_rc_impl().m_results_store[framework::current_test_case().p_id];
-
-    if( passed )
-        tr.p_assertions_passed.value++;
-    else
-        tr.p_assertions_failed.value++;
-
-    if( tr.p_assertions_failed == 1 )
-        first_failed_assertion();
-}
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::exception_caught( execution_exception const& )
-{
-    test_results& tr = s_rc_impl().m_results_store[framework::current_test_case().p_id];
-
-    tr.p_assertions_failed.value++;
-}
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::test_unit_aborted( test_unit const& tu )
-{
-    s_rc_impl().m_results_store[tu.p_id].p_aborted.value = true;
-}
-
-//____________________________________________________________________________//
-
-test_results const&
-results_collector_t::results( test_unit_id id ) const
-{
-    return s_rc_impl().m_results_store[id];
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_RESULTS_COLLECTOR_IPP_021105GER
diff --git a/contrib/autoboost/boost/test/impl/results_reporter.ipp b/contrib/autoboost/boost/test/impl/results_reporter.ipp
deleted file mode 100644
index cb309e3db..000000000
--- a/contrib/autoboost/boost/test/impl/results_reporter.ipp
+++ /dev/null
@@ -1,202 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : result reporting facilties
-// ***************************************************************************
-
-#ifndef BOOST_TEST_RESULTS_REPORTER_IPP_020105GER
-#define BOOST_TEST_RESULTS_REPORTER_IPP_020105GER
-
-// Boost.Test
-#include <boost/test/results_reporter.hpp>
-#include <boost/test/unit_test_suite_impl.hpp>
-#include <boost/test/results_collector.hpp>
-#include <boost/test/framework.hpp>
-#include <boost/test/output/plain_report_formatter.hpp>
-#include <boost/test/output/xml_report_formatter.hpp>
-
-#include <boost/test/detail/unit_test_parameters.hpp>
-
-// Boost
-#include <boost/scoped_ptr.hpp>
-#include <boost/io/ios_state.hpp>
-typedef ::autoboost::io::ios_base_all_saver io_saver_type;
-
-// STL
-#include <iostream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-namespace results_reporter {
-
-// ************************************************************************** //
-// **************        result reporter implementation        ************** //
-// ************************************************************************** //
-
-namespace {
-
-struct results_reporter_impl : test_tree_visitor {
-    // Constructor
-    results_reporter_impl()
-    : m_output( runtime_config::report_sink() )
-    , m_stream_state_saver( new io_saver_type( *m_output ) )
-    , m_report_level( CONFIRMATION_REPORT )
-    , m_formatter( new output::plain_report_formatter )
-    {}
-
-    // test tree visitor interface implementation
-    void    visit( test_case const& tc )
-    {
-        m_formatter->test_unit_report_start( tc, *m_output );
-        m_formatter->test_unit_report_finish( tc, *m_output );
-    }
-    bool    test_suite_start( test_suite const& ts )
-    {
-        m_formatter->test_unit_report_start( ts, *m_output );
-
-        if( m_report_level == DETAILED_REPORT && !results_collector.results( ts.p_id ).p_skipped )
-            return true;
-
-        m_formatter->test_unit_report_finish( ts, *m_output );
-        return false;
-    }
-    void    test_suite_finish( test_suite const& ts )
-    {
-        m_formatter->test_unit_report_finish( ts, *m_output );
-    }
-
-    typedef scoped_ptr<io_saver_type> saver_ptr;
-
-    // Data members
-    std::ostream*       m_output;
-    saver_ptr           m_stream_state_saver;
-    report_level        m_report_level;
-    scoped_ptr<format>  m_formatter;
-};
-
-results_reporter_impl& s_rr_impl() { static results_reporter_impl the_inst; return the_inst; }
-
-} // local namespace
-
-// ************************************************************************** //
-// **************              report configuration            ************** //
-// ************************************************************************** //
-
-void
-set_level( report_level l )
-{
-    if( l != INV_REPORT_LEVEL )
-        s_rr_impl().m_report_level = l;
-}
-
-//____________________________________________________________________________//
-
-void
-set_stream( std::ostream& ostr )
-{
-    s_rr_impl().m_output = &ostr;
-    s_rr_impl().m_stream_state_saver.reset( new io_saver_type( ostr ) );
-}
-
-//____________________________________________________________________________//
-
-std::ostream&
-get_stream()
-{
-    return *s_rr_impl().m_output;
-}
-
-//____________________________________________________________________________//
-
-void
-set_format( output_format rf )
-{
-    switch( rf ) {
-    case CLF:
-        set_format( new output::plain_report_formatter );
-        break;
-    case XML:
-        set_format( new output::xml_report_formatter );
-        break;
-    default:
-        break;
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-set_format( results_reporter::format* f )
-{
-    if( f )
-        s_rr_impl().m_formatter.reset( f );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               report initiation              ************** //
-// ************************************************************************** //
-
-void
-make_report( report_level l, test_unit_id id )
-{
-    if( l == INV_REPORT_LEVEL )
-        l = s_rr_impl().m_report_level;
-
-    if( l == NO_REPORT )
-        return;
-
-    if( id == INV_TEST_UNIT_ID )
-        id = framework::master_test_suite().p_id;
-
-    s_rr_impl().m_stream_state_saver->restore();
-
-    report_level bkup = s_rr_impl().m_report_level;
-    s_rr_impl().m_report_level = l;
-
-    s_rr_impl().m_formatter->results_report_start( *s_rr_impl().m_output );
-
-    switch( l ) {
-    case CONFIRMATION_REPORT:
-        s_rr_impl().m_formatter->do_confirmation_report( framework::get<test_unit>( id ), *s_rr_impl().m_output );
-        break;
-    case SHORT_REPORT:
-    case DETAILED_REPORT:
-        traverse_test_tree( id, s_rr_impl() );
-        break;
-    default:
-        break;
-    }
-
-    s_rr_impl().m_formatter->results_report_finish( *s_rr_impl().m_output );
-    s_rr_impl().m_report_level = bkup;
-}
-
-//____________________________________________________________________________//
-
-} // namespace results_reporter
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_RESULTS_REPORTER_IPP_020105GER
diff --git a/contrib/autoboost/boost/test/impl/test_main.ipp b/contrib/autoboost/boost/test/impl/test_main.ipp
deleted file mode 100644
index 40ded515e..000000000
--- a/contrib/autoboost/boost/test/impl/test_main.ipp
+++ /dev/null
@@ -1,68 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  (C) Copyright Beman Dawes 1995-2001.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $$Revision$
-//
-//  Description : implements main function for Test Execution Monitor.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TEST_MAIN_IPP_012205GER
-#define BOOST_TEST_TEST_MAIN_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/framework.hpp>
-#include <boost/test/test_tools.hpp>
-#include <boost/test/unit_test_suite.hpp>
-
-// Boost
-#include <boost/cstdlib.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-extern int test_main( int argc, char* argv[] );    // prototype for user's test_main()
-
-struct test_main_caller {
-    test_main_caller( int argc, char** argv ) : m_argc( argc ), m_argv( argv ) {}
-    
-    void operator()() {
-        int test_main_result = test_main( m_argc, m_argv );
-
-        // translate a test_main non-success return into a test error
-        BOOST_CHECK( test_main_result == 0 || test_main_result == autoboost::exit_success );
-    }
-  
-private:
-    // Data members    
-    int      m_argc;
-    char**   m_argv;
-};
-
-// ************************************************************************** //
-// **************                   test main                  ************** //
-// ************************************************************************** //
-
-::autoboost::unit_test::test_suite*
-init_unit_test_suite( int argc, char* argv[] ) {
-    using namespace ::autoboost::unit_test;
-    
-    framework::master_test_suite().p_name.value = "Test Program";
-    
-    framework::master_test_suite().add( BOOST_TEST_CASE( test_main_caller( argc, argv ) ) );
-    
-    return 0;
-}
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TEST_MAIN_IPP_012205GER
diff --git a/contrib/autoboost/boost/test/impl/test_tools.ipp b/contrib/autoboost/boost/test/impl/test_tools.ipp
deleted file mode 100644
index b68e7b708..000000000
--- a/contrib/autoboost/boost/test/impl/test_tools.ipp
+++ /dev/null
@@ -1,628 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : supplies offline implementation for the Test Tools
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TEST_TOOLS_IPP_012205GER
-#define BOOST_TEST_TEST_TOOLS_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/test_tools.hpp>
-#include <boost/test/unit_test_log.hpp>
-#include <boost/test/output_test_stream.hpp>
-#include <boost/test/framework.hpp>
-#include <boost/test/execution_monitor.hpp> // execution_aborted
-#include <boost/test/unit_test_suite_impl.hpp>
-
-// Boost
-#include <boost/config.hpp>
-
-// STL
-#include <fstream>
-#include <string>
-#include <cstring>
-#include <cctype>
-#include <cwchar>
-#include <stdexcept>
-#include <ios>
-
-// !! should we use #include <cstdarg>
-#include <stdarg.h>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-# ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::strcmp; using ::strlen; using ::isprint; }
-#if !defined( BOOST_NO_CWCHAR )
-namespace std { using ::wcscmp; }
-#endif
-# endif
-
-namespace autoboost {
-
-namespace test_tools {
-
-// ************************************************************************** //
-// **************                print_log_value               ************** //
-// ************************************************************************** //
-
-void
-print_log_value<char>::operator()( std::ostream& ostr, char t )
-{
-    if( (std::isprint)( static_cast<unsigned char>(t) ) )
-        ostr << '\'' << t << '\'';
-    else
-        ostr << std::hex
-#if BOOST_TEST_USE_STD_LOCALE
-        << std::showbase
-#else
-        << "0x"
-#endif
-        << static_cast<int>(t);
-}
-
-//____________________________________________________________________________//
-
-void
-print_log_value<unsigned char>::operator()( std::ostream& ostr, unsigned char t )
-{
-    ostr << std::hex
-        // showbase is only available for new style streams:
-#if BOOST_TEST_USE_STD_LOCALE
-        << std::showbase
-#else
-        << "0x"
-#endif
-        << static_cast<int>(t);
-}
-
-//____________________________________________________________________________//
-
-void
-print_log_value<char const*>::operator()( std::ostream& ostr, char const* t )
-{
-    ostr << ( t ? t : "null string" );
-}
-
-//____________________________________________________________________________//
-
-void
-print_log_value<wchar_t const*>::operator()( std::ostream& ostr, wchar_t const* t )
-{
-    ostr << ( t ? t : L"null string" );
-}
-
-//____________________________________________________________________________//
-
-namespace tt_detail {
-
-// ************************************************************************** //
-// **************            TOOL BOX Implementation           ************** //
-// ************************************************************************** //
-
-using ::autoboost::unit_test::lazy_ostream;
-
-bool
-check_impl( predicate_result const& pr, lazy_ostream const& check_descr,
-            const_string file_name, std::size_t line_num,
-            tool_level tl, check_type ct,
-            std::size_t num_of_args, ... )
-{
-    using namespace unit_test;
-
-    if( !framework::is_initialized() )
-        throw std::runtime_error( "can't use testing tools before framework is initialized" );
-
-    if( !!pr )
-        tl = PASS;
-
-    log_level    ll;
-    char const*  prefix;
-    char const*  suffix;
-       
-    switch( tl ) {
-    case PASS:
-        ll      = log_successful_tests;
-        prefix  = "check ";
-        suffix  = " passed";
-        break;
-    case WARN:
-        ll      = log_warnings;
-        prefix  = "condition ";
-        suffix  = " is not satisfied";
-        break;
-    case CHECK:
-        ll      = log_all_errors;
-        prefix  = "check ";
-        suffix  = " failed";
-        break;
-    case REQUIRE:
-        ll      = log_fatal_errors;
-        prefix  = "critical check ";
-        suffix  = " failed";
-        break;
-    default:
-        return true;
-    }
-
-    switch( ct ) {
-    case CHECK_PRED:
-        unit_test_log << unit_test::log::begin( file_name, line_num ) 
-                      << ll << prefix << check_descr << suffix;
-        
-        if( !pr.has_empty_message() )
-            unit_test_log << ". " << pr.message();
-        
-        unit_test_log << unit_test::log::end();
-        break;
-
-    case CHECK_MSG:
-        unit_test_log << unit_test::log::begin( file_name, line_num ) << ll;
-        
-        if( tl == PASS )
-            unit_test_log << prefix << "'" << check_descr << "'" << suffix;
-        else
-            unit_test_log << check_descr;
-        
-        if( !pr.has_empty_message() )
-            unit_test_log << ". " << pr.message();
-
-        unit_test_log << unit_test::log::end();
-        break;
-
-    case CHECK_EQUAL: 
-    case CHECK_NE: 
-    case CHECK_LT: 
-    case CHECK_LE: 
-    case CHECK_GT: 
-    case CHECK_GE: {
-        static char const* check_str [] = { " == ", " != ", " < " , " <= ", " > " , " >= " };
-        static char const* rever_str [] = { " != ", " == ", " >= ", " > " , " <= ", " < "  };
-
-        va_list args;
-
-        va_start( args, num_of_args );
-        char const*         arg1_descr  = va_arg( args, char const* );
-        lazy_ostream const* arg1_val    = va_arg( args, lazy_ostream const* );
-        char const*         arg2_descr  = va_arg( args, char const* );
-        lazy_ostream const* arg2_val    = va_arg( args, lazy_ostream const* );
-
-        unit_test_log << unit_test::log::begin( file_name, line_num ) 
-                      << ll << prefix << arg1_descr << check_str[ct-CHECK_EQUAL] << arg2_descr << suffix;
-
-        if( tl != PASS )
-            unit_test_log << " [" << *arg1_val << rever_str[ct-CHECK_EQUAL] << *arg2_val << "]" ;
-
-        va_end( args );
-        
-        if( !pr.has_empty_message() )
-            unit_test_log << ". " << pr.message();
-
-        unit_test_log << unit_test::log::end();
-        break;
-    }
-
-    case CHECK_CLOSE:
-    case CHECK_CLOSE_FRACTION: {
-        va_list args;
-
-        va_start( args, num_of_args );
-        char const*         arg1_descr  = va_arg( args, char const* );
-        lazy_ostream const* arg1_val    = va_arg( args, lazy_ostream const* );
-        char const*         arg2_descr  = va_arg( args, char const* );
-        lazy_ostream const* arg2_val    = va_arg( args, lazy_ostream const* );
-        /* toler_descr = */               va_arg( args, char const* );
-        lazy_ostream const* toler_val   = va_arg( args, lazy_ostream const* );
-
-        unit_test_log << unit_test::log::begin( file_name, line_num ) << ll;
-
-        unit_test_log << "difference{" << pr.message() << (ct == CHECK_CLOSE ? "%" : "")
-                      << "} between " << arg1_descr << "{" << *arg1_val
-                      << "} and "               << arg2_descr << "{" << *arg2_val
-                      << ( tl == PASS ? "} doesn't exceed " : "} exceeds " )
-                      << *toler_val;
-        if( ct == CHECK_CLOSE )
-            unit_test_log << "%";
-
-        va_end( args );
-        
-        unit_test_log << unit_test::log::end();
-        break;
-    }
-    case CHECK_SMALL: {
-        va_list args;
-
-        va_start( args, num_of_args );
-        char const*         arg1_descr  = va_arg( args, char const* );
-        lazy_ostream const* arg1_val    = va_arg( args, lazy_ostream const* );
-        /* toler_descr = */               va_arg( args, char const* );
-        lazy_ostream const* toler_val   = va_arg( args, lazy_ostream const* );
-
-        unit_test_log << unit_test::log::begin( file_name, line_num ) << ll;
-
-        unit_test_log << "absolute value of " << arg1_descr << "{" << *arg1_val << "}" 
-                      << ( tl == PASS ? " doesn't exceed " : " exceeds " )
-                      << *toler_val;
-
-        va_end( args );
-        
-        if( !pr.has_empty_message() )
-            unit_test_log << ". " << pr.message();
-
-        unit_test_log << unit_test::log::end();
-        break;
-    }
-
-    case CHECK_PRED_WITH_ARGS: {
-        unit_test_log << unit_test::log::begin( file_name, line_num ) 
-                      << ll << prefix << check_descr;
-
-        // print predicate call description
-        {
-            va_list args;
-            va_start( args, num_of_args );
-
-            unit_test_log << "( ";
-            for( std::size_t i = 0; i < num_of_args; ++i ) {
-                unit_test_log << va_arg( args, char const* );
-                va_arg( args, lazy_ostream const* ); // skip argument value;
-                
-                if( i != num_of_args-1 )
-                    unit_test_log << ", ";
-            }
-            unit_test_log << " )" << suffix;
-            va_end( args );
-        }
-                        
-        if( tl != PASS ) {
-            va_list args;
-            va_start( args, num_of_args );
-
-            unit_test_log << " for ( ";
-            for( std::size_t i = 0; i < num_of_args; ++i ) {
-                va_arg( args, char const* ); // skip argument description;            
-                unit_test_log << *va_arg( args, lazy_ostream const* );
-                
-                if( i != num_of_args-1 )
-                    unit_test_log << ", ";
-            }
-            unit_test_log << " )";
-            va_end( args );
-        }
-       
-        if( !pr.has_empty_message() )
-            unit_test_log << ". " << pr.message();
-
-        unit_test_log << unit_test::log::end();
-        break;
-    }
-
-    case CHECK_EQUAL_COLL: {
-        va_list args;
-
-        va_start( args, num_of_args );
-        char const* left_begin_descr    = va_arg( args, char const* );
-        char const* left_end_descr      = va_arg( args, char const* );
-        char const* right_begin_descr   = va_arg( args, char const* );
-        char const* right_end_descr     = va_arg( args, char const* );
-
-        unit_test_log << unit_test::log::begin( file_name, line_num ) 
-                      << ll << prefix 
-                      << "{ " << left_begin_descr  << ", " << left_end_descr  << " } == { " 
-                              << right_begin_descr << ", " << right_end_descr << " }"
-                      << suffix;
-
-        va_end( args );
-        
-        if( !pr.has_empty_message() )
-            unit_test_log << ". " << pr.message();
-
-        unit_test_log << unit_test::log::end();
-        break;
-    }
-
-    case CHECK_BITWISE_EQUAL: {
-        va_list args;
-
-        va_start( args, num_of_args );
-        char const* left_descr    = va_arg( args, char const* );
-        char const* right_descr   = va_arg( args, char const* );
-
-        unit_test_log << unit_test::log::begin( file_name, line_num )
-                      << ll << prefix << left_descr  << " =.= " << right_descr << suffix;
-
-        va_end( args );
-        
-        if( !pr.has_empty_message() )
-            unit_test_log << ". " << pr.message();
-
-        unit_test_log << unit_test::log::end();
-        break;
-    }
-    }
-
-    switch( tl ) {
-    case PASS:
-        framework::assertion_result( true );
-        return true;
-
-    case WARN:
-        return false;
-
-    case CHECK:
-        framework::assertion_result( false );
-        return false;
-        
-    case REQUIRE:
-        framework::assertion_result( false );
-
-        framework::test_unit_aborted( framework::current_test_case() );
-
-        throw execution_aborted();
-    }
-
-    return true;
-}
-
-//____________________________________________________________________________//
-
-predicate_result
-equal_impl( char const* left, char const* right )
-{
-    return (left && right) ? std::strcmp( left, right ) == 0 : (left == right);
-}
-
-//____________________________________________________________________________//
-
-#if !defined( BOOST_NO_CWCHAR )
-
-predicate_result
-equal_impl( wchar_t const* left, wchar_t const* right )
-{
-    return (left && right) ? std::wcscmp( left, right ) == 0 : (left == right);
-}
-
-#endif // !defined( BOOST_NO_CWCHAR )
-
-//____________________________________________________________________________//
-
-bool
-is_defined_impl( const_string symbol_name, const_string symbol_value )
-{
-    symbol_value.trim_left( 2 );
-    return symbol_name != symbol_value;
-}
-
-//____________________________________________________________________________//
-
-} // namespace tt_detail
-
-// ************************************************************************** //
-// **************               output_test_stream             ************** //
-// ************************************************************************** //
-
-struct output_test_stream::Impl
-{
-    std::fstream    m_pattern;
-    bool            m_match_or_save;
-    bool            m_text_or_binary;
-    std::string     m_synced_string;
-
-    char            get_char()
-    {
-        char res;
-        do {
-            m_pattern.get( res );
-        } while( m_text_or_binary && res == '\r' && !m_pattern.fail() && !m_pattern.eof() );
-
-        return res;
-    }
-
-    void            check_and_fill( predicate_result& res )
-    {
-        if( !res.p_predicate_value )
-            res.message() << "Output content: \"" << m_synced_string << '\"';
-    }
-};
-
-//____________________________________________________________________________//
-
-output_test_stream::output_test_stream( const_string pattern_file_name, bool match_or_save, bool text_or_binary )
-: m_pimpl( new Impl )
-{
-    if( !pattern_file_name.is_empty() ) {
-        std::ios::openmode m = match_or_save ? std::ios::in : std::ios::out;
-        if( !text_or_binary )
-            m |= std::ios::binary;
-
-        m_pimpl->m_pattern.open( pattern_file_name.begin(), m );
-
-        BOOST_WARN_MESSAGE( m_pimpl->m_pattern.is_open(),
-                             "Can't open pattern file " << pattern_file_name
-                                << " for " << (match_or_save ? "reading" : "writing") );
-    }
-
-    m_pimpl->m_match_or_save    = match_or_save;
-    m_pimpl->m_text_or_binary   = text_or_binary;
-}
-
-//____________________________________________________________________________//
-
-output_test_stream::~output_test_stream()
-{
-    delete m_pimpl;
-}
-
-//____________________________________________________________________________//
-
-predicate_result
-output_test_stream::is_empty( bool flush_stream )
-{
-    sync();
-
-    result_type res( m_pimpl->m_synced_string.empty() );
-
-    m_pimpl->check_and_fill( res );
-
-    if( flush_stream )
-        flush();
-
-    return res;
-}
-
-//____________________________________________________________________________//
-
-predicate_result
-output_test_stream::check_length( std::size_t length_, bool flush_stream )
-{
-    sync();
-
-    result_type res( m_pimpl->m_synced_string.length() == length_ );
-
-    m_pimpl->check_and_fill( res );
-
-    if( flush_stream )
-        flush();
-
-    return res;
-}
-
-//____________________________________________________________________________//
-
-predicate_result
-output_test_stream::is_equal( const_string arg, bool flush_stream )
-{
-    sync();
-
-    result_type res( const_string( m_pimpl->m_synced_string ) == arg );
-
-    m_pimpl->check_and_fill( res );
-
-    if( flush_stream )
-        flush();
-
-    return res;
-}
-
-//____________________________________________________________________________//
-
-predicate_result
-output_test_stream::match_pattern( bool flush_stream )
-{
-    sync();
-
-    result_type result( true );
-
-    if( !m_pimpl->m_pattern.is_open() ) {
-        result = false;
-        result.message() << "Pattern file can't be opened!";
-    }
-    else {
-        if( m_pimpl->m_match_or_save ) {
-            for ( std::string::size_type i = 0; i < m_pimpl->m_synced_string.length(); ++i ) {
-                char c = m_pimpl->get_char();
-
-                result = !m_pimpl->m_pattern.fail() &&
-                         !m_pimpl->m_pattern.eof()  &&
-                         (m_pimpl->m_synced_string[i] == c);
-
-                if( !result ) {
-                    std::string::size_type suffix_size  = (std::min)( m_pimpl->m_synced_string.length() - i,
-                                                                    static_cast<std::string::size_type>(5) );
-
-                    // try to log area around the mismatch
-                    result.message() << "Mismatch at position " << i << '\n'
-                        << "..." << m_pimpl->m_synced_string.substr( i, suffix_size ) << "..." << '\n'
-                        << "..." << c;
-
-                    std::string::size_type counter = suffix_size;
-                    while( --counter ) {
-                        char c = m_pimpl->get_char();
-
-                        if( m_pimpl->m_pattern.fail() || m_pimpl->m_pattern.eof() )
-                            break;
-
-                        result.message() << c;
-                    }
-
-                    result.message() << "...";
-
-                    // skip rest of the bytes. May help for further matching
-                    m_pimpl->m_pattern.ignore( 
-                        static_cast<std::streamsize>( m_pimpl->m_synced_string.length() - i - suffix_size) );
-                    break;
-                }
-            }
-        }
-        else {
-            m_pimpl->m_pattern.write( m_pimpl->m_synced_string.c_str(),
-                                      static_cast<std::streamsize>( m_pimpl->m_synced_string.length() ) );
-            m_pimpl->m_pattern.flush();
-        }
-    }
-
-    if( flush_stream )
-        flush();
-
-    return result;
-}
-
-//____________________________________________________________________________//
-
-void
-output_test_stream::flush()
-{
-    m_pimpl->m_synced_string.erase();
-
-#ifndef BOOST_NO_STRINGSTREAM
-    str( std::string() );
-#else
-    seekp( 0, std::ios::beg );
-#endif
-}
-
-//____________________________________________________________________________//
-
-std::size_t
-output_test_stream::length()
-{
-    sync();
-
-    return m_pimpl->m_synced_string.length();
-}
-
-//____________________________________________________________________________//
-
-void
-output_test_stream::sync()
-{
-#ifdef BOOST_NO_STRINGSTREAM
-    m_pimpl->m_synced_string.assign( str(), pcount() );
-    freeze( false );
-#else
-    m_pimpl->m_synced_string = str();
-#endif
-}
-
-//____________________________________________________________________________//
-
-} // namespace test_tools
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TEST_TOOLS_IPP_012205GER
diff --git a/contrib/autoboost/boost/test/impl/unit_test_log.ipp b/contrib/autoboost/boost/test/impl/unit_test_log.ipp
deleted file mode 100644
index 40c34b361..000000000
--- a/contrib/autoboost/boost/test/impl/unit_test_log.ipp
+++ /dev/null
@@ -1,444 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : implemets Unit Test Log
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_LOG_IPP_012205GER
-#define BOOST_TEST_UNIT_TEST_LOG_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/unit_test_log.hpp>
-#include <boost/test/unit_test_log_formatter.hpp>
-#include <boost/test/unit_test_suite_impl.hpp>
-#include <boost/test/execution_monitor.hpp>
-
-#include <boost/test/detail/unit_test_parameters.hpp>
-
-#include <boost/test/utils/basic_cstring/compare.hpp>
-
-#include <boost/test/output/compiler_log_formatter.hpp>
-#include <boost/test/output/xml_log_formatter.hpp>
-
-// Boost
-#include <boost/scoped_ptr.hpp>
-#include <boost/io/ios_state.hpp>
-typedef ::autoboost::io::ios_base_all_saver io_saver_type;
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************             entry_value_collector            ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-entry_value_collector const&
-entry_value_collector::operator<<( lazy_ostream const& v ) const
-{
-    unit_test_log << v;
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-entry_value_collector const& 
-entry_value_collector::operator<<( const_string v ) const
-{
-    unit_test_log << v;
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-entry_value_collector::~entry_value_collector()
-{
-    if( m_last )
-        unit_test_log << log::end();
-}
-
-//____________________________________________________________________________//
-
-} // namespace ut_detail
-
-// ************************************************************************** //
-// **************                 unit_test_log                ************** //
-// ************************************************************************** //
-
-namespace {
-
-struct unit_test_log_impl {
-    // Constructor
-    unit_test_log_impl()
-    : m_stream( runtime_config::log_sink() )
-    , m_stream_state_saver( new io_saver_type( *m_stream ) )
-    , m_threshold_level( log_all_errors )
-    , m_log_formatter( new output::compiler_log_formatter )
-    {
-    }
-
-    // log data
-    typedef scoped_ptr<unit_test_log_formatter> formatter_ptr;
-    typedef scoped_ptr<io_saver_type>           saver_ptr;
-
-    std::ostream*       m_stream;
-    saver_ptr           m_stream_state_saver;
-    log_level           m_threshold_level;
-    formatter_ptr       m_log_formatter;
-
-    // entry data
-    bool                m_entry_in_progress;
-    bool                m_entry_started;
-    log_entry_data      m_entry_data;
-
-    // check point data
-    log_checkpoint_data m_checkpoint_data;
-
-    // helper functions
-    std::ostream&       stream()            { return *m_stream; }
-    void                set_checkpoint( const_string file, std::size_t line_num, const_string msg )
-    {
-        assign_op( m_checkpoint_data.m_message, msg, 0 );
-        m_checkpoint_data.m_file_name    = file;
-        m_checkpoint_data.m_line_num    = line_num;
-    }
-};
-
-unit_test_log_impl& s_log_impl() { static unit_test_log_impl the_inst; return the_inst; }
-
-} // local namespace
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::test_start( counter_t test_cases_amount )
-{
-    if( s_log_impl().m_threshold_level == log_nothing )
-        return;
-
-    s_log_impl().m_log_formatter->log_start( s_log_impl().stream(), test_cases_amount );
-
-    if( runtime_config::show_build_info() )
-        s_log_impl().m_log_formatter->log_build_info( s_log_impl().stream() );
-
-    s_log_impl().m_entry_in_progress = false;
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::test_finish()
-{
-    if( s_log_impl().m_threshold_level == log_nothing )
-        return;
-
-    s_log_impl().m_log_formatter->log_finish( s_log_impl().stream() );
-
-    s_log_impl().stream().flush();
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::test_aborted()
-{
-    BOOST_TEST_LOG_ENTRY( log_messages ) << "Test is aborted";
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::test_unit_start( test_unit const& tu )
-{
-    if( s_log_impl().m_threshold_level > log_test_units )
-        return;
-
-    if( s_log_impl().m_entry_in_progress )
-        *this << log::end();
-
-    s_log_impl().m_log_formatter->test_unit_start( s_log_impl().stream(), tu );
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::test_unit_finish( test_unit const& tu, unsigned long elapsed )
-{
-    if( s_log_impl().m_threshold_level > log_test_units )
-        return;
-
-    s_log_impl().m_checkpoint_data.clear();
-
-    if( s_log_impl().m_entry_in_progress )
-        *this << log::end();
-
-    s_log_impl().m_log_formatter->test_unit_finish( s_log_impl().stream(), tu, elapsed );
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::test_unit_skipped( test_unit const& tu )
-{
-    if( s_log_impl().m_threshold_level > log_test_units )
-        return;
-
-    if( s_log_impl().m_entry_in_progress )
-        *this << log::end();
-
-    s_log_impl().m_log_formatter->test_unit_skipped( s_log_impl().stream(), tu );
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::test_unit_aborted( test_unit const& )
-{
-    // do nothing
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::assertion_result( bool )
-{
-    // do nothing
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::exception_caught( execution_exception const& ex )
-{
-    log_level l =
-        ex.code() <= execution_exception::cpp_exception_error   ? log_cpp_exception_errors :
-        (ex.code() <= execution_exception::timeout_error        ? log_system_errors
-                                                                : log_fatal_errors );
-
-    if( l >= s_log_impl().m_threshold_level ) {
-        if( s_log_impl().m_entry_in_progress )
-            *this << log::end();
-
-        s_log_impl().m_log_formatter->log_exception( s_log_impl().stream(), s_log_impl().m_checkpoint_data, ex );
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::set_checkpoint( const_string file, std::size_t line_num, const_string msg )
-{
-    s_log_impl().set_checkpoint( file, line_num, msg );
-}
-
-//____________________________________________________________________________//
-
-char
-set_unix_slash( char in )
-{
-    return in == '\\' ? '/' : in;
-}
-    
-unit_test_log_t&
-unit_test_log_t::operator<<( log::begin const& b )
-{
-    if( s_log_impl().m_entry_in_progress )
-        *this << log::end();
-
-    s_log_impl().m_stream_state_saver->restore();
-
-    s_log_impl().m_entry_data.clear();
-
-    assign_op( s_log_impl().m_entry_data.m_file_name, b.m_file_name, 0 );
-
-    // normalize file name
-    std::transform( s_log_impl().m_entry_data.m_file_name.begin(), s_log_impl().m_entry_data.m_file_name.end(),
-                    s_log_impl().m_entry_data.m_file_name.begin(),
-                    &set_unix_slash );
-
-    s_log_impl().m_entry_data.m_line_num = b.m_line_num;
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-unit_test_log_t&
-unit_test_log_t::operator<<( log::end const& )
-{
-    if( s_log_impl().m_entry_in_progress )
-        s_log_impl().m_log_formatter->log_entry_finish( s_log_impl().stream() );
-
-    s_log_impl().m_entry_in_progress = false;
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-unit_test_log_t&
-unit_test_log_t::operator<<( log_level l )
-{
-    s_log_impl().m_entry_data.m_level = l;
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-ut_detail::entry_value_collector
-unit_test_log_t::operator()( log_level l )
-{
-    *this << l;
-
-    return ut_detail::entry_value_collector();
-}
-
-//____________________________________________________________________________//
-
-bool
-unit_test_log_t::log_entry_start()
-{
-    if( s_log_impl().m_entry_in_progress ) 
-        return true;
-
-    switch( s_log_impl().m_entry_data.m_level ) {
-    case log_successful_tests:
-        s_log_impl().m_log_formatter->log_entry_start( s_log_impl().stream(), s_log_impl().m_entry_data,
-                                                       unit_test_log_formatter::BOOST_UTL_ET_INFO );
-        break;
-    case log_messages:
-        s_log_impl().m_log_formatter->log_entry_start( s_log_impl().stream(), s_log_impl().m_entry_data,
-                                                       unit_test_log_formatter::BOOST_UTL_ET_MESSAGE );
-        break;
-    case log_warnings:
-        s_log_impl().m_log_formatter->log_entry_start( s_log_impl().stream(), s_log_impl().m_entry_data,
-                                                       unit_test_log_formatter::BOOST_UTL_ET_WARNING );
-        break;
-    case log_all_errors:
-    case log_cpp_exception_errors:
-    case log_system_errors:
-        s_log_impl().m_log_formatter->log_entry_start( s_log_impl().stream(), s_log_impl().m_entry_data,
-                                                       unit_test_log_formatter::BOOST_UTL_ET_ERROR );
-        break;
-    case log_fatal_errors:
-        s_log_impl().m_log_formatter->log_entry_start( s_log_impl().stream(), s_log_impl().m_entry_data,
-                                                       unit_test_log_formatter::BOOST_UTL_ET_FATAL_ERROR );
-        break;
-    case log_nothing:
-    case log_test_units:
-    case invalid_log_level:
-        return false;
-    }
-
-    s_log_impl().m_entry_in_progress = true;
-
-    return true;
-}
-
-//____________________________________________________________________________//
-
-unit_test_log_t&
-unit_test_log_t::operator<<( const_string value )
-{
-    if( s_log_impl().m_entry_data.m_level >= s_log_impl().m_threshold_level && !value.empty() && log_entry_start() )
-        s_log_impl().m_log_formatter->log_entry_value( s_log_impl().stream(), value );
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-unit_test_log_t&
-unit_test_log_t::operator<<( lazy_ostream const& value )
-{
-    if( s_log_impl().m_entry_data.m_level >= s_log_impl().m_threshold_level && !value.empty() && log_entry_start() )
-        s_log_impl().m_log_formatter->log_entry_value( s_log_impl().stream(), value );
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::set_stream( std::ostream& str )
-{
-    if( s_log_impl().m_entry_in_progress )
-        return;
-
-    s_log_impl().m_stream = &str;
-    s_log_impl().m_stream_state_saver.reset( new io_saver_type( str ) );
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::set_threshold_level( log_level lev )
-{
-    if( s_log_impl().m_entry_in_progress || lev == invalid_log_level )
-        return;
-
-    s_log_impl().m_threshold_level = lev;
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::set_format( output_format log_format )
-{
-    if( s_log_impl().m_entry_in_progress )
-        return;
-
-    if( log_format == CLF )
-        set_formatter( new output::compiler_log_formatter );
-    else
-        set_formatter( new output::xml_log_formatter );
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::set_formatter( unit_test_log_formatter* the_formatter )
-{
-    s_log_impl().m_log_formatter.reset( the_formatter );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************            unit_test_log_formatter           ************** //
-// ************************************************************************** //
-
-void
-unit_test_log_formatter::log_entry_value( std::ostream& ostr, lazy_ostream const& value )
-{
-    log_entry_value( ostr, (wrap_stringstream().ref() << value).str() );
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_LOG_IPP_012205GER
diff --git a/contrib/autoboost/boost/test/impl/unit_test_main.ipp b/contrib/autoboost/boost/test/impl/unit_test_main.ipp
deleted file mode 100644
index b5338ae2a..000000000
--- a/contrib/autoboost/boost/test/impl/unit_test_main.ipp
+++ /dev/null
@@ -1,246 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : main function implementation for Unit Test Framework
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_MAIN_IPP_012205GER
-#define BOOST_TEST_UNIT_TEST_MAIN_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/framework.hpp>
-#include <boost/test/results_collector.hpp>
-#include <boost/test/unit_test_suite_impl.hpp>
-#include <boost/test/results_reporter.hpp>
-
-#include <boost/test/detail/unit_test_parameters.hpp>
-
-#if !defined(__BORLANDC__) && !BOOST_WORKAROUND( BOOST_MSVC, < 1300 ) && !BOOST_WORKAROUND( __SUNPRO_CC, < 0x5100 )
-#define BOOST_TEST_SUPPORT_RUN_BY_NAME
-#include <boost/test/utils/iterator/token_iterator.hpp>
-#endif
-
-// Boost
-#include <boost/cstdlib.hpp>
-#include <boost/bind.hpp>
-
-// STL
-#include <stdexcept>
-#include <iostream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                 test_case_filter             ************** //
-// ************************************************************************** //
-
-class test_case_filter : public test_tree_visitor {
-public:
-    struct single_filter {
-        single_filter( const_string in )
-        {
-            if( in == "*" )
-                m_kind  = SFK_ALL;
-            else if( first_char( in ) == '*' && last_char( in ) == '*' ) {
-                m_kind  = SFK_SUBSTR;
-                m_value = in.substr( 1, in.size()-1 );
-            }
-            else if( first_char( in ) == '*' ) {
-                m_kind  = SFK_TRAILING;
-                m_value = in.substr( 1 );
-            }
-            else if( last_char( in ) == '*' ) {
-                m_kind  = SFK_LEADING;
-                m_value = in.substr( 0, in.size()-1 );
-            }
-            else {
-                m_kind  = SFK_MATCH;
-                m_value = in;
-            }
-        };
-
-        bool            pass( test_unit const& tu ) const
-        {
-            const_string name( tu.p_name );
-    
-            switch( m_kind ) {
-            default:
-            case SFK_ALL:
-                return true;
-
-            case SFK_LEADING:
-                return name.substr( 0, m_value.size() ) == m_value;
-
-            case SFK_TRAILING:
-                return name.size() >= m_value.size() && name.substr( name.size() - m_value.size() ) == m_value;
-
-            case SFK_SUBSTR:
-                return name.find( m_value ) != const_string::npos;
-
-            case SFK_MATCH:
-                return m_value == tu.p_name.get();
-            }
-        }
-        enum kind { SFK_ALL, SFK_LEADING, SFK_TRAILING, SFK_SUBSTR, SFK_MATCH };
-
-        kind            m_kind;
-        const_string    m_value;
-    };
-    // Constructor
-#ifndef BOOST_TEST_SUPPORT_RUN_BY_NAME
-    explicit        test_case_filter( const_string ) : m_depth( 0 ) {}
-#else
-    explicit        test_case_filter( const_string tc_to_run ) 
-    : m_depth( 0 )
-    {
-        string_token_iterator tit( tc_to_run, (dropped_delimeters = "/", kept_delimeters = dt_none) );
-
-        while( tit != string_token_iterator() ) {
-            m_filters.push_back( 
-                std::vector<single_filter>( string_token_iterator( *tit, (dropped_delimeters = ",", kept_delimeters = dt_none)  ), 
-                                            string_token_iterator() ) );
-
-            ++tit;           
-        }
-    }
-#endif
-    
-    void            filter_unit( test_unit const& tu )
-    {
-        if( (++m_depth - 1) > m_filters.size() ) {
-            tu.p_enabled.value = true;
-            return;
-        }
-
-        if( m_depth == 1 )
-            return;
-
-        std::vector<single_filter> const& filters = m_filters[m_depth-2];
-
-        tu.p_enabled.value =
-            std::find_if( filters.begin(), filters.end(), bind( &single_filter::pass, _1, autoboost::ref(tu) ) ) != filters.end();
-    }
-
-    // test tree visitor interface
-    virtual void    visit( test_case const& tc )
-    {
-        if( m_depth < m_filters.size() ) {
-            tc.p_enabled.value = false;
-            return;
-        }
-
-        filter_unit( tc );
-
-        --m_depth;
-    }
-
-    virtual bool    test_suite_start( test_suite const& ts )
-    { 
-        filter_unit( ts );
-
-        if( !ts.p_enabled )
-            --m_depth;
-
-        return ts.p_enabled;
-    }
-
-    virtual void    test_suite_finish( test_suite const& )  { --m_depth; }
-
-private:
-    // Data members
-    std::vector<std::vector<single_filter> >    m_filters;
-    unsigned                                    m_depth;
-};
-
-// ************************************************************************** //
-// **************                  unit_test_main              ************** //
-// ************************************************************************** //
-
-int BOOST_TEST_DECL
-unit_test_main( init_unit_test_func init_func, int argc, char* argv[] )
-{
-    try {
-        framework::init( init_func, argc, argv );
-
-        if( !runtime_config::test_to_run().is_empty() ) {
-            test_case_filter filter( runtime_config::test_to_run() );
-
-            traverse_test_tree( framework::master_test_suite().p_id, filter );
-        }
-
-        framework::run();
-
-        results_reporter::make_report();
-
-        return runtime_config::no_result_code() 
-                    ? autoboost::exit_success
-                    : results_collector.results( framework::master_test_suite().p_id ).result_code();
-    }
-    catch( framework::nothing_to_test const& ) {
-        return autoboost::exit_success;
-    }
-    catch( framework::internal_error const& ex ) {
-        results_reporter::get_stream() << "Boost.Test framework internal error: " << ex.what() << std::endl;
-        
-        return autoboost::exit_exception_failure;
-    }
-    catch( framework::setup_error const& ex ) {
-        results_reporter::get_stream() << "Test setup error: " << ex.what() << std::endl;
-        
-        return autoboost::exit_exception_failure;
-    }
-    catch( ... ) {
-        results_reporter::get_stream() << "Boost.Test framework internal error: unknown reason" << std::endl;
-        
-        return autoboost::exit_exception_failure;
-    }
-}
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-#if !defined(BOOST_TEST_DYN_LINK) && !defined(BOOST_TEST_NO_MAIN)
-
-// ************************************************************************** //
-// **************        main function for tests using lib     ************** //
-// ************************************************************************** //
-
-int BOOST_TEST_CALL_DECL
-main( int argc, char* argv[] )
-{
-    // prototype for user's unit test init function
-#ifdef BOOST_TEST_ALTERNATIVE_INIT_API
-    extern bool init_unit_test();
-
-    autoboost::unit_test::init_unit_test_func init_func = &init_unit_test;
-#else
-    extern ::autoboost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] );
-
-    autoboost::unit_test::init_unit_test_func init_func = &init_unit_test_suite;
-#endif
-
-    return ::autoboost::unit_test::unit_test_main( init_func, argc, argv );
-}
-
-#endif // !BOOST_TEST_DYN_LINK && !BOOST_TEST_NO_MAIN
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_MAIN_IPP_012205GER
diff --git a/contrib/autoboost/boost/test/impl/unit_test_monitor.ipp b/contrib/autoboost/boost/test/impl/unit_test_monitor.ipp
deleted file mode 100644
index c39fda7f0..000000000
--- a/contrib/autoboost/boost/test/impl/unit_test_monitor.ipp
+++ /dev/null
@@ -1,101 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : implements specific subclass of Executon Monitor used by Unit
-//  Test Framework to monitor test cases run.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_MONITOR_IPP_012205GER
-#define BOOST_TEST_UNIT_TEST_MONITOR_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/unit_test_monitor.hpp>
-#include <boost/test/unit_test_suite_impl.hpp>
-#include <boost/test/test_tools.hpp>
-#include <boost/test/framework.hpp>
-
-#include <boost/test/detail/unit_test_parameters.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-namespace {
-
-template<typename F>
-struct zero_return_wrapper_t {
-    explicit zero_return_wrapper_t( F const& f ) : m_f( f ) {}
-    
-    int operator()() { m_f(); return 0; }
-    
-    F const& m_f;
-};
-
-template<typename F>
-zero_return_wrapper_t<F>
-zero_return_wrapper( F const& f )
-{
-    return zero_return_wrapper_t<F>( f );
-}
-
-}
-
-// ************************************************************************** //
-// **************               unit_test_monitor              ************** //
-// ************************************************************************** //
-
-unit_test_monitor_t::error_level
-unit_test_monitor_t::execute_and_translate( test_case const& tc )
-{
-    try {
-        p_catch_system_errors.value     = runtime_config::catch_sys_errors();
-        p_timeout.value                 = tc.p_timeout.get();
-        p_auto_start_dbg.value          = runtime_config::auto_start_dbg();
-        p_use_alt_stack.value           = runtime_config::use_alt_stack();
-        p_detect_fp_exceptions.value    = runtime_config::detect_fp_exceptions();
-
-        execute( callback0<int>( zero_return_wrapper( tc.test_func() ) ) );
-    }
-    catch( execution_exception const& ex ) {
-        framework::exception_caught( ex );
-        framework::test_unit_aborted( framework::current_test_case() );
-
-        // translate execution_exception::error_code to error_level
-        switch( ex.code() ) {
-        case execution_exception::no_error:             return test_ok;
-        case execution_exception::user_error:           return unexpected_exception;
-        case execution_exception::cpp_exception_error:  return unexpected_exception;
-        case execution_exception::system_error:         return os_exception;
-        case execution_exception::timeout_error:        return os_timeout;
-        case execution_exception::user_fatal_error:
-        case execution_exception::system_fatal_error:   return fatal_error;
-        default:                                        return unexpected_exception;
-        }
-    }
-
-    return test_ok;
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_MONITOR_IPP_012205GER
diff --git a/contrib/autoboost/boost/test/impl/unit_test_parameters.ipp b/contrib/autoboost/boost/test/impl/unit_test_parameters.ipp
deleted file mode 100644
index 90d4862de..000000000
--- a/contrib/autoboost/boost/test/impl/unit_test_parameters.ipp
+++ /dev/null
@@ -1,527 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : simple implementation for Unit Test Framework parameter
-//  handling routines. May be rewritten in future to use some kind of
-//  command-line arguments parsing facility and environment variable handling
-//  facility
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_PARAMETERS_IPP_012205GER
-#define BOOST_TEST_UNIT_TEST_PARAMETERS_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/detail/unit_test_parameters.hpp>
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-#include <boost/test/utils/basic_cstring/compare.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-#include <boost/test/utils/fixed_mapping.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/test/framework.hpp>
-
-// Boost.Runtime.Param
-#include <boost/test/utils/runtime/cla/dual_name_parameter.hpp>
-#include <boost/test/utils/runtime/cla/parser.hpp>
-
-namespace rt  = autoboost::runtime;
-namespace cla = rt::cla;
-
-
-#ifndef UNDER_CE
-#include <boost/test/utils/runtime/env/variable.hpp>
-
-namespace env = rt::env;
-#endif
-
-
-// Boost
-#include <boost/config.hpp>
-#include <boost/test/detail/suppress_warnings.hpp>
-#include <boost/lexical_cast.hpp>
-#include <boost/test/detail/enable_warnings.hpp>
-
-// STL
-#include <map>
-#include <cstdlib>
-#include <iostream>
-#include <fstream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-# ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::getenv; using ::strncmp; using ::strcmp; }
-# endif
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************    input operations for unit_test's enums    ************** //
-// ************************************************************************** //
-
-std::istream&
-operator>>( std::istream& in, unit_test::log_level& ll )
-{
-    static fixed_mapping<const_string,unit_test::log_level,case_ins_less<char const> > log_level_name(
-        "all"           , log_successful_tests,
-        "success"       , log_successful_tests,
-        "test_suite"    , log_test_units,
-        "unit_scope"    , log_test_units,
-        "message"       , log_messages,
-        "warning"       , log_warnings,
-        "error"         , log_all_errors,
-        "cpp_exception" , log_cpp_exception_errors,
-        "system_error"  , log_system_errors,
-        "fatal_error"   , log_fatal_errors,
-        "nothing"       , log_nothing,
-
-        invalid_log_level
-        );
-
-    std::string val;
-    in >> val;
-
-    ll = log_level_name[val];
-    BOOST_TEST_SETUP_ASSERT( ll != unit_test::invalid_log_level, "invalid log level " + val );
-
-    return in;
-}
-
-//____________________________________________________________________________//
-
-std::istream&
-operator>>( std::istream& in, unit_test::report_level& rl )
-{
-    fixed_mapping<const_string,unit_test::report_level,case_ins_less<char const> > report_level_name (
-        "confirm",  CONFIRMATION_REPORT,
-        "short",    SHORT_REPORT,
-        "detailed", DETAILED_REPORT,
-        "no",       NO_REPORT,
-
-        INV_REPORT_LEVEL
-        );
-
-    std::string val;
-    in >> val;
-
-    rl = report_level_name[val];
-    BOOST_TEST_SETUP_ASSERT( rl != INV_REPORT_LEVEL, "invalid report level " + val );
-
-    return in;
-}
-
-//____________________________________________________________________________//
-
-std::istream&
-operator>>( std::istream& in, unit_test::output_format& of )
-{
-    fixed_mapping<const_string,unit_test::output_format,case_ins_less<char const> > output_format_name (
-        "HRF", unit_test::CLF,
-        "CLF", unit_test::CLF,
-        "XML", unit_test::XML,
-
-        unit_test::INV_OF
-        );
-
-    std::string val;
-    in >> val;
-
-    of = output_format_name[val];
-    BOOST_TEST_SETUP_ASSERT( of != unit_test::INV_OF, "invalid output format " + val );
-
-    return in;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 runtime_config               ************** //
-// ************************************************************************** //
-
-namespace runtime_config {
-
-namespace {
-
-// framework parameters and corresponding command-line arguments
-std::string AUTO_START_DBG    = "auto_start_dbg";
-std::string BREAK_EXEC_PATH   = "break_exec_path";
-std::string BUILD_INFO        = "build_info";
-std::string CATCH_SYS_ERRORS  = "catch_system_errors";
-std::string DETECT_FP_EXCEPT  = "detect_fp_exceptions";
-std::string DETECT_MEM_LEAKS  = "detect_memory_leaks";
-std::string LOG_FORMAT        = "log_format";
-std::string LOG_LEVEL         = "log_level";
-std::string LOG_SINK          = "log_sink";
-std::string OUTPUT_FORMAT     = "output_format";
-std::string RANDOM_SEED       = "random";
-std::string REPORT_FORMAT     = "report_format";
-std::string REPORT_LEVEL      = "report_level";
-std::string REPORT_SINK       = "report_sink";
-std::string RESULT_CODE       = "result_code";
-std::string TESTS_TO_RUN      = "run_test";
-std::string SAVE_TEST_PATTERN = "save_pattern";
-std::string SHOW_PROGRESS     = "show_progress";
-std::string USE_ALT_STACK     = "use_alt_stack";
-
-fixed_mapping<const_string,const_string> parameter_2_env_var(
-    AUTO_START_DBG    , "BOOST_TEST_AUTO_START_DBG",
-    BREAK_EXEC_PATH   , "BOOST_TEST_BREAK_EXEC_PATH",
-    BUILD_INFO        , "BOOST_TEST_BUILD_INFO",
-    CATCH_SYS_ERRORS  , "BOOST_TEST_CATCH_SYSTEM_ERRORS",
-    DETECT_FP_EXCEPT  , "BOOST_TEST_DETECT_FP_EXCEPTIONS",
-    DETECT_MEM_LEAKS  , "BOOST_TEST_DETECT_MEMORY_LEAK",
-    LOG_FORMAT        , "BOOST_TEST_LOG_FORMAT",
-    LOG_LEVEL         , "BOOST_TEST_LOG_LEVEL",
-    LOG_SINK          , "BOOST_TEST_LOG_SINK",
-    OUTPUT_FORMAT     , "BOOST_TEST_OUTPUT_FORMAT",
-    RANDOM_SEED       , "BOOST_TEST_RANDOM",
-    REPORT_FORMAT     , "BOOST_TEST_REPORT_FORMAT",
-    REPORT_LEVEL      , "BOOST_TEST_REPORT_LEVEL",
-    REPORT_SINK       , "BOOST_TEST_REPORT_SINK",
-    RESULT_CODE       , "BOOST_TEST_RESULT_CODE",
-    TESTS_TO_RUN      , "BOOST_TESTS_TO_RUN",
-    SAVE_TEST_PATTERN , "BOOST_TEST_SAVE_PATTERN",
-    SHOW_PROGRESS     , "BOOST_TEST_SHOW_PROGRESS",
-    USE_ALT_STACK     , "BOOST_TEST_USE_ALT_STACK",
-
-    ""
-);
-
-//____________________________________________________________________________//
-
-// storage for the CLAs
-cla::parser     s_cla_parser;
-std::string     s_empty;
-
-output_format   s_report_format;
-output_format   s_log_format;
-
-//____________________________________________________________________________//
-
-template<typename T>
-T
-retrieve_parameter( const_string parameter_name, cla::parser const& s_cla_parser, T const& default_value = T(), T const& optional_value = T() )
-{
-    rt::const_argument_ptr arg = s_cla_parser[parameter_name];
-    if( arg ) {
-        if( rtti::type_id<T>() == rtti::type_id<bool>() ||
-            !static_cast<cla::parameter const&>( arg->p_formal_parameter.get() ).p_optional_value )
-            return s_cla_parser.get<T>( parameter_name );
-
-        optional<T> val = s_cla_parser.get<optional<T> >( parameter_name );
-        if( val )
-            return *val;
-        else
-            return optional_value;
-    }
-
-    autoboost::optional<T> v;
-
-#ifndef UNDER_CE
-    env::get( parameter_2_env_var[parameter_name], v );
-#endif
-
-    if( v )
-        return *v;
-    else
-        return default_value;
-}
-
-//____________________________________________________________________________//
-
-} // local namespace 
-
-void
-init( int& argc, char** argv )
-{
-    using namespace cla;
-
-    try {
-        s_cla_parser - cla::ignore_mismatch
-          << cla::dual_name_parameter<bool>( AUTO_START_DBG + "|d" )
-            - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
-               cla::description = "Automatically starts debugger if system level error (signal) occurs")
-          << cla::named_parameter<std::string>( BREAK_EXEC_PATH )
-            - (cla::prefix = "--",cla::separator = "=",cla::guess_name,cla::optional,
-               cla::description = "For the exception safety testing allows to break at specific execution path")
-          << cla::dual_name_parameter<bool>( BUILD_INFO + "|i" )
-            - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
-               cla::description = "Shows library build information" )
-          << cla::dual_name_parameter<bool>( CATCH_SYS_ERRORS + "|s" )
-            - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
-               cla::description = "Allows to switch between catching and ignoring system errors (signals)")
-          << cla::named_parameter<bool>( DETECT_FP_EXCEPT )
-            - (cla::prefix = "--",cla::separator = "=",cla::guess_name,cla::optional,
-               cla::description = "Allows to switch between catching and ignoring floating point exceptions")
-          << cla::named_parameter<long>( DETECT_MEM_LEAKS )
-            - (cla::prefix = "--",cla::separator = "=",cla::guess_name,cla::optional,
-               cla::description = "Allows to switch between catching and ignoring memory leaks")
-          << cla::dual_name_parameter<unit_test::output_format>( LOG_FORMAT + "|f" )
-            - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
-               cla::description = "Specifies log format")
-          << cla::dual_name_parameter<unit_test::log_level>( LOG_LEVEL + "|l" )
-            - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
-               cla::description = "Specifies log level")
-          << cla::dual_name_parameter<std::string>( LOG_SINK + "|k" )
-            - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
-               cla::description = "Specifies log sink:stdout(default),stderr or file name")
-          << cla::dual_name_parameter<unit_test::output_format>( OUTPUT_FORMAT + "|o" )
-            - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
-               cla::description = "Specifies output format (both log and report)")
-          << cla::dual_name_parameter<int>( RANDOM_SEED + "|a" )
-            - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,cla::optional_value,
-               cla::description = "Allows to switch between sequential and random order of test units execution.\n"
-                                  "Optionally allows to specify concrete seed for random number generator")
-          << cla::dual_name_parameter<unit_test::output_format>( REPORT_FORMAT + "|m" )
-            - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
-               cla::description = "Specifies report format")
-          << cla::dual_name_parameter<unit_test::report_level>(REPORT_LEVEL + "|r")
-            - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
-               cla::description = "Specifies report level")
-          << cla::dual_name_parameter<std::string>( REPORT_SINK + "|e" )
-            - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
-               cla::description = "Specifies report sink:stderr(default),stdout or file name")
-          << cla::dual_name_parameter<bool>( RESULT_CODE + "|c" )
-            - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
-               cla::description = "Allows to disable test modules's result code generation")
-          << cla::dual_name_parameter<std::string>( TESTS_TO_RUN + "|t" )
-            - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
-               cla::description = "Allows to filter which test units to run")
-          << cla::named_parameter<bool>( SAVE_TEST_PATTERN )
-            - (cla::prefix = "--",cla::separator = "=",cla::guess_name,cla::optional,
-               cla::description = "Allows to switch between saving and matching against test pattern file")
-          << cla::dual_name_parameter<bool>( SHOW_PROGRESS + "|p" )
-            - (cla::prefix = "--|-",cla::separator = "=| ",cla::guess_name,cla::optional,
-               cla::description = "Turns on progress display")
-          << cla::named_parameter<bool>( USE_ALT_STACK )
-            - (cla::prefix = "--",cla::separator = "=",cla::guess_name,cla::optional,
-               cla::description = "Turns on/off usage of an alternative stack for signal handling")
-
-          << cla::dual_name_parameter<bool>( "help|?" )
-            - (cla::prefix = "--|-",cla::separator = "=",cla::guess_name,cla::optional,
-               cla::description = "this help message")
-            ;
-
-        s_cla_parser.parse( argc, argv );
-
-        if( s_cla_parser["help"] ) {
-            s_cla_parser.help( std::cout );
-            throw framework::nothing_to_test();
-        }
-
-        s_report_format     = retrieve_parameter( REPORT_FORMAT, s_cla_parser, unit_test::CLF );
-        s_log_format        = retrieve_parameter( LOG_FORMAT, s_cla_parser, unit_test::CLF );
-
-        unit_test::output_format of = retrieve_parameter( OUTPUT_FORMAT, s_cla_parser, unit_test::INV_OF );
-
-        if( of != unit_test::INV_OF )
-            s_report_format = s_log_format = of;
-    }
-    catch( rt::logic_error const& ex ) {
-        std::ostringstream err;
-        
-        err << "Fail to process runtime parameters: " << ex.msg() << std::endl;
-        s_cla_parser.usage( err );
-
-        throw framework::setup_error( err.str() );
-    }
-}
-
-//____________________________________________________________________________//
-
-unit_test::log_level
-log_level()
-{
-    return retrieve_parameter( LOG_LEVEL, s_cla_parser, unit_test::log_all_errors );
-}
-
-//____________________________________________________________________________//
-
-bool
-no_result_code()
-{
-    return !retrieve_parameter( RESULT_CODE, s_cla_parser, true );
-}
-
-//____________________________________________________________________________//
-
-unit_test::report_level
-report_level()
-{
-    return retrieve_parameter( REPORT_LEVEL, s_cla_parser, unit_test::CONFIRMATION_REPORT );
-}
-
-//____________________________________________________________________________//
-
-const_string
-test_to_run()
-{
-    static std::string s_test_to_run = retrieve_parameter( TESTS_TO_RUN, s_cla_parser, s_empty );
-
-    return s_test_to_run;
-}
-
-//____________________________________________________________________________//
-
-const_string
-break_exec_path()
-{
-    static std::string s_break_exec_path = retrieve_parameter( BREAK_EXEC_PATH, s_cla_parser, s_empty );
-
-    return s_break_exec_path;
-}
-
-//____________________________________________________________________________//
-
-bool
-save_pattern()
-{
-    return retrieve_parameter( SAVE_TEST_PATTERN, s_cla_parser, false );
-}
-
-//____________________________________________________________________________//
-
-bool
-show_progress()
-{
-    return retrieve_parameter( SHOW_PROGRESS, s_cla_parser, false );
-}
-
-//____________________________________________________________________________//
-
-bool
-show_build_info()
-{
-    return retrieve_parameter( BUILD_INFO, s_cla_parser, false );
-}
-
-//____________________________________________________________________________//
-
-bool
-catch_sys_errors()
-{
-    return retrieve_parameter( CATCH_SYS_ERRORS, s_cla_parser, 
-#ifdef BOOST_TEST_DEFAULTS_TO_CORE_DUMP
-        false
-#else
-        true 
-#endif
-        );
-}
-
-//____________________________________________________________________________//
-
-bool
-auto_start_dbg()
-{
-    // !! set debugger as an option
-    return retrieve_parameter( AUTO_START_DBG, s_cla_parser, false );
-;
-}
-
-//____________________________________________________________________________//
-
-bool
-use_alt_stack()
-{
-    return retrieve_parameter( USE_ALT_STACK, s_cla_parser, true );
-}
-
-//____________________________________________________________________________//
-
-bool
-detect_fp_exceptions()
-{
-    return retrieve_parameter( DETECT_FP_EXCEPT, s_cla_parser, false );
-}
-
-//____________________________________________________________________________//
-
-output_format
-report_format()
-{
-    return s_report_format;
-}
-
-//____________________________________________________________________________//
-
-output_format
-log_format()
-{
-    return s_log_format;
-}
-
-//____________________________________________________________________________//
-
-std::ostream*
-report_sink()
-{
-    std::string sink_name = retrieve_parameter( REPORT_SINK, s_cla_parser, s_empty );
-
-    if( sink_name.empty() || sink_name == "stderr" )
-        return &std::cerr;    
-    
-    if( sink_name == "stdout" )
-        return &std::cout;
-
-    static std::ofstream log_file( sink_name.c_str() );
-    return &log_file;
-}
-
-//____________________________________________________________________________//
-
-std::ostream*
-log_sink()
-{
-    std::string sink_name = retrieve_parameter( LOG_SINK, s_cla_parser, s_empty );
-
-    if( sink_name.empty() || sink_name == "stdout" )
-        return &std::cout;    
-
-    if( sink_name == "stderr" )
-        return &std::cerr;    
-
-    static std::ofstream report_file( sink_name.c_str() );
-    return &report_file;
-}
-
-//____________________________________________________________________________//
-
-long
-detect_memory_leaks()
-{
-    return retrieve_parameter( DETECT_MEM_LEAKS, s_cla_parser, static_cast<long>(1) );
-}
-
-//____________________________________________________________________________//
-
-int
-random_seed()
-{
-    return retrieve_parameter( RANDOM_SEED, s_cla_parser, 0, 1 );
-}
-
-//____________________________________________________________________________//
-
-} // namespace runtime_config
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_PARAMETERS_IPP_012205GER
diff --git a/contrib/autoboost/boost/test/impl/unit_test_suite.ipp b/contrib/autoboost/boost/test/impl/unit_test_suite.ipp
deleted file mode 100644
index ef86993d3..000000000
--- a/contrib/autoboost/boost/test/impl/unit_test_suite.ipp
+++ /dev/null
@@ -1,346 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : privides core implementation for Unit Test Framework.
-//                Extensions can be provided in separate files
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_SUITE_IPP_012205GER
-#define BOOST_TEST_UNIT_TEST_SUITE_IPP_012205GER
-
-// Boost.Test
-#include <boost/detail/workaround.hpp>
-#include <boost/test/unit_test_suite_impl.hpp>
-#include <boost/test/framework.hpp>
-#include <boost/test/utils/foreach.hpp>
-#include <boost/test/results_collector.hpp>
-#include <boost/test/detail/unit_test_parameters.hpp>
-
-// Boost
-#include <boost/timer.hpp>
-
-// STL
-#include <algorithm>
-#include <vector>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-#if BOOST_WORKAROUND(__BORLANDC__, < 0x600) && \
-    BOOST_WORKAROUND(_STLPORT_VERSION, <= 0x450) \
-    /**/
-    using std::rand; // rand is in std and random_shuffle is in _STL
-#endif
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                   test_unit                  ************** //
-// ************************************************************************** //
-
-test_unit::test_unit( const_string name, test_unit_type t )
-: p_type( t )
-, p_type_name( t == tut_case ? "case" : "suite" )
-, p_id( INV_TEST_UNIT_ID )
-, p_name( std::string( name.begin(), name.size() ) )
-, p_enabled( true )
-{
-}
-
-//____________________________________________________________________________//
-
-test_unit::~test_unit()
-{
-    framework::deregister_test_unit( this );
-}
-
-//____________________________________________________________________________//
-
-void
-test_unit::depends_on( test_unit* tu )
-{
-    m_dependencies.push_back( tu->p_id );
-}
-
-//____________________________________________________________________________//
-
-bool
-test_unit::check_dependencies() const
-{
-    BOOST_TEST_FOREACH( test_unit_id, tu_id, m_dependencies ) {
-        if( !unit_test::results_collector.results( tu_id ).passed() )
-            return false;
-    }
-
-    return true;
-}
-
-//____________________________________________________________________________//
-
-void
-test_unit::increase_exp_fail( unsigned num )
-{
-    p_expected_failures.value += num;
-
-    if( p_parent_id != 0 )
-        framework::get<test_suite>( p_parent_id ).increase_exp_fail( num );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                   test_case                  ************** //
-// ************************************************************************** //
-
-test_case::test_case( const_string name, callback0<> const& test_func )
-: test_unit( name, static_cast<test_unit_type>(type) )
-, m_test_func( test_func )
-{
-     // !! weirdest MSVC BUG; try to remove this statement; looks like it eats first token of next statement   
-#if BOOST_WORKAROUND(BOOST_MSVC,<1300)   
-     0;   
-#endif 
-    framework::register_test_unit( this );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  test_suite                  ************** //
-// ************************************************************************** //
-
-//____________________________________________________________________________//
-
-test_suite::test_suite( const_string name )
-: test_unit( name, static_cast<test_unit_type>(type) )
-{
-    framework::register_test_unit( this );
-}
-
-//____________________________________________________________________________//
-
-void
-test_suite::add( test_unit* tu, counter_t expected_failures, unsigned timeout )
-{
-    if( timeout != 0 )
-        tu->p_timeout.value = timeout;
-
-    m_members.push_back( tu->p_id );
-    tu->p_parent_id.value = p_id;
-
-    if( tu->p_expected_failures )
-        increase_exp_fail( tu->p_expected_failures );
-
-    if( expected_failures )
-        tu->increase_exp_fail( expected_failures );
-}
-
-//____________________________________________________________________________//
-
-void
-test_suite::add( test_unit_generator const& gen, unsigned timeout )
-{
-    test_unit* tu;
-    while((tu = gen.next(), tu))
-        add( tu, 0, timeout );
-}
-
-//____________________________________________________________________________//
-
-void
-test_suite::remove( test_unit_id id )
-{
-    std::vector<test_unit_id>::iterator it = std::find( m_members.begin(), m_members.end(), id );
-
-    if( it != m_members.end() )
-        m_members.erase( it );
-}
-
-//____________________________________________________________________________//
-
-test_unit_id
-test_suite::get( const_string tu_name ) const
-{
-    BOOST_TEST_FOREACH( test_unit_id, id, m_members ) {
-        if( tu_name == framework::get( id, ut_detail::test_id_2_unit_type( id ) ).p_name.get() )
-            return id;
-    }
-
-    return INV_TEST_UNIT_ID;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               traverse_test_tree             ************** //
-// ************************************************************************** //
-
-void
-traverse_test_tree( test_case const& tc, test_tree_visitor& V )
-{
-    if( tc.p_enabled )
-    V.visit( tc );
-}
-
-//____________________________________________________________________________//
-
-void
-traverse_test_tree( test_suite const& suite, test_tree_visitor& V )
-{
-    if( !suite.p_enabled || !V.test_suite_start( suite ) )
-        return;
-
-    try {
-        if( runtime_config::random_seed() == 0 ) {
-            BOOST_TEST_FOREACH( test_unit_id, id, suite.m_members )
-                traverse_test_tree( id, V );
-        }
-        else {
-            std::vector<test_unit_id> members( suite.m_members );
-            std::random_shuffle( members.begin(), members.end() );
-            BOOST_TEST_FOREACH( test_unit_id, id, members )
-                traverse_test_tree( id, V );
-        }
-        
-    } catch( test_being_aborted const& ) {
-        V.test_suite_finish( suite );
-        framework::test_unit_aborted( suite );
-
-        throw;
-    }
-
-    V.test_suite_finish( suite );
-}
-
-//____________________________________________________________________________//
-
-void
-traverse_test_tree( test_unit_id id, test_tree_visitor& V )
-{
-    if( ut_detail::test_id_2_unit_type( id ) == tut_case )
-        traverse_test_tree( framework::get<test_case>( id ), V );
-    else
-        traverse_test_tree( framework::get<test_suite>( id ), V );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                test_case_counter             ************** //
-// ************************************************************************** //
-
-void
-test_case_counter::visit( test_case const& tc )
-{
-    if( tc.p_enabled )
-        ++p_count.value;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               object generators              ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-std::string
-normalize_test_case_name( const_string name )
-{
-    return ( name[0] == '&'
-                ? std::string( name.begin()+1, name.size()-1 )
-                : std::string( name.begin(), name.size() ) );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************           auto_test_unit_registrar           ************** //
-// ************************************************************************** //
-
-auto_test_unit_registrar::auto_test_unit_registrar( test_case* tc, counter_t exp_fail )
-{
-    curr_ts_store().back()->add( tc, exp_fail );
-}
-
-//____________________________________________________________________________//
-
-auto_test_unit_registrar::auto_test_unit_registrar( const_string ts_name )
-{
-    test_unit_id id = curr_ts_store().back()->get( ts_name );
-
-    test_suite* ts;
-
-    if( id != INV_TEST_UNIT_ID ) {
-        ts = &framework::get<test_suite>( id ); // !! test for invalid tu type
-        BOOST_ASSERT( ts->p_parent_id == curr_ts_store().back()->p_id );
-    }
-    else {
-        ts = new test_suite( ts_name );
-        curr_ts_store().back()->add( ts );
-    }
-
-    curr_ts_store().push_back( ts );
-}
-
-//____________________________________________________________________________//
-
-auto_test_unit_registrar::auto_test_unit_registrar( test_unit_generator const& tc_gen )
-{
-    curr_ts_store().back()->add( tc_gen );
-}
-
-//____________________________________________________________________________//
-
-auto_test_unit_registrar::auto_test_unit_registrar( int )
-{
-    if( curr_ts_store().size() == 0 )
-        return; // report error?
-
-    curr_ts_store().pop_back();
-}
-
-//____________________________________________________________________________//
-
-std::list<test_suite*>&
-auto_test_unit_registrar::curr_ts_store()
-{
-    static std::list<test_suite*> inst( 1, &framework::master_test_suite() );
-    return inst;
-}
-
-//____________________________________________________________________________//
-
-} // namespace ut_detail
-
-// ************************************************************************** //
-// **************                global_fixture                ************** //
-// ************************************************************************** //
-
-global_fixture::global_fixture()
-{
-    framework::register_observer( *this );
-} 
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_SUITE_IPP_012205GER
diff --git a/contrib/autoboost/boost/test/impl/xml_log_formatter.ipp b/contrib/autoboost/boost/test/impl/xml_log_formatter.ipp
deleted file mode 100644
index 7a33766ad..000000000
--- a/contrib/autoboost/boost/test/impl/xml_log_formatter.ipp
+++ /dev/null
@@ -1,180 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : implements XML Log formatter
-// ***************************************************************************
-
-#ifndef BOOST_TEST_XML_LOG_FORMATTER_IPP_020105GER
-#define BOOST_TEST_XML_LOG_FORMATTER_IPP_020105GER
-
-// Boost.Test
-#include <boost/test/output/xml_log_formatter.hpp>
-#include <boost/test/unit_test_suite_impl.hpp>
-#include <boost/test/framework.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-
-#include <boost/test/utils/xml_printer.hpp>
-
-// Boost
-#include <boost/version.hpp>
-
-// STL
-#include <iostream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-namespace output {
-
-static const_string tu_type_name( test_unit const& tu )
-{
-    return tu.p_type == tut_case ? "TestCase" : "TestSuite";
-}
-
-// ************************************************************************** //
-// **************               xml_log_formatter              ************** //
-// ************************************************************************** //
-
-void
-xml_log_formatter::log_start( std::ostream& ostr, counter_t )
-{
-    ostr  << "<TestLog>";
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::log_finish( std::ostream& ostr )
-{
-    ostr  << "</TestLog>";
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::log_build_info( std::ostream& ostr )
-{
-    ostr  << "<BuildInfo"
-            << " platform"  << attr_value() << BOOST_PLATFORM
-            << " compiler"  << attr_value() << BOOST_COMPILER
-            << " stl"       << attr_value() << BOOST_STDLIB
-            << " boost=\""  << BOOST_VERSION/100000     << "."
-                            << BOOST_VERSION/100 % 1000 << "."
-                            << BOOST_VERSION % 100      << '\"'
-            << "/>";
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::test_unit_start( std::ostream& ostr, test_unit const& tu )
-{
-    ostr << "<" << tu_type_name( tu ) << " name" << attr_value() << tu.p_name.get() << ">";
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::test_unit_finish( std::ostream& ostr, test_unit const& tu, unsigned long elapsed )
-{
-    if( tu.p_type == tut_case )
-        ostr << "<TestingTime>" << elapsed << "</TestingTime>";
-        
-    ostr << "</" << tu_type_name( tu ) << ">";
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::test_unit_skipped( std::ostream& ostr, test_unit const& tu )
-{
-    ostr << "<" << tu_type_name( tu )
-         << " name"    << attr_value() << tu.p_name.get()
-         << " skipped" << attr_value() << "yes"
-         << "/>";
-}
-    
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::log_exception( std::ostream& ostr, log_checkpoint_data const& checkpoint_data, execution_exception const& ex )
-{
-    execution_exception::location const& loc = ex.where();
-
-    ostr << "<Exception file" << attr_value() << loc.m_file_name
-         << " line"           << attr_value() << loc.m_line_num;
-
-    if( !loc.m_function.is_empty() )
-        ostr << " function"   << attr_value() << loc.m_function;
-
-    ostr << ">" << cdata() << ex.what();
-
-    if( !checkpoint_data.m_file_name.is_empty() ) {
-        ostr << "<LastCheckpoint file" << attr_value() << checkpoint_data.m_file_name
-             << " line"                << attr_value() << checkpoint_data.m_line_num
-             << ">"
-             << cdata() << checkpoint_data.m_message
-             << "</LastCheckpoint>";
-    }
-
-    ostr << "</Exception>";
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::log_entry_start( std::ostream& ostr, log_entry_data const& entry_data, log_entry_types let )
-{
-    static literal_string xml_tags[] = { "Info", "Message", "Warning", "Error", "FatalError" };
-
-    m_curr_tag = xml_tags[let];
-    ostr << '<' << m_curr_tag
-         << BOOST_TEST_L( " file" ) << attr_value() << entry_data.m_file_name
-         << BOOST_TEST_L( " line" ) << attr_value() << entry_data.m_line_num
-         << BOOST_TEST_L( "><![CDATA[" );
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::log_entry_value( std::ostream& ostr, const_string value )
-{
-    ostr << value;
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::log_entry_finish( std::ostream& ostr )
-{
-    ostr << BOOST_TEST_L( "]]></" ) << m_curr_tag << BOOST_TEST_L( ">" );
-
-    m_curr_tag.clear();
-}
-
-//____________________________________________________________________________//
-
-} // namespace output
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_XML_LOG_FORMATTER_IPP_020105GER
diff --git a/contrib/autoboost/boost/test/impl/xml_report_formatter.ipp b/contrib/autoboost/boost/test/impl/xml_report_formatter.ipp
deleted file mode 100644
index 37fa6593b..000000000
--- a/contrib/autoboost/boost/test/impl/xml_report_formatter.ipp
+++ /dev/null
@@ -1,115 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : XML report formatter
-// ***************************************************************************
-
-#ifndef BOOST_TEST_XML_REPORT_FORMATTER_IPP_020105GER
-#define BOOST_TEST_XML_REPORT_FORMATTER_IPP_020105GER
-
-// Boost.Test
-#include <boost/test/results_collector.hpp>
-#include <boost/test/unit_test_suite_impl.hpp>
-#include <boost/test/output/xml_report_formatter.hpp>
-
-#include <boost/test/utils/xml_printer.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-namespace output {
-
-void
-xml_report_formatter::results_report_start( std::ostream& ostr )
-{
-    ostr << "<TestResult>";
-}
-
-//____________________________________________________________________________//
-
-void
-xml_report_formatter::results_report_finish( std::ostream& ostr )
-{
-    ostr << "</TestResult>";
-}
-
-
-//____________________________________________________________________________//
-
-void
-xml_report_formatter::test_unit_report_start( test_unit const& tu, std::ostream& ostr )
-{
-    test_results const& tr = results_collector.results( tu.p_id );
-
-    const_string descr;
-
-    if( tr.passed() )
-        descr = "passed";
-    else if( tr.p_skipped )
-        descr = "skipped";
-    else if( tr.p_aborted )
-        descr = "aborted";
-    else
-        descr = "failed";
-
-    ostr << '<' << ( tu.p_type == tut_case ? "TestCase" : "TestSuite" ) 
-         << " name"     << attr_value() << tu.p_name.get()
-         << " result"   << attr_value() << descr
-         << " assertions_passed"        << attr_value() << tr.p_assertions_passed
-         << " assertions_failed"        << attr_value() << tr.p_assertions_failed
-         << " expected_failures"        << attr_value() << tr.p_expected_failures;
-
-    if( tu.p_type == tut_suite )
-        ostr << " test_cases_passed"    << attr_value() << tr.p_test_cases_passed
-             << " test_cases_failed"    << attr_value() << tr.p_test_cases_failed
-             << " test_cases_skipped"   << attr_value() << tr.p_test_cases_skipped
-             << " test_cases_aborted"   << attr_value() << tr.p_test_cases_aborted;
-             
-    
-    ostr << '>';
-}
-
-//____________________________________________________________________________//
-
-void
-xml_report_formatter::test_unit_report_finish( test_unit const& tu, std::ostream& ostr )
-{
-    ostr << "</" << ( tu.p_type == tut_case ? "TestCase" : "TestSuite" ) << '>';
-}
-
-//____________________________________________________________________________//
-
-void
-xml_report_formatter::do_confirmation_report( test_unit const& tu, std::ostream& ostr )
-{
-    test_unit_report_start( tu, ostr );
-    test_unit_report_finish( tu, ostr );    
-}
-
-//____________________________________________________________________________//
-
-} // namespace output
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_XML_REPORT_FORMATTER_IPP_020105GER
diff --git a/contrib/autoboost/boost/test/interaction_based.hpp b/contrib/autoboost/boost/test/interaction_based.hpp
deleted file mode 100644
index a4523b20b..000000000
--- a/contrib/autoboost/boost/test/interaction_based.hpp
+++ /dev/null
@@ -1,262 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : Facilities to perform interaction-based testing
-// ***************************************************************************
-
-#ifndef BOOST_TEST_INTERACTION_BASED_HPP_112105GER
-#define BOOST_TEST_INTERACTION_BASED_HPP_112105GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/detail/global_typedef.hpp>
-
-#include <boost/test/utils/wrap_stringstream.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-// Boost
-#include <boost/lexical_cast.hpp>
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               BOOST_ITEST_EPOINT             ************** //
-// ************************************************************************** //
-
-#define BOOST_ITEST_EPOINT( description ) \
-    ::autoboost::itest::manager::instance().exception_point( BOOST_TEST_L(__FILE__), __LINE__, description )
-/**/
-
-// ************************************************************************** //
-// **************               BOOST_ITEST_DPOINT             ************** //
-// ************************************************************************** //
-
-#define BOOST_ITEST_DPOINT() \
-    ::autoboost::itest::manager::instance().decision_point( BOOST_TEST_L(__FILE__), __LINE__ )
-/**/
-
-// ************************************************************************** //
-// **************                BOOST_ITEST_SCOPE             ************** //
-// ************************************************************************** //
-
-#define BOOST_ITEST_SCOPE( scope_name ) \
-    ::autoboost::itest::scope_guard itest_scope_guard ## __LINE__( BOOST_TEST_L(__FILE__), __LINE__, BOOST_STRINGIZE(scope_name) )
-/**/
-
-// ************************************************************************** //
-// **************                 BOOST_ITEST_NEW              ************** //
-// ************************************************************************** //
-
-#define BOOST_ITEST_NEW( type_name ) \
-    new ( ::autoboost::itest::location( BOOST_TEST_L(__FILE__), __LINE__ ) ) type_name
-/**/
-
-// ************************************************************************** //
-// **************              BOOST_ITEST_DATA_FLOW           ************** //
-// ************************************************************************** //
-
-#define BOOST_ITEST_DATA_FLOW( v ) \
-    ::autoboost::itest::manager::instance().generic_data_flow( v )
-/**/
-
-// ************************************************************************** //
-// **************               BOOST_ITEST_RETURN             ************** //
-// ************************************************************************** //
-
-#define BOOST_ITEST_RETURN( type, default_value ) \
-    ::autoboost::itest::manager::instance().generic_return<type>( default_value )
-/**/
-
-// ************************************************************************** //
-// **************              BOOST_ITEST_MOCK_FUNC           ************** //
-// ************************************************************************** //
-
-#define BOOST_ITEST_MOCK_FUNC( function_name )          \
-    BOOST_ITEST_SCOPE( function_name );                 \
-    BOOST_ITEST_EPOINT( 0 );                            \
-    return ::autoboost::itest::mock_object<>::prototype();  \
-/**/
-
-namespace autoboost {
-
-namespace itest { // interaction-based testing
-
-using unit_test::const_string;
-
-// ************************************************************************** //
-// **************                    manager                   ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL manager {
-public:
-    // instance access
-    static manager&     instance() { return *instance_ptr(); }
-
-    // Mock objects interface hooks
-    virtual void        exception_point( const_string /*file*/, 
-                                         std::size_t /*line_num*/, 
-                                         const_string /*descr*/ ){}
-    virtual bool        decision_point( const_string /*file*/, 
-                                        std::size_t /*line_num*/ )          { return true; }
-    virtual unsigned    enter_scope( const_string /*file*/, 
-                                     std::size_t /*line_num*/,
-                                     const_string /*scope_name*/){ return 0; }
-    virtual void        leave_scope( unsigned )                             {}
-    virtual void        allocated( const_string /*file*/, 
-                                   std::size_t /*line_num*/, 
-                                   void* /*p*/, std::size_t /*s*/ )         {}
-    virtual void        freed( void* /*p*/ )                                {}
-    virtual void        data_flow( const_string /*d*/ )                     {}
-    virtual std::string return_value( const_string /*default_value */ )     { return ""; }
-
-    template<typename T>
-    void                generic_data_flow( T const& t )
-    {
-        wrap_stringstream ws;
-
-        data_flow( (ws << t).str() );
-    }
-    template<typename T, typename DefaultValueType>
-    T                   generic_return( DefaultValueType const& dv )
-    {
-        wrap_stringstream ws;
-
-        std::string const& res = return_value( (ws << dv).str() );
-
-        if( res.empty() )
-            return dv;
-
-        return lexical_cast<T>( res );
-    }
-
-protected:
-    manager();
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) 
-public:
-#endif
-    BOOST_TEST_PROTECTED_VIRTUAL ~manager();
-
-private:
-    struct dummy_constr{};
-    explicit manager( dummy_constr* ) {}
-
-    static manager*     instance_ptr( bool reset = false, manager* ptr = 0 );
-}; // manager
-
-// ************************************************************************** //
-// **************                  scope_guard                 ************** //
-// ************************************************************************** //
-
-class scope_guard {
-public:
-    // Constructor
-    scope_guard( const_string file, std::size_t line_num, const_string scope_name )
-    {
-        m_scope_index = manager::instance().enter_scope( file, line_num, scope_name );
-    }
-    ~scope_guard()
-    {
-        manager::instance().leave_scope( m_scope_index );
-    }
-
-    unsigned m_scope_index;
-};
-
-// ************************************************************************** //
-// **************                    location                  ************** //
-// ************************************************************************** //
-
-struct location {
-    location( const_string file, std::size_t line ) 
-    : m_file_name( file )
-    , m_line_num( line )
-    {}
-
-    const_string    m_file_name;
-    std::size_t     m_line_num;
-};
-
-}  // namespace itest
-
-} // namespace autoboost
-
-// ************************************************************************** //
-// **************              operator new overload           ************** //
-// ************************************************************************** //
-
-#if !defined(BOOST_ITEST_NO_NEW_OVERLOADS)
-
-// STL
-#include <cstdlib>
-
-# ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::malloc; using ::free; }
-# endif
-# ifdef _CRTDBG_MAP_ALLOC
-namespace std { using ::_malloc_dbg; using ::_free_dbg; }
-# endif
-
-inline void*
-operator new( std::size_t s, ::autoboost::itest::location const& l )
-{
-    void* res = std::malloc(s ? s : 1);
-
-    if( res )
-        ::autoboost::itest::manager::instance().allocated( l.m_file_name, l.m_line_num, res, s );
-    else
-        throw std::bad_alloc();
-        
-    return res;
-}
-
-//____________________________________________________________________________//
-
-inline void*
-operator new[]( std::size_t s, ::autoboost::itest::location const& l )
-{
-    void* res = std::malloc(s ? s : 1);
-
-    if( res )
-        ::autoboost::itest::manager::instance().allocated( l.m_file_name, l.m_line_num, res, s );
-    else
-        throw std::bad_alloc();
-        
-    return res;
-}
-
-//____________________________________________________________________________//
-
-inline void
-operator delete( void* p, ::autoboost::itest::location const& )
-{
-    ::autoboost::itest::manager::instance().freed( p );
-
-    std::free( p );
-}
-
-//____________________________________________________________________________//
-
-inline void
-operator delete[]( void* p, ::autoboost::itest::location const& )
-{
-    ::autoboost::itest::manager::instance().freed( p );
-
-    std::free( p );
-}
-
-//____________________________________________________________________________//
-
-#endif
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_INTERACTION_BASED_HPP_112105GER
diff --git a/contrib/autoboost/boost/test/mock_object.hpp b/contrib/autoboost/boost/test/mock_object.hpp
deleted file mode 100644
index 5ffb4f1fc..000000000
--- a/contrib/autoboost/boost/test/mock_object.hpp
+++ /dev/null
@@ -1,328 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : Facilities to perform exception safety_tests
-// ***************************************************************************
-
-#ifndef BOOST_TEST_MOCK_OBJECT_HPP_112205GER
-#define BOOST_TEST_MOCK_OBJECT_HPP_112205GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/interaction_based.hpp>
-
-// Boost
-#include <boost/preprocessor/punctuation/comma.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace itest {
-
-// ************************************************************************** //
-// **************                mock_object_base              ************** //
-// ************************************************************************** //
-
-class mock_object_base {
-public:
-    mock_object_base() {}
-
-    template<typename T1>
-    mock_object_base( T1 const& ) {}
-
-    template<typename T1, typename T2>
-    mock_object_base( T1 const&, T2 const& ) {}
-
-    template<typename T1, typename T2, typename T3>
-    mock_object_base( T1 const&, T2 const&, T3 const& ) {}
-
-    template<typename T1, typename T2, typename T3, typename T4>
-    mock_object_base( T1 const&, T2 const&, T3 const&, T4 const& ) {}
-
-    template<typename T1, typename T2, typename T3, typename T4, typename T5>
-    mock_object_base( T1 const&, T2 const&, T3 const&, T4 const&, T5 const& ) {}
-};
-
-// ************************************************************************** //
-// **************      mock_object implementation helpers      ************** //
-// ************************************************************************** //
-
-#define MO_OP_IMPL( op, descr, ret )                        \
-    BOOST_ITEST_SCOPE( mock_object::operator op );          \
-    BOOST_ITEST_EPOINT( descr );                            \
-    return ret                                              \
-/**/
-
-#define MO_UNARY_OP( op, descr )                            \
-self_type const& operator op() const                        \
-{                                                           \
-    MO_OP_IMPL( op, descr, prototype() );                   \
-}                                                           \
-/**/
-
-#define MO_UNARY_BOOL_OP( op, descr )                       \
-bool operator op() const                                    \
-{                                                           \
-    MO_OP_IMPL( op, descr, (!!BOOST_ITEST_DPOINT()) );      \
-}                                                           \
-/**/
-
-#define MO_BINARY_OP( op, descr )                           \
-template<int i1, typename Base1,int i2, typename Base2>     \
-inline mock_object<i1,Base1> const&                         \
-operator op( mock_object<i1,Base1> const& mo,               \
-             mock_object<i2,Base2> const& )                 \
-{                                                           \
-    MO_OP_IMPL( op, descr, mo );                            \
-}                                                           \
-                                                            \
-template<int i, typename Base, typename T>                  \
-inline mock_object<i,Base> const&                           \
-operator op( mock_object<i,Base> const& mo, T const& )      \
-{                                                           \
-    MO_OP_IMPL( op, descr, mo );                            \
-}                                                           \
-                                                            \
-template<int i, typename Base, typename T>                  \
-inline mock_object<i,Base> const&                           \
-operator op( T const&, mock_object<i,Base> const& mo )      \
-{                                                           \
-    MO_OP_IMPL( op, descr, mo );                            \
-}                                                           \
-/**/
-
-#define MO_BINARY_BOOL_OP( op, descr )                      \
-template<int i1, typename Base1,int i2, typename Base2>     \
-inline bool                                                 \
-operator op( mock_object<i1,Base1> const&,                  \
-             mock_object<i2,Base2> const& )                 \
-{                                                           \
-    MO_OP_IMPL( op, descr, BOOST_ITEST_DPOINT() );          \
-}                                                           \
-                                                            \
-template<int i, typename Base, typename T>                  \
-inline bool                                                 \
-operator op( mock_object<i,Base> const&, T const& )         \
-{                                                           \
-    MO_OP_IMPL( op, descr, BOOST_ITEST_DPOINT() );          \
-}                                                           \
-                                                            \
-template<int i, typename Base, typename T>                  \
-inline bool                                                 \
-operator op( T const&, mock_object<i,Base> const& )         \
-{                                                           \
-    MO_OP_IMPL( op, descr, BOOST_ITEST_DPOINT() );          \
-}                                                           \
-/**/
-
-// ************************************************************************** //
-// **************                  mock_object                 ************** //
-// ************************************************************************** //
-
-template<int i = 0, typename Base=mock_object_base>
-class mock_object;
-
-template<int i, typename Base>
-class mock_object : public Base {
-    // Private typeefs
-    typedef mock_object<i,Base> self_type;
-    struct dummy { void nonnull() {}; };
-    typedef void (dummy::*safe_bool)();
-
-    // prototype constructor
-    mock_object( dummy* ) {}
-
-public:
-    static mock_object& prototype()
-    {
-        static mock_object p( reinterpret_cast<dummy*>(0) ); 
-        return p;
-    }
-
-    // Constructors
-    mock_object()
-    {
-        BOOST_ITEST_SCOPE( mock_object::mock_object );
-        BOOST_ITEST_EPOINT( "Mock object default constructor" );
-    }
-
-    template<typename T1>
-    mock_object( T1 const& arg1 )
-    : mock_object_base( arg1 )
-    {
-        BOOST_ITEST_SCOPE( mock_object::mock_object );
-        BOOST_ITEST_EPOINT( "Mock object constructor" );
-    }
-
-    template<typename T1, typename T2>
-    mock_object( T1 const& arg1, T2 const& arg2 )
-    : mock_object_base( arg1, arg2 )
-    {
-        BOOST_ITEST_SCOPE( mock_object::mock_object );
-        BOOST_ITEST_EPOINT( "Mock object constructor" );
-    }
-
-    template<typename T1, typename T2, typename T3>
-    mock_object( T1 const& arg1, T2 const& arg2, T3 const& arg3 )
-    : mock_object_base( arg1, arg2, arg3 )
-    {
-        BOOST_ITEST_SCOPE( mock_object::mock_object );
-        BOOST_ITEST_EPOINT( "Mock object constructor" );
-    }
-
-    template<typename T1, typename T2, typename T3, typename T4>
-    mock_object( T1 const& arg1, T2 const& arg2, T3 const& arg3, T4 const& arg4 )
-    : mock_object_base( arg1, arg2, arg3, arg4 )
-    {
-        BOOST_ITEST_SCOPE( mock_object::mock_object );
-        BOOST_ITEST_EPOINT( "Mock object constructor" );
-    }
-
-    template<typename T1, typename T2, typename T3, typename T4, typename T5>
-    mock_object( T1 const& arg1, T2 const& arg2, T3 const& arg3, T4 const& arg4, T5 const& arg5 )
-    : mock_object_base( arg1, arg2, arg3, arg4, arg5 )
-    {
-        BOOST_ITEST_SCOPE( mock_object::mock_object );
-        BOOST_ITEST_EPOINT( "Mock object constructor" );
-    }
-
-    mock_object( mock_object const& )
-    {
-        BOOST_ITEST_SCOPE( mock_object::mock_object );
-        BOOST_ITEST_EPOINT( "Mock object copy constructor" );
-    }
-
-    // assignment
-    self_type const&    operator =( mock_object const& ) const
-    {
-        MO_OP_IMPL( =, "Copy assignment", prototype() );
-    }
-
-    template <typename T>
-    self_type const&    operator =( T const& ) const
-    {
-        MO_OP_IMPL( =, "Copy assignment", prototype() );
-    }
-
-    // Unary operators
-    MO_UNARY_BOOL_OP( !, "Logical NOT operator" )
-    MO_UNARY_OP( &, "Address-of operator" )
-    MO_UNARY_OP( ~, "One's complement operator" )
-    MO_UNARY_OP( *, "Pointer dereference" )
-    MO_UNARY_OP( +, "Unary plus" )
-
-    // Increment and Decrement
-    MO_UNARY_OP( ++, "Prefix increment" )
-    MO_UNARY_OP( --, "Prefix decrement" )
-    self_type const&    operator ++(int) const
-    {
-        MO_OP_IMPL( ++, "Postfix increment", prototype() );
-    }
-    self_type const&    operator --(int) const
-    {
-        MO_OP_IMPL( --, "Postfix decrement", prototype() );
-    }
-
-    // Bool context convertion
-    operator safe_bool() const
-    {
-        MO_OP_IMPL( safe_bool, "Bool context conversion",
-                    (BOOST_ITEST_DPOINT() ? 0 : &dummy::nonnull) );
-    }
-
-    // Function-call operators
-    self_type const&    operator ()() const
-    {
-        MO_OP_IMPL( (), "0-arity function-call", prototype() );
-    }
-    template<typename T1>
-    self_type const&    operator ()( T1 const& arg1 ) const
-    {
-        MO_OP_IMPL( (), "1-arity function-call", prototype() );
-    }
-    template<typename T1, typename T2>
-    self_type const&    operator ()( T1 const&, T2 const& ) const
-    {
-        MO_OP_IMPL( (), "2-arity function-call", prototype() );
-    }
-    template<typename T1, typename T2, typename T3>
-    self_type const&    operator ()( T1 const&, T2 const&, T3 const& ) const
-    {
-        MO_OP_IMPL( (), "3-arity function-call", prototype() );
-    }
-    template<typename T1, typename T2, typename T3, typename T4>
-    self_type const&    operator ()( T1 const&, T2 const&, T3 const&, T4 const& ) const
-    {
-        MO_OP_IMPL( (), "4-arity function-call", prototype() );
-    }
-    template<typename T1, typename T2, typename T3, typename T4, typename T5>
-    self_type const&    operator ()( T1 const&, T2 const&, T3 const&, T4 const&, T5 const& ) const
-    {
-        MO_OP_IMPL( (), "5-arity function-call", prototype() );
-    }
-
-    // Substripting
-    template<typename T>
-    self_type const&    operator []( T const& ) const
-    {
-        MO_OP_IMPL( [], "Substripting", prototype() );
-    }
-
-    // Class member access
-    self_type const*    operator->() const
-    {
-        MO_OP_IMPL( ->, "Class member access", this );
-    }
-};
-
-// !! MO_BINARY_OP( BOOST_PP_COMMA(), "Comma operator" )
-
-MO_BINARY_BOOL_OP( !=, "Inequality" )
-MO_BINARY_OP( %, "Modulus" )
-MO_BINARY_OP( %=, "Modulus/assignment" )
-MO_BINARY_OP( &, "Bitwise AND" )
-MO_BINARY_BOOL_OP( &&, "Logical AND" )
-MO_BINARY_OP( &=, "Bitwise AND/assignment" )
-MO_BINARY_OP( *, "Multiplication" )
-MO_BINARY_OP( *=, "Multiplication/assignment" )
-MO_BINARY_OP( +, "Addition" )
-MO_BINARY_OP( +=, "Addition/assignment" )
-//MO_BINARY_OP( -, "Subtraction" )
-MO_BINARY_OP( -=, "Subtraction/assignment" )
-MO_BINARY_OP( ->*, "Pointer-to-member selection" )
-MO_BINARY_OP( /, "Division" )
-MO_BINARY_OP( /=, "Division/assignment" )
-MO_BINARY_BOOL_OP( <, "Less than" )
-MO_BINARY_OP( <<=, "Left shift/assignment" )
-MO_BINARY_BOOL_OP( <=, "Less than or equal to" )
-MO_BINARY_BOOL_OP( ==, "Equality" )
-MO_BINARY_BOOL_OP( >, "Greater than" )
-MO_BINARY_BOOL_OP( >=, "Greater than or equal to" )
-MO_BINARY_OP( >>=, "Right shift/assignment" )
-MO_BINARY_OP( ^, "Exclusive OR" )
-MO_BINARY_OP( ^=, "Exclusive OR/assignment" )
-MO_BINARY_OP( |, "Bitwise inclusive OR" )
-MO_BINARY_OP( |=, "Bitwise inclusive OR/assignment" )
-MO_BINARY_BOOL_OP( ||, "Logical OR" )
-
-MO_BINARY_OP( <<, "Left shift" )
-MO_BINARY_OP( >>, "Right shift" )
-
-} // namespace itest
-
-} // namespace autoboost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_MOCK_OBJECT_HPP_112205GER
diff --git a/contrib/autoboost/boost/test/output/compiler_log_formatter.hpp b/contrib/autoboost/boost/test/output/compiler_log_formatter.hpp
deleted file mode 100644
index 8a7393ca0..000000000
--- a/contrib/autoboost/boost/test/output/compiler_log_formatter.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : contains compiler like Log formatter definition
-// ***************************************************************************
-
-#ifndef BOOST_TEST_COMPILER_LOG_FORMATTER_HPP_020105GER
-#define BOOST_TEST_COMPILER_LOG_FORMATTER_HPP_020105GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/unit_test_log_formatter.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-namespace output {
-
-// ************************************************************************** //
-// **************             compiler_log_formatter           ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL compiler_log_formatter : public unit_test_log_formatter {
-public:
-    // Formatter interface
-    void    log_start( std::ostream&, counter_t test_cases_amount );
-    void    log_finish( std::ostream& );
-    void    log_build_info( std::ostream& );
-
-    void    test_unit_start( std::ostream&, test_unit const& tu );
-    void    test_unit_finish( std::ostream&, test_unit const& tu, unsigned long elapsed );
-    void    test_unit_skipped( std::ostream&, test_unit const& tu );
-
-    void    log_exception( std::ostream&, log_checkpoint_data const&, execution_exception const& ex );
-
-    void    log_entry_start( std::ostream&, log_entry_data const&, log_entry_types let );
-    void    log_entry_value( std::ostream&, const_string value );
-    void    log_entry_value( std::ostream&, lazy_ostream const& value );
-    void    log_entry_finish( std::ostream& );
-
-protected:
-    virtual void    print_prefix( std::ostream&, const_string file, std::size_t line );
-};
-
-} // namespace output
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_COMPILER_LOG_FORMATTER_HPP_020105GER
diff --git a/contrib/autoboost/boost/test/output/plain_report_formatter.hpp b/contrib/autoboost/boost/test/output/plain_report_formatter.hpp
deleted file mode 100644
index 677e5107c..000000000
--- a/contrib/autoboost/boost/test/output/plain_report_formatter.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : plain report formatter implementation
-// ***************************************************************************
-
-#ifndef BOOST_TEST_PLAIN_REPORT_FORMATTER_HPP_020105GER
-#define BOOST_TEST_PLAIN_REPORT_FORMATTER_HPP_020105GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/results_reporter.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-namespace output {
-
-// ************************************************************************** //
-// **************             plain_report_formatter           ************** //
-// ************************************************************************** //
-
-class plain_report_formatter : public results_reporter::format {
-public:
-    // Formatter interface
-    void    results_report_start( std::ostream& ostr );
-    void    results_report_finish( std::ostream& ostr );
-
-    void    test_unit_report_start( test_unit const&, std::ostream& ostr );
-    void    test_unit_report_finish( test_unit const&, std::ostream& ostr );
-
-    void    do_confirmation_report( test_unit const&, std::ostream& ostr );
-
-private:
-    // Data members
-    counter_t m_indent;
-};
-
-} // namespace output
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_PLAIN_REPORT_FORMATTER_HPP_020105GER
diff --git a/contrib/autoboost/boost/test/output/xml_log_formatter.hpp b/contrib/autoboost/boost/test/output/xml_log_formatter.hpp
deleted file mode 100644
index a74309ee3..000000000
--- a/contrib/autoboost/boost/test/output/xml_log_formatter.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : contains XML Log formatter definition
-// ***************************************************************************
-
-#ifndef BOOST_TEST_XML_LOG_FORMATTER_020105GER
-#define BOOST_TEST_XML_LOG_FORMATTER_020105GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/unit_test_log_formatter.hpp>
-
-// STL
-#include <cstddef> // std::size_t
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-namespace output {
-
-// ************************************************************************** //
-// **************               xml_log_formatter              ************** //
-// ************************************************************************** //
-
-class xml_log_formatter : public unit_test_log_formatter {
-public:
-    // Formatter interface
-    void    log_start( std::ostream&, counter_t test_cases_amount );
-    void    log_finish( std::ostream& );
-    void    log_build_info( std::ostream& );
-
-    void    test_unit_start( std::ostream&, test_unit const& tu );
-    void    test_unit_finish( std::ostream&, test_unit const& tu, unsigned long elapsed );
-    void    test_unit_skipped( std::ostream&, test_unit const& tu );
-
-    void    log_exception( std::ostream&, log_checkpoint_data const&, execution_exception const& ex );
-
-    void    log_entry_start( std::ostream&, log_entry_data const&, log_entry_types let );
-    using   unit_test_log_formatter::log_entry_value; // bring base class functions into overload set
-    void    log_entry_value( std::ostream&, const_string value );
-    void    log_entry_finish( std::ostream& );
-
-private:
-    // Data members
-    const_string    m_curr_tag;
-};
-
-} // namespace output
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_XML_LOG_FORMATTER_020105GER
diff --git a/contrib/autoboost/boost/test/output/xml_report_formatter.hpp b/contrib/autoboost/boost/test/output/xml_report_formatter.hpp
deleted file mode 100644
index 9a5c0fbb7..000000000
--- a/contrib/autoboost/boost/test/output/xml_report_formatter.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : XML report formatter implementation
-// ***************************************************************************
-
-#ifndef BOOST_TEST_XML_REPORT_FORMATTER_HPP_020105GER
-#define BOOST_TEST_XML_REPORT_FORMATTER_HPP_020105GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/results_reporter.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-namespace output {
-
-// ************************************************************************** //
-// **************              xml_report_formatter            ************** //
-// ************************************************************************** //
-
-class xml_report_formatter : public results_reporter::format {
-public:
-    // Formatter interface
-    void    results_report_start( std::ostream& ostr );
-    void    results_report_finish( std::ostream& ostr );
-
-    void    test_unit_report_start( test_unit const&, std::ostream& ostr );
-    void    test_unit_report_finish( test_unit const&, std::ostream& ostr );
-
-    void    do_confirmation_report( test_unit const&, std::ostream& ostr );
-};
-
-} // namespace output
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_XML_REPORT_FORMATTER_HPP_020105GER
diff --git a/contrib/autoboost/boost/test/output_test_stream.hpp b/contrib/autoboost/boost/test/output_test_stream.hpp
deleted file mode 100644
index 329756d1c..000000000
--- a/contrib/autoboost/boost/test/output_test_stream.hpp
+++ /dev/null
@@ -1,78 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : output_test_stream class definition
-// ***************************************************************************
-
-#ifndef BOOST_TEST_OUTPUT_TEST_STREAM_HPP_012705GER
-#define BOOST_TEST_OUTPUT_TEST_STREAM_HPP_012705GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/utils/wrap_stringstream.hpp>
-#include <boost/test/predicate_result.hpp>
-
-// STL
-#include <cstddef>          // for std::size_t
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               output_test_stream             ************** //
-// ************************************************************************** //
-
-// class to be used to simplify testing of ostream-based output operations
-
-namespace autoboost {
-
-namespace test_tools {
-
-class BOOST_TEST_DECL output_test_stream : public wrap_stringstream::wrapped_stream {
-    typedef unit_test::const_string const_string;
-    typedef predicate_result        result_type;
-public:
-    // Constructor
-    explicit        output_test_stream( const_string    pattern_file_name = const_string(),
-                                        bool            match_or_save     = true,
-                                        bool            text_or_binary    = true );
-
-    // Destructor
-    ~output_test_stream();
-
-    // checking function
-    result_type     is_empty( bool flush_stream = true );
-    result_type     check_length( std::size_t length, bool flush_stream = true );
-    result_type     is_equal( const_string arg_, bool flush_stream = true );
-    result_type     match_pattern( bool flush_stream = true );
-
-    // explicit flush
-    void            flush();
-
-private:
-    // helper functions
-    std::size_t     length();
-    void            sync();
-
-    struct Impl;
-    Impl*           m_pimpl;
-};
-
-} // namespace test_tools
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_OUTPUT_TEST_STREAM_HPP_012705GER
diff --git a/contrib/autoboost/boost/test/predicate_result.hpp b/contrib/autoboost/boost/test/predicate_result.hpp
deleted file mode 100644
index ff35e7752..000000000
--- a/contrib/autoboost/boost/test/predicate_result.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : enhanced result for test predicate that include message explaining failure
-// ***************************************************************************
-
-#ifndef BOOST_TEST_PREDICATE_RESULT_HPP_012705GER
-#define BOOST_TEST_PREDICATE_RESULT_HPP_012705GER
-
-// Boost.Test
-#include <boost/test/utils/class_properties.hpp>
-#include <boost/test/utils/wrap_stringstream.hpp>
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-
-// Boost
-#include <boost/shared_ptr.hpp>
-#include <boost/detail/workaround.hpp>
-
-// STL
-#include <cstddef>          // for std::size_t
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace test_tools {
-
-// ************************************************************************** //
-// **************                predicate_result              ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL predicate_result {
-    typedef unit_test::const_string      const_string;
-    struct dummy { void nonnull() {}; };
-    typedef void (dummy::*safe_bool)();
-
-public:
-    // Constructor
-    predicate_result( bool pv_ ) 
-    : p_predicate_value( pv_ )
-    {}
-
-    template<typename BoolConvertable>
-    predicate_result( BoolConvertable const& pv_ ) : p_predicate_value( !!pv_ ) {}
-
-    // Access methods
-    bool                operator!() const           { return !p_predicate_value; }
-    void                operator=( bool pv_ )       { p_predicate_value.value = pv_; }
-    operator            safe_bool() const           { return !!p_predicate_value ? &dummy::nonnull : 0; }
-
-    // Public properties
-    BOOST_READONLY_PROPERTY( bool, (predicate_result) ) p_predicate_value;
-
-    // Access methods
-    bool                has_empty_message() const   { return !m_message; }
-    wrap_stringstream&  message()
-    {
-        if( !m_message )
-            m_message.reset( new wrap_stringstream );
-
-        return *m_message;
-    }
-    const_string        message() const                   { return !m_message ? const_string() : const_string( m_message->str() ); }
-
-private:
-    // Data members
-    shared_ptr<wrap_stringstream> m_message;
-};
-
-} // namespace test_tools
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_PREDICATE_RESULT_HPP_012705GER
diff --git a/contrib/autoboost/boost/test/progress_monitor.hpp b/contrib/autoboost/boost/test/progress_monitor.hpp
deleted file mode 100644
index 6692d0766..000000000
--- a/contrib/autoboost/boost/test/progress_monitor.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines simple text based progress monitor
-// ***************************************************************************
-
-#ifndef BOOST_TEST_PROGRESS_MONITOR_HPP_020105GER
-#define BOOST_TEST_PROGRESS_MONITOR_HPP_020105GER
-
-// Boost.Test
-#include <boost/test/test_observer.hpp>
-#include <boost/test/utils/trivial_singleton.hpp>
-
-// STL
-#include <iosfwd>   // for std::ostream&
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                progress_monitor              ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL progress_monitor_t : public test_observer, public singleton<progress_monitor_t> {
-public:
-    // test observer interface
-    void    test_start( counter_t test_cases_amount );
-    void    test_finish() {}
-    void    test_aborted();
-
-    void    test_unit_start( test_unit const& ) {}
-    void    test_unit_finish( test_unit const&, unsigned long );
-    void    test_unit_skipped( test_unit const& );
-    void    test_unit_aborted( test_unit const& ) {}
-
-    void    assertion_result( bool ) {}
-    void    exception_caught( execution_exception const& ) {}
-
-    // configuration
-    void    set_stream( std::ostream& );
-
-private:
-    BOOST_TEST_SINGLETON_CONS( progress_monitor_t );
-}; // progress_monitor_t
-
-BOOST_TEST_SINGLETON_INST( progress_monitor )
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_PROGRESS_MONITOR_HPP_020105GER
-
diff --git a/contrib/autoboost/boost/test/results_collector.hpp b/contrib/autoboost/boost/test/results_collector.hpp
deleted file mode 100644
index 377270bba..000000000
--- a/contrib/autoboost/boost/test/results_collector.hpp
+++ /dev/null
@@ -1,112 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines class unit_test_result that is responsible for 
-//  gathering test results and presenting this information to end-user
-// ***************************************************************************
-
-#ifndef BOOST_TEST_RESULTS_COLLECTOR_HPP_071894GER
-#define BOOST_TEST_RESULTS_COLLECTOR_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/test_observer.hpp>
-
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-
-#include <boost/test/utils/trivial_singleton.hpp>
-#include <boost/test/utils/class_properties.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************      first failed assertion debugger hook    ************** //
-// ************************************************************************** //
-
-namespace {
-inline void first_failed_assertion() {}
-}
-
-// ************************************************************************** //
-// **************                 test_results                 ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL test_results {
-public:
-    test_results();
-
-    typedef BOOST_READONLY_PROPERTY( counter_t, (results_collector_t)(test_results)(results_collect_helper) ) counter_prop;
-    typedef BOOST_READONLY_PROPERTY( bool,      (results_collector_t)(test_results)(results_collect_helper) ) bool_prop;
-
-    counter_prop    p_assertions_passed;
-    counter_prop    p_assertions_failed;
-    counter_prop    p_expected_failures;
-    counter_prop    p_test_cases_passed;
-    counter_prop    p_test_cases_failed;
-    counter_prop    p_test_cases_skipped;
-    counter_prop    p_test_cases_aborted;
-    bool_prop       p_aborted;
-    bool_prop       p_skipped;
-
-    // "conclusion" methods
-    bool            passed() const;
-    int             result_code() const;
-
-    // collection helper
-    void            operator+=( test_results const& );
-
-    void            clear();
-};
-
-// ************************************************************************** //
-// **************               results_collector              ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL results_collector_t : public test_observer, public singleton<results_collector_t> {
-public:
-    // test_observer interface implementation
-    void                test_start( counter_t test_cases_amount );
-    void                test_finish();
-    void                test_aborted();
-
-    void                test_unit_start( test_unit const& );
-    void                test_unit_finish( test_unit const&, unsigned long elapsed );
-    void                test_unit_skipped( test_unit const& );
-    void                test_unit_aborted( test_unit const& );
-
-    void                assertion_result( bool passed );
-    void                exception_caught( execution_exception const& );
-
-    // results access
-    test_results const& results( test_unit_id ) const;
-
-private:
-    BOOST_TEST_SINGLETON_CONS( results_collector_t );
-};
-
-BOOST_TEST_SINGLETON_INST( results_collector )
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_RESULTS_COLLECTOR_HPP_071894GER
-
diff --git a/contrib/autoboost/boost/test/results_reporter.hpp b/contrib/autoboost/boost/test/results_reporter.hpp
deleted file mode 100644
index b567a2cb2..000000000
--- a/contrib/autoboost/boost/test/results_reporter.hpp
+++ /dev/null
@@ -1,88 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines class unit_test_result that is responsible for 
-//  gathering test results and presenting this information to end-user
-// ***************************************************************************
-
-#ifndef BOOST_TEST_RESULTS_REPORTER_HPP_021205GER
-#define BOOST_TEST_RESULTS_REPORTER_HPP_021205GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-
-// STL
-#include <iosfwd>   // for std::ostream&
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-namespace results_reporter {
-
-// ************************************************************************** //
-// **************              formatter interface             ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL format {
-public:
-    // Destructor
-    virtual ~format() {}
-
-    virtual void    results_report_start( std::ostream& ostr ) = 0;
-    virtual void    results_report_finish( std::ostream& ostr ) = 0;
-
-    virtual void    test_unit_report_start( test_unit const&, std::ostream& ostr ) = 0;
-    virtual void    test_unit_report_finish( test_unit const&, std::ostream& ostr ) = 0;
-
-    virtual void    do_confirmation_report( test_unit const&, std::ostream& ostr ) = 0;
-};
-
-// ************************************************************************** //
-// **************              report configuration            ************** //
-// ************************************************************************** //
-
-BOOST_TEST_DECL void    set_level( report_level );
-BOOST_TEST_DECL void    set_stream( std::ostream& );
-BOOST_TEST_DECL void    set_format( output_format );
-BOOST_TEST_DECL void    set_format( results_reporter::format* );
-
-BOOST_TEST_DECL std::ostream& get_stream();
-
-// ************************************************************************** //
-// **************               report initiation              ************** //
-// ************************************************************************** //
-
-BOOST_TEST_DECL void    make_report( report_level l = INV_REPORT_LEVEL, test_unit_id = INV_TEST_UNIT_ID );
-inline void             confirmation_report( test_unit_id id = INV_TEST_UNIT_ID )   
-{ make_report( CONFIRMATION_REPORT, id ); }
-inline void             short_report( test_unit_id id = INV_TEST_UNIT_ID )
-{ make_report( SHORT_REPORT, id ); }
-inline void             detailed_report( test_unit_id id = INV_TEST_UNIT_ID )
-{ make_report( DETAILED_REPORT, id ); }
-
-} // namespace results_reporter
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_RESULTS_REPORTER_HPP_021205GER
-
diff --git a/contrib/autoboost/boost/test/test_observer.hpp b/contrib/autoboost/boost/test/test_observer.hpp
deleted file mode 100644
index bae5f2753..000000000
--- a/contrib/autoboost/boost/test/test_observer.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines abstract interface for test observer
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TEST_OBSERVER_HPP_021005GER
-#define BOOST_TEST_TEST_OBSERVER_HPP_021005GER
-
-// Boost.Test
-#include <boost/test/detail/fwd_decl.hpp>
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/config.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                 test_observer                ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL test_observer {
-public:
-    // test observer interface
-    virtual void    test_start( counter_t /* test_cases_amount */ ) {}
-    virtual void    test_finish() {}
-    virtual void    test_aborted() {}
-
-    virtual void    test_unit_start( test_unit const& ) {}
-    virtual void    test_unit_finish( test_unit const&, unsigned long /* elapsed */ ) {}
-    virtual void    test_unit_skipped( test_unit const& ) {}
-    virtual void    test_unit_aborted( test_unit const& ) {}
-
-    virtual void    assertion_result( bool /* passed */ ) {}
-    virtual void    exception_caught( execution_exception const& ) {}
-
-    virtual int     priority() { return 0; }
-
-protected:
-    BOOST_TEST_PROTECTED_VIRTUAL ~test_observer() {}
-};
-
-} // unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TEST_OBSERVER_HPP_021005GER
-
diff --git a/contrib/autoboost/boost/test/test_tools.hpp b/contrib/autoboost/boost/test/test_tools.hpp
deleted file mode 100644
index 9bf7bcc1f..000000000
--- a/contrib/autoboost/boost/test/test_tools.hpp
+++ /dev/null
@@ -1,719 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : contains definition for all test tools in test toolbox
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TEST_TOOLS_HPP_012705GER
-#define BOOST_TEST_TEST_TOOLS_HPP_012705GER
-
-// Boost.Test
-#include <boost/test/predicate_result.hpp>
-#include <boost/test/unit_test_log.hpp>
-#include <boost/test/floating_point_comparison.hpp>
-
-#include <boost/test/detail/config.hpp>
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/workaround.hpp>
-
-#include <boost/test/utils/wrap_stringstream.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-#include <boost/test/utils/lazy_ostream.hpp>
-
-// Boost
-#include <boost/preprocessor/seq/for_each.hpp>
-#include <boost/preprocessor/seq/size.hpp>
-#include <boost/preprocessor/seq/enum.hpp> 
-#include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/preprocessor/punctuation/comma_if.hpp>
-#include <boost/preprocessor/arithmetic/add.hpp>
-
-#include <boost/limits.hpp>
-
-#include <boost/type_traits/is_array.hpp>
-#include <boost/type_traits/is_function.hpp>
-#include <boost/type_traits/is_abstract.hpp>
-
-#include <boost/mpl/or.hpp>
-
-// STL
-#include <cstddef>          // for std::size_t
-#include <iosfwd>
-#include <ios>              // for std::boolalpha
-#include <climits>          // for CHAR_BIT
-
-#ifdef BOOST_MSVC
-# pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                    TOOL BOX                  ************** //
-// ************************************************************************** //
-
-// In macros below following argument abbreviations are used:
-// P - predicate
-// M - message
-// S - statement
-// E - exception
-// L - left argument
-// R - right argument
-// TL - tool level
-// CT - check type
-// ARGS - arguments list
-
-#define BOOST_TEST_TOOL_IMPL( func, P, check_descr, TL, CT )            \
-    ::autoboost::test_tools::tt_detail::func(                               \
-        P,                                                              \
-        ::autoboost::unit_test::lazy_ostream::instance() << check_descr,    \
-        BOOST_TEST_L(__FILE__),                                         \
-        static_cast<std::size_t>(__LINE__),                             \
-        ::autoboost::test_tools::tt_detail::TL,                             \
-        ::autoboost::test_tools::tt_detail::CT                              \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_CHECK_IMPL( P, check_descr, TL, CT )                  \
-do {                                                                \
-    BOOST_TEST_PASSPOINT();                                         \
-    BOOST_TEST_TOOL_IMPL( check_impl, P, check_descr, TL, CT ), 0 );\
-} while( ::autoboost::test_tools::dummy_cond )                          \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_TEST_PASS_ARG_INFO( r, data, arg ) , arg, BOOST_STRINGIZE( arg )
-
-#define BOOST_CHECK_WITH_ARGS_IMPL( P, check_descr, TL, CT, ARGS )  \
-do {                                                                \
-    BOOST_TEST_PASSPOINT();                                         \
-    BOOST_TEST_TOOL_IMPL( check_frwd, P, check_descr, TL, CT )      \
-    BOOST_PP_SEQ_FOR_EACH( BOOST_TEST_PASS_ARG_INFO, '_', ARGS ) ); \
-} while( ::autoboost::test_tools::dummy_cond )                          \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN( P )                     BOOST_CHECK_IMPL( (P), BOOST_TEST_STRINGIZE( P ), WARN, CHECK_PRED )
-#define BOOST_CHECK( P )                    BOOST_CHECK_IMPL( (P), BOOST_TEST_STRINGIZE( P ), CHECK, CHECK_PRED )
-#define BOOST_REQUIRE( P )                  BOOST_CHECK_IMPL( (P), BOOST_TEST_STRINGIZE( P ), REQUIRE, CHECK_PRED )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_MESSAGE( P, M )          BOOST_CHECK_IMPL( (P), M, WARN, CHECK_MSG )
-#define BOOST_CHECK_MESSAGE( P, M )         BOOST_CHECK_IMPL( (P), M, CHECK, CHECK_MSG )
-#define BOOST_REQUIRE_MESSAGE( P, M )       BOOST_CHECK_IMPL( (P), M, REQUIRE, CHECK_MSG )
-
-//____________________________________________________________________________//
-
-#define BOOST_ERROR( M )                    BOOST_CHECK_MESSAGE( false, M )
-#define BOOST_FAIL( M )                     BOOST_REQUIRE_MESSAGE( false, M )
-
-//____________________________________________________________________________//
-
-#define BOOST_CHECK_THROW_IMPL( S, E, P, prefix, TL )                                                   \
-    try {                                                                                               \
-        BOOST_TEST_PASSPOINT();                                                                         \
-        S;                                                                                              \
-        BOOST_CHECK_IMPL( false, "exception " BOOST_STRINGIZE( E ) " is expected", TL, CHECK_MSG ); }   \
-    catch( E const& ex ) {                                                                              \
-        ::autoboost::unit_test::ut_detail::ignore_unused_variable_warning( ex );                            \
-        BOOST_CHECK_IMPL( P, prefix BOOST_STRINGIZE( E ) " is caught", TL, CHECK_MSG );                 \
-    }                                                                                                   \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_THROW( S, E )            BOOST_CHECK_THROW_IMPL( S, E, true, "exception ", WARN )
-#define BOOST_CHECK_THROW( S, E )           BOOST_CHECK_THROW_IMPL( S, E, true, "exception ", CHECK )
-#define BOOST_REQUIRE_THROW( S, E )         BOOST_CHECK_THROW_IMPL( S, E, true, "exception ", REQUIRE )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_EXCEPTION( S, E, P )     BOOST_CHECK_THROW_IMPL( S, E, P( ex ), "incorrect exception ", WARN )
-#define BOOST_CHECK_EXCEPTION( S, E, P )    BOOST_CHECK_THROW_IMPL( S, E, P( ex ), "incorrect exception ", CHECK )
-#define BOOST_REQUIRE_EXCEPTION( S, E, P )  BOOST_CHECK_THROW_IMPL( S, E, P( ex ), "incorrect exception ", REQUIRE )
-
-//____________________________________________________________________________//
-
-#define BOOST_CHECK_NO_THROW_IMPL( S, TL )                                                          \
-    try {                                                                                           \
-        S;                                                                                          \
-        BOOST_CHECK_IMPL( true, "no exceptions thrown by " BOOST_STRINGIZE( S ), TL, CHECK_MSG ); } \
-    catch( ... ) {                                                                                  \
-        BOOST_CHECK_IMPL( false, "exception thrown by " BOOST_STRINGIZE( S ), TL, CHECK_MSG );      \
-    }                                                                                               \
-/**/
-
-#define BOOST_WARN_NO_THROW( S )            BOOST_CHECK_NO_THROW_IMPL( S, WARN )
-#define BOOST_CHECK_NO_THROW( S )           BOOST_CHECK_NO_THROW_IMPL( S, CHECK )
-#define BOOST_REQUIRE_NO_THROW( S )         BOOST_CHECK_NO_THROW_IMPL( S, REQUIRE )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_EQUAL( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::equal_impl_frwd(), "", WARN, CHECK_EQUAL, (L)(R) )
-#define BOOST_CHECK_EQUAL( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::equal_impl_frwd(), "", CHECK, CHECK_EQUAL, (L)(R) )
-#define BOOST_REQUIRE_EQUAL( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::equal_impl_frwd(), "", REQUIRE, CHECK_EQUAL, (L)(R) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_NE( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::ne_impl(), "", WARN, CHECK_NE, (L)(R) )
-#define BOOST_CHECK_NE( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::ne_impl(), "", CHECK, CHECK_NE, (L)(R) )
-#define BOOST_REQUIRE_NE( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::ne_impl(), "", REQUIRE, CHECK_NE, (L)(R) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_LT( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::lt_impl(), "", WARN, CHECK_LT, (L)(R) )
-#define BOOST_CHECK_LT( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::lt_impl(), "", CHECK, CHECK_LT, (L)(R) )
-#define BOOST_REQUIRE_LT( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::lt_impl(), "", REQUIRE, CHECK_LT, (L)(R) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_LE( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::le_impl(), "", WARN, CHECK_LE, (L)(R) )
-#define BOOST_CHECK_LE( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::le_impl(), "", CHECK, CHECK_LE, (L)(R) )
-#define BOOST_REQUIRE_LE( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::le_impl(), "", REQUIRE, CHECK_LE, (L)(R) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_GT( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::gt_impl(), "", WARN, CHECK_GT, (L)(R) )
-#define BOOST_CHECK_GT( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::gt_impl(), "", CHECK, CHECK_GT, (L)(R) )
-#define BOOST_REQUIRE_GT( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::gt_impl(), "", REQUIRE, CHECK_GT, (L)(R) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_GE( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::ge_impl(), "", WARN, CHECK_GE, (L)(R) )
-#define BOOST_CHECK_GE( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::ge_impl(), "", CHECK, CHECK_GE, (L)(R) )
-#define BOOST_REQUIRE_GE( L, R ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::tt_detail::ge_impl(), "", REQUIRE, CHECK_GE, (L)(R) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_CLOSE( L, R, T ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::check_is_close, "", WARN, CHECK_CLOSE, \
-        (L)(R)(::autoboost::test_tools::percent_tolerance(T)) )
-#define BOOST_CHECK_CLOSE( L, R, T ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::check_is_close, "", CHECK, CHECK_CLOSE, \
-        (L)(R)(::autoboost::test_tools::percent_tolerance(T)) )
-#define BOOST_REQUIRE_CLOSE( L, R, T ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::check_is_close, "", REQUIRE, CHECK_CLOSE, \
-        (L)(R)(::autoboost::test_tools::percent_tolerance(T)) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_CLOSE_FRACTION( L, R, T ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::check_is_close, "", WARN, CHECK_CLOSE_FRACTION, \
-    (L)(R)(::autoboost::test_tools::fraction_tolerance(T)) )
-#define BOOST_CHECK_CLOSE_FRACTION( L, R, T ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::check_is_close, "", CHECK, CHECK_CLOSE_FRACTION, \
-    (L)(R)(::autoboost::test_tools::fraction_tolerance(T)) )
-#define BOOST_REQUIRE_CLOSE_FRACTION( L, R, T ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::check_is_close, "", REQUIRE, CHECK_CLOSE_FRACTION, \
-    (L)(R)(::autoboost::test_tools::fraction_tolerance(T)) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_SMALL( FPV, T ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::check_is_small, "", WARN, CHECK_SMALL, (FPV)(T) )
-#define BOOST_CHECK_SMALL( FPV, T ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::check_is_small, "", CHECK, CHECK_SMALL, (FPV)(T) )
-#define BOOST_REQUIRE_SMALL( FPV, T ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( ::autoboost::test_tools::check_is_small, "", REQUIRE, CHECK_SMALL, (FPV)(T) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_PREDICATE( P, ARGS ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( P, BOOST_TEST_STRINGIZE( P ), WARN, CHECK_PRED_WITH_ARGS, ARGS )
-#define BOOST_CHECK_PREDICATE( P, ARGS ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( P, BOOST_TEST_STRINGIZE( P ), CHECK, CHECK_PRED_WITH_ARGS, ARGS )
-#define BOOST_REQUIRE_PREDICATE( P, ARGS ) \
-    BOOST_CHECK_WITH_ARGS_IMPL( P, BOOST_TEST_STRINGIZE( P ), REQUIRE, CHECK_PRED_WITH_ARGS, ARGS )
-
-//____________________________________________________________________________//
-
-#define BOOST_EQUAL_COLLECTIONS_IMPL( L_begin, L_end, R_begin, R_end, TL )      \
-    BOOST_TEST_TOOL_IMPL( check_impl, ::autoboost::test_tools::tt_detail::equal_coll_impl( \
-        (L_begin), (L_end), (R_begin), (R_end) ), "", TL, CHECK_EQUAL_COLL ),   \
-    4,                                                                          \
-    BOOST_STRINGIZE( L_begin ), BOOST_STRINGIZE( L_end ),                       \
-    BOOST_STRINGIZE( R_begin ), BOOST_STRINGIZE( R_end ) )                      \
-/**/
-
-#define BOOST_WARN_EQUAL_COLLECTIONS( L_begin, L_end, R_begin, R_end )          \
-    BOOST_EQUAL_COLLECTIONS_IMPL( L_begin, L_end, R_begin, R_end, WARN )
-#define BOOST_CHECK_EQUAL_COLLECTIONS( L_begin, L_end, R_begin, R_end )         \
-    BOOST_EQUAL_COLLECTIONS_IMPL( L_begin, L_end, R_begin, R_end, CHECK )
-#define BOOST_REQUIRE_EQUAL_COLLECTIONS( L_begin, L_end, R_begin, R_end )       \
-    BOOST_EQUAL_COLLECTIONS_IMPL( L_begin, L_end, R_begin, R_end, REQUIRE )
-
-//____________________________________________________________________________//
-
-#define BOOST_BITWISE_EQUAL_IMPL( L, R, TL )                                    \
-    BOOST_TEST_TOOL_IMPL( check_impl,                                           \
-      ::autoboost::test_tools::tt_detail::bitwise_equal_impl( (L), (R) ),           \
-      "", TL, CHECK_BITWISE_EQUAL ),                                            \
-    2, BOOST_STRINGIZE( L ), BOOST_STRINGIZE( R ) )                             \
-/**/
-
-#define BOOST_WARN_BITWISE_EQUAL( L, R )    BOOST_BITWISE_EQUAL_IMPL( L, R, WARN )
-#define BOOST_CHECK_BITWISE_EQUAL( L, R )   BOOST_BITWISE_EQUAL_IMPL( L, R, CHECK )
-#define BOOST_REQUIRE_BITWISE_EQUAL( L, R ) BOOST_BITWISE_EQUAL_IMPL( L, R, REQUIRE )
-
-//____________________________________________________________________________//
-
-#define BOOST_IS_DEFINED( symb )            ::autoboost::test_tools::tt_detail::is_defined_impl( #symb, BOOST_STRINGIZE(= symb) )
-
-//____________________________________________________________________________//
-
-// ***************************** //
-// deprecated interface
-
-#define BOOST_BITWISE_EQUAL( L, R )         BOOST_CHECK_BITWISE_EQUAL( L, R )
-#define BOOST_MESSAGE( M )                  BOOST_TEST_MESSAGE( M )
-#define BOOST_CHECKPOINT( M )               BOOST_TEST_CHECKPOINT( M )
-
-namespace autoboost {
-
-namespace test_tools {
-
-typedef unit_test::const_string      const_string;
-
-namespace { bool dummy_cond = false; }
-
-// ************************************************************************** //
-// **************                print_log_value               ************** //
-// ************************************************************************** //
-
-template<typename T>
-struct print_log_value {
-    void    operator()( std::ostream& ostr, T const& t )
-    {
-        // avoid warning: 'autoboost::test_tools::<unnamed>::dummy_cond' defined but not used 
-        if (::autoboost::test_tools::dummy_cond) {}
-
-        typedef typename mpl::or_<is_array<T>,is_function<T>,is_abstract<T> >::type cant_use_nl;
-
-        set_precision( ostr, cant_use_nl() );
-
-        ostr << t; // by default print the value
-    }
-
-    void set_precision( std::ostream& ostr, mpl::false_ )
-    {
-        if( std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::radix == 2 )
-            ostr.precision( 2 + std::numeric_limits<T>::digits * 301/1000 ); 
-    }
-
-    void set_precision( std::ostream&, mpl::true_ ) {}
-};
-
-//____________________________________________________________________________//
-
-#define BOOST_TEST_DONT_PRINT_LOG_VALUE( the_type )         \
-namespace autoboost { namespace test_tools {                    \
-template<>                                                  \
-struct print_log_value<the_type > {                         \
-    void operator()( std::ostream&, the_type const& ) {}    \
-};                                                          \
-}}                                                          \
-/**/
-
-//____________________________________________________________________________//
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-template<typename T, std::size_t N >
-struct print_log_value< T[N] > {
-    void    operator()( std::ostream& ostr, T const* t )
-    {
-        ostr << t;
-    }
-};
-#endif
-
-//____________________________________________________________________________//
-
-template<>
-struct BOOST_TEST_DECL print_log_value<bool> {
-    void    operator()( std::ostream& ostr, bool t )
-    {
-         ostr << std::boolalpha << t;
-    }
-};
-
-//____________________________________________________________________________//
-
-template<>
-struct BOOST_TEST_DECL print_log_value<char> {
-    void    operator()( std::ostream& ostr, char t );
-};
-
-//____________________________________________________________________________//
-
-template<>
-struct BOOST_TEST_DECL print_log_value<unsigned char> {
-    void    operator()( std::ostream& ostr, unsigned char t );
-};
-
-//____________________________________________________________________________//
-
-template<>
-struct BOOST_TEST_DECL print_log_value<char const*> {
-    void    operator()( std::ostream& ostr, char const* t );
-};
-
-//____________________________________________________________________________//
-
-template<>
-struct BOOST_TEST_DECL print_log_value<wchar_t const*> {
-    void    operator()( std::ostream& ostr, wchar_t const* t );
-};
-
-//____________________________________________________________________________//
-
-namespace tt_detail {
-
-// ************************************************************************** //
-// **************              tools classification            ************** //
-// ************************************************************************** //
-
-enum check_type {
-    CHECK_PRED, 
-    CHECK_MSG,
-    CHECK_EQUAL,
-    CHECK_NE,
-    CHECK_LT,
-    CHECK_LE,
-    CHECK_GT,
-    CHECK_GE,
-    CHECK_CLOSE,
-    CHECK_CLOSE_FRACTION,
-    CHECK_SMALL,
-    CHECK_BITWISE_EQUAL,
-    CHECK_PRED_WITH_ARGS,
-    CHECK_EQUAL_COLL
-};
-
-enum tool_level {
-    WARN, CHECK, REQUIRE, PASS
-};
-
-// ************************************************************************** //
-// **************                 print_helper                 ************** //
-// ************************************************************************** //
-// Adds level of indirection to the output operation, allowing us to customize 
-// it for types that do not support operator << directly or for any other reason
-
-template<typename T>
-struct print_helper_t {
-    explicit    print_helper_t( T const& t ) : m_t( t ) {}
-
-    T const&    m_t;
-};
-
-//____________________________________________________________________________//
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) 
-// Borland suffers premature pointer decay passing arrays by reference
-template<typename T, std::size_t N >
-struct print_helper_t< T[N] > {
-    explicit    print_helper_t( T const * t ) : m_t( t ) {}
-
-    T const *   m_t;
-};
-#endif
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline print_helper_t<T> print_helper( T const& t )
-{
-    return print_helper_t<T>( t );
-}
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline std::ostream& 
-operator<<( std::ostream& ostr, print_helper_t<T> const& ph )
-{
-    print_log_value<T>()( ostr, ph.m_t );
-
-    return ostr;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************            TOOL BOX Implementation           ************** //
-// ************************************************************************** //
-
-BOOST_TEST_DECL 
-bool check_impl( predicate_result const& pr, ::autoboost::unit_test::lazy_ostream const& check_descr,
-                 const_string file_name, std::size_t line_num,
-                 tool_level tl, check_type ct,
-                 std::size_t num_args, ... );
-
-//____________________________________________________________________________//
-
-#define TEMPL_PARAMS( z, m, dummy ) , typename BOOST_JOIN( Arg, m )
-#define FUNC_PARAMS( z, m, dummy )                                                  \
- , BOOST_JOIN( Arg, m ) const& BOOST_JOIN( arg, m )                                 \
- , char const* BOOST_JOIN( BOOST_JOIN( arg, m ), _descr )                           \
-/**/
-
-#define PRED_PARAMS( z, m, dummy ) BOOST_PP_COMMA_IF( m ) BOOST_JOIN( arg, m ) 
-
-#define ARG_INFO( z, m, dummy )                                                     \
- , BOOST_JOIN( BOOST_JOIN( arg, m ), _descr )                                       \
- , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() \
-        << ::autoboost::test_tools::tt_detail::print_helper( BOOST_JOIN( arg, m ) ))    \
-/**/
-
-#define IMPL_FRWD( z, n, dummy )                                                    \
-template<typename Pred                                                              \
-         BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), TEMPL_PARAMS, _ )>            \
-inline bool                                                                         \
-check_frwd( Pred P, unit_test::lazy_ostream const& check_descr,                     \
-            const_string file_name, std::size_t line_num,                           \
-            tool_level tl, check_type ct                                            \
-            BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), FUNC_PARAMS, _ )           \
-)                                                                                   \
-{                                                                                   \
-    return                                                                          \
-    check_impl( P( BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), PRED_PARAMS, _ ) ), \
-                check_descr, file_name, line_num, tl, ct,                           \
-                BOOST_PP_ADD( n, 1 )                                                \
-                BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), ARG_INFO, _ )          \
-    );                                                                              \
-}                                                                                   \
-/**/
-
-#ifndef BOOST_TEST_MAX_PREDICATE_ARITY
-#define BOOST_TEST_MAX_PREDICATE_ARITY 5
-#endif
-
-BOOST_PP_REPEAT( BOOST_TEST_MAX_PREDICATE_ARITY, IMPL_FRWD, _ )
-
-#undef TEMPL_PARAMS
-#undef FUNC_PARAMS
-#undef PRED_INFO
-#undef ARG_INFO
-#undef IMPL_FRWD
-
-//____________________________________________________________________________//
-
-template <class Left, class Right>
-predicate_result equal_impl( Left const& left, Right const& right )
-{
-    return left == right;
-}
-
-//____________________________________________________________________________//
-
-predicate_result        BOOST_TEST_DECL equal_impl( char const* left, char const* right );
-inline predicate_result equal_impl( char* left, char const* right ) { return equal_impl( static_cast<char const*>(left), static_cast<char const*>(right) ); }
-inline predicate_result equal_impl( char const* left, char* right ) { return equal_impl( static_cast<char const*>(left), static_cast<char const*>(right) ); }
-inline predicate_result equal_impl( char* left, char* right )       { return equal_impl( static_cast<char const*>(left), static_cast<char const*>(right) ); }
-
-#if !defined( BOOST_NO_CWCHAR )
-predicate_result        BOOST_TEST_DECL equal_impl( wchar_t const* left, wchar_t const* right );
-inline predicate_result equal_impl( wchar_t* left, wchar_t const* right ) { return equal_impl( static_cast<wchar_t const*>(left), static_cast<wchar_t const*>(right) ); }
-inline predicate_result equal_impl( wchar_t const* left, wchar_t* right ) { return equal_impl( static_cast<wchar_t const*>(left), static_cast<wchar_t const*>(right) ); }
-inline predicate_result equal_impl( wchar_t* left, wchar_t* right )       { return equal_impl( static_cast<wchar_t const*>(left), static_cast<wchar_t const*>(right) ); }
-#endif
-
-//____________________________________________________________________________//
-
-struct equal_impl_frwd {
-    template <typename Left, typename Right>
-    inline predicate_result
-    call_impl( Left const& left, Right const& right, mpl::false_ ) const
-    {
-        return equal_impl( left, right );
-    }
-
-    template <typename Left, typename Right>
-    inline predicate_result
-    call_impl( Left const& left, Right const& right, mpl::true_ ) const
-    {
-        return (*this)( right, &left[0] );
-    }
-
-    template <typename Left, typename Right>
-    inline predicate_result
-    operator()( Left const& left, Right const& right ) const
-    {
-        typedef typename is_array<Left>::type left_is_array;
-        return call_impl( left, right, left_is_array() );
-    }
-};
-
-//____________________________________________________________________________//
-
-struct ne_impl {
-    template <class Left, class Right>
-    predicate_result operator()( Left const& left, Right const& right )
-    {
-        return !equal_impl_frwd()( left, right );
-    }
-};
-
-//____________________________________________________________________________//
-
-struct lt_impl {
-    template <class Left, class Right>
-    predicate_result operator()( Left const& left, Right const& right )
-    {
-        return left < right;
-    }
-};
-
-//____________________________________________________________________________//
-
-struct le_impl {
-    template <class Left, class Right>
-    predicate_result operator()( Left const& left, Right const& right )
-    {
-        return left <= right;
-    }
-};
-
-//____________________________________________________________________________//
-
-struct gt_impl {
-    template <class Left, class Right>
-    predicate_result operator()( Left const& left, Right const& right )
-    {
-        return left > right;
-    }
-};
-
-//____________________________________________________________________________//
-
-struct ge_impl {
-    template <class Left, class Right>
-    predicate_result operator()( Left const& left, Right const& right )
-    {
-        return left >= right;
-    }
-};
-
-//____________________________________________________________________________//
-
-template <typename Left, typename Right>
-inline predicate_result
-equal_coll_impl( Left left_begin, Left left_end, Right right_begin, Right right_end )
-{
-    predicate_result    res( true );
-    std::size_t         pos = 0;
-
-    for( ; left_begin != left_end && right_begin != right_end; ++left_begin, ++right_begin, ++pos ) {
-        if( *left_begin != *right_begin ) {
-            res = false;
-            res.message() << "\nMismatch in a position " << pos << ": "  << *left_begin << " != " << *right_begin;
-        }
-    }
-
-    if( left_begin != left_end ) {
-        std::size_t r_size = pos;
-        while( left_begin != left_end ) {
-            ++pos;
-            ++left_begin;
-        }
-
-        res = false;
-        res.message() << "\nCollections size mismatch: " << pos << " != " << r_size;
-    }
-
-    if( right_begin != right_end ) {
-        std::size_t l_size = pos;
-        while( right_begin != right_end ) {
-            ++pos;
-            ++right_begin;
-        }
-
-        res = false;
-        res.message() << "\nCollections size mismatch: " << l_size << " != " << pos;
-    }
-
-    return res;
-}
-
-//____________________________________________________________________________//
-
-template <class Left, class Right>
-inline predicate_result
-bitwise_equal_impl( Left const& left, Right const& right )
-{
-    predicate_result    res( true );
-
-    std::size_t left_bit_size  = sizeof(Left)*CHAR_BIT;
-    std::size_t right_bit_size = sizeof(Right)*CHAR_BIT;
-
-    static Left const leftOne( 1 );
-    static Right const rightOne( 1 );
-
-    std::size_t total_bits = left_bit_size < right_bit_size ? left_bit_size : right_bit_size;
-
-    for( std::size_t counter = 0; counter < total_bits; ++counter ) {
-        if( ( left & ( leftOne << counter ) ) != ( right & ( rightOne << counter ) ) ) {
-            res = false;
-            res.message() << "\nMismatch in a position " << counter;
-        }
-    }
-
-    if( left_bit_size != right_bit_size ) {
-        res = false;
-        res.message() << "\nOperands bit sizes mismatch: " << left_bit_size << " != " << right_bit_size;
-    }
-
-    return res;
-}
-
-//____________________________________________________________________________//
-
-bool BOOST_TEST_DECL is_defined_impl( const_string symbol_name, const_string symbol_value );
-
-//____________________________________________________________________________//
-
-} // namespace tt_detail
-
-} // namespace test_tools
-
-namespace test_toolbox = test_tools;
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TEST_TOOLS_HPP_012705GER
diff --git a/contrib/autoboost/boost/test/unit_test.hpp b/contrib/autoboost/boost/test/unit_test.hpp
deleted file mode 100644
index b3b487137..000000000
--- a/contrib/autoboost/boost/test/unit_test.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : Entry point for the end user into the Unit Test Framework.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_HPP_071894GER
-#define BOOST_TEST_UNIT_TEST_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/test_tools.hpp>
-#include <boost/test/unit_test_suite.hpp>
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 Auto Linking                 ************** //
-// ************************************************************************** //
-
-#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_TEST_NO_LIB) && \
-    !defined(BOOST_TEST_SOURCE) && !defined(BOOST_TEST_INCLUDED)
-#  define BOOST_LIB_NAME autoboost_unit_test_framework
-
-#  if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_TEST_DYN_LINK)
-#    define BOOST_DYN_LINK
-#  endif
-
-#  include <boost/config/auto_link.hpp>
-
-#endif  // auto-linking disabled
-
-// ************************************************************************** //
-// **************                  unit_test_main              ************** //
-// ************************************************************************** //
-
-namespace autoboost { namespace unit_test {
-
-int BOOST_TEST_DECL unit_test_main( init_unit_test_func init_func, int argc, char* argv[] );
-
-}}
-
-#if defined(BOOST_TEST_DYN_LINK) && defined(BOOST_TEST_MAIN) && !defined(BOOST_TEST_NO_MAIN)
-
-// ************************************************************************** //
-// **************        main function for tests using dll     ************** //
-// ************************************************************************** //
-
-int BOOST_TEST_CALL_DECL
-main( int argc, char* argv[] )
-{
-    return ::autoboost::unit_test::unit_test_main( &init_unit_test, argc, argv );
-}
-
-//____________________________________________________________________________//
-
-#endif // BOOST_TEST_DYN_LINK && BOOST_TEST_MAIN && !BOOST_TEST_NO_MAIN
-
-#endif // BOOST_TEST_UNIT_TEST_HPP_071894GER
diff --git a/contrib/autoboost/boost/test/unit_test_log.hpp b/contrib/autoboost/boost/test/unit_test_log.hpp
deleted file mode 100644
index 10932ec93..000000000
--- a/contrib/autoboost/boost/test/unit_test_log.hpp
+++ /dev/null
@@ -1,177 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines singleton class unit_test_log and all manipulators.
-//  unit_test_log has output stream like interface. It's implementation is
-//  completely hidden with pimple idiom
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_LOG_HPP_071894GER
-#define BOOST_TEST_UNIT_TEST_LOG_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/test_observer.hpp>
-
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/log_level.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-
-#include <boost/test/utils/wrap_stringstream.hpp>
-#include <boost/test/utils/trivial_singleton.hpp>
-#include <boost/test/utils/lazy_ostream.hpp>
-
-// Boost
-#include <boost/utility.hpp>
-
-// STL
-#include <iosfwd>   // for std::ostream&
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                log manipulators              ************** //
-// ************************************************************************** //
-
-namespace log {
-
-struct BOOST_TEST_DECL begin {
-    begin( const_string fn, std::size_t ln )
-    : m_file_name( fn )
-    , m_line_num( ln )
-    {}
-
-    const_string m_file_name;
-    std::size_t m_line_num;
-};
-
-struct end {};
-
-} // namespace log
-
-// ************************************************************************** //
-// **************             entry_value_collector            ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-class BOOST_TEST_DECL entry_value_collector {
-public:
-    // Constructors
-    entry_value_collector() : m_last( true ) {}
-    entry_value_collector( entry_value_collector const& rhs ) : m_last( true ) { rhs.m_last = false; }
-    ~entry_value_collector();
-
-    // collection interface
-    entry_value_collector const& operator<<( lazy_ostream const& ) const;
-    entry_value_collector const& operator<<( const_string ) const;
-
-private:
-    // Data members
-    mutable bool    m_last;
-};
-
-} // namespace ut_detail
-
-// ************************************************************************** //
-// **************                 unit_test_log                ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL unit_test_log_t : public test_observer, public singleton<unit_test_log_t> {
-public:
-    // test_observer interface implementation
-    void                test_start( counter_t test_cases_amount );
-    void                test_finish();
-    void                test_aborted();
-
-    void                test_unit_start( test_unit const& );
-    void                test_unit_finish( test_unit const&, unsigned long elapsed );
-    void                test_unit_skipped( test_unit const& );
-    void                test_unit_aborted( test_unit const& );
-
-    void                assertion_result( bool passed );
-    void                exception_caught( execution_exception const& );
-
-    virtual int         priority() { return 1; }
-
-    // log configuration methods
-    void                set_stream( std::ostream& );
-    void                set_threshold_level( log_level );
-    void                set_format( output_format );
-    void                set_formatter( unit_test_log_formatter* );
-
-    // test progress logging
-    void                set_checkpoint( const_string file, std::size_t line_num, const_string msg = const_string() );
-
-    // entry logging
-    unit_test_log_t&    operator<<( log::begin const& );        // begin entry 
-    unit_test_log_t&    operator<<( log::end const& );          // end entry
-    unit_test_log_t&    operator<<( log_level );                // set entry level
-    unit_test_log_t&    operator<<( const_string );             // log entry value
-    unit_test_log_t&    operator<<( lazy_ostream const& );      // log entry value
-
-    ut_detail::entry_value_collector operator()( log_level );   // initiate entry collection
-
-private:
-    bool            log_entry_start();
-
-    BOOST_TEST_SINGLETON_CONS( unit_test_log_t );
-}; // unit_test_log_t
-
-BOOST_TEST_SINGLETON_INST( unit_test_log )
-
-// helper macros
-#define BOOST_TEST_LOG_ENTRY( ll )                                                  \
-    (::autoboost::unit_test::unit_test_log                                              \
-        << ::autoboost::unit_test::log::begin( BOOST_TEST_L(__FILE__), __LINE__ ))(ll)  \
-/**/
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-// ************************************************************************** //
-// **************       Unit test log interface helpers        ************** //
-// ************************************************************************** //
-
-#define BOOST_TEST_MESSAGE( M )                                 \
-    BOOST_TEST_LOG_ENTRY( ::autoboost::unit_test::log_messages )    \
-    << (::autoboost::unit_test::lazy_ostream::instance() << M)      \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_TEST_PASSPOINT()                                  \
-    ::autoboost::unit_test::unit_test_log.set_checkpoint(           \
-        BOOST_TEST_L(__FILE__),                                 \
-        static_cast<std::size_t>(__LINE__) )                    \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_TEST_CHECKPOINT( M )                              \
-    ::autoboost::unit_test::unit_test_log.set_checkpoint(           \
-        BOOST_TEST_L(__FILE__),                                 \
-        static_cast<std::size_t>(__LINE__),                     \
-        (::autoboost::wrap_stringstream().ref() << M).str() )       \
-/**/
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_LOG_HPP_071894GER
-
diff --git a/contrib/autoboost/boost/test/unit_test_log_formatter.hpp b/contrib/autoboost/boost/test/unit_test_log_formatter.hpp
deleted file mode 100644
index c3b52d038..000000000
--- a/contrib/autoboost/boost/test/unit_test_log_formatter.hpp
+++ /dev/null
@@ -1,123 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2003-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : 
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_LOG_FORMATTER_HPP_071894GER
-#define BOOST_TEST_UNIT_TEST_LOG_FORMATTER_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/log_level.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-
-#include <boost/test/execution_monitor.hpp>
-
-// STL
-#include <iosfwd>
-#include <string> // for std::string
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                log_entry_data                ************** //
-// ************************************************************************** //
-
-struct BOOST_TEST_DECL log_entry_data {
-    log_entry_data()
-    {
-        m_file_name.reserve( 200 );
-    }
-
-    std::string     m_file_name;
-    std::size_t     m_line_num;
-    log_level       m_level;
-
-    void clear()
-    {
-        m_file_name.erase();
-        m_line_num      = 0;
-        m_level     = log_nothing;
-    }
-};
-
-// ************************************************************************** //
-// **************                checkpoint_data               ************** //
-// ************************************************************************** //
-
-struct BOOST_TEST_DECL log_checkpoint_data
-{
-    const_string    m_file_name;
-    std::size_t     m_line_num;
-    std::string     m_message;
-
-    void clear()
-    {
-        m_file_name.clear();
-        m_line_num    = 0;
-        m_message = std::string();
-    }
-};
-
-// ************************************************************************** //
-// **************            unit_test_log_formatter           ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL unit_test_log_formatter {
-public:
-    enum log_entry_types { BOOST_UTL_ET_INFO, 
-                           BOOST_UTL_ET_MESSAGE,
-                           BOOST_UTL_ET_WARNING,
-                           BOOST_UTL_ET_ERROR,
-                           BOOST_UTL_ET_FATAL_ERROR };
-
-    // Destructor
-    virtual             ~unit_test_log_formatter() {}
-
-    // Formatter interface
-    virtual void        log_start( std::ostream&, counter_t test_cases_amount ) = 0;
-    virtual void        log_finish( std::ostream& ) = 0;
-    virtual void        log_build_info( std::ostream& ) = 0;
-
-    virtual void        test_unit_start( std::ostream&, test_unit const& tu ) = 0;
-    virtual void        test_unit_finish( std::ostream&, test_unit const& tu, unsigned long elapsed ) = 0;
-    virtual void        test_unit_skipped( std::ostream&, test_unit const& ) = 0;
-
-    virtual void        log_exception( std::ostream& os, log_checkpoint_data const& cd, execution_exception const& ex )
-    {
-        // for backward compatibility
-        log_exception( os, cd, ex.what() );
-    }
-    virtual void        log_exception( std::ostream&, log_checkpoint_data const&, const_string /* explanation */ ) {}
-
-    virtual void        log_entry_start( std::ostream&, log_entry_data const&, log_entry_types let ) = 0;
-    virtual void        log_entry_value( std::ostream&, const_string value ) = 0;
-    virtual void        log_entry_value( std::ostream&, lazy_ostream const& value ); // there is a default impl
-    virtual void        log_entry_finish( std::ostream& ) = 0;
-};
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_LOG_FORMATTER_HPP_071894GER
-
diff --git a/contrib/autoboost/boost/test/unit_test_monitor.hpp b/contrib/autoboost/boost/test/unit_test_monitor.hpp
deleted file mode 100644
index 26aa7c762..000000000
--- a/contrib/autoboost/boost/test/unit_test_monitor.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines specific version of execution monitor used to managed 
-//  run unit of test cases. Translates execution exception into error level
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_MONITOR_HPP_020905GER
-#define BOOST_TEST_UNIT_TEST_MONITOR_HPP_020905GER
-
-// Boost.Test
-#include <boost/test/execution_monitor.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-#include <boost/test/utils/trivial_singleton.hpp>
-#include <boost/test/utils/callback.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************               unit_test_monitor              ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL unit_test_monitor_t : public singleton<unit_test_monitor_t>, public execution_monitor {
-public:
-    enum error_level { 
-        test_fail               =  1,
-        test_ok                 =  0,
-        constructor_error       = -1, 
-        unexpected_exception    = -2, 
-        os_exception            = -3, 
-        os_timeout              = -4, 
-        fatal_error             = -5,  // includes both system and user
-        destructor_error        = -6
-    };
-
-    static bool is_critical_error( error_level e ) { return e <= fatal_error; }
-
-    // monitor method
-    error_level execute_and_translate( test_case const& );
-
-private:
-    BOOST_TEST_SINGLETON_CONS( unit_test_monitor_t );
-};
-
-BOOST_TEST_SINGLETON_INST( unit_test_monitor )
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_MONITOR_HPP_020905GER
diff --git a/contrib/autoboost/boost/test/unit_test_suite.hpp b/contrib/autoboost/boost/test/unit_test_suite.hpp
deleted file mode 100644
index 75b72706f..000000000
--- a/contrib/autoboost/boost/test/unit_test_suite.hpp
+++ /dev/null
@@ -1,245 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines Unit Test Framework public API
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_SUITE_HPP_071894GER
-#define BOOST_TEST_UNIT_TEST_SUITE_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/unit_test_suite_impl.hpp>
-#include <boost/test/framework.hpp>
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************    Non-auto (explicit) test case interface   ************** //
-// ************************************************************************** //
-
-#define BOOST_TEST_CASE( test_function ) \
-autoboost::unit_test::make_test_case( autoboost::unit_test::callback0<>(test_function), BOOST_TEST_STRINGIZE( test_function ) )
-#define BOOST_CLASS_TEST_CASE( test_function, tc_instance ) \
-autoboost::unit_test::make_test_case((test_function), BOOST_TEST_STRINGIZE( test_function ), tc_instance )
-
-// ************************************************************************** //
-// **************               BOOST_TEST_SUITE               ************** //
-// ************************************************************************** //
-
-#define BOOST_TEST_SUITE( testsuite_name ) \
-( new autoboost::unit_test::test_suite( testsuite_name ) )
-
-// ************************************************************************** //
-// **************             BOOST_AUTO_TEST_SUITE            ************** //
-// ************************************************************************** //
-
-#define BOOST_AUTO_TEST_SUITE( suite_name )                             \
-namespace suite_name {                                                  \
-BOOST_AUTO_TU_REGISTRAR( suite_name )( BOOST_STRINGIZE( suite_name ) ); \
-/**/
-
-// ************************************************************************** //
-// **************            BOOST_FIXTURE_TEST_SUITE          ************** //
-// ************************************************************************** //
-
-#define BOOST_FIXTURE_TEST_SUITE( suite_name, F )                       \
-BOOST_AUTO_TEST_SUITE( suite_name )                                     \
-typedef F BOOST_AUTO_TEST_CASE_FIXTURE;                                 \
-/**/
-
-// ************************************************************************** //
-// **************           BOOST_AUTO_TEST_SUITE_END          ************** //
-// ************************************************************************** //
-
-#define BOOST_AUTO_TEST_SUITE_END()                                     \
-BOOST_AUTO_TU_REGISTRAR( BOOST_JOIN( end_suite, __LINE__ ) )( 1 );      \
-}                                                                       \
-/**/
-
-// ************************************************************************** //
-// **************    BOOST_AUTO_TEST_CASE_EXPECTED_FAILURES    ************** //
-// ************************************************************************** //
-
-#define BOOST_AUTO_TEST_CASE_EXPECTED_FAILURES( test_name, n )          \
-struct BOOST_AUTO_TC_UNIQUE_ID( test_name );                            \
-                                                                        \
-static struct BOOST_JOIN( test_name, _exp_fail_num_spec )               \
-: autoboost::unit_test::ut_detail::                                         \
-  auto_tc_exp_fail<BOOST_AUTO_TC_UNIQUE_ID( test_name ) >               \
-{                                                                       \
-    BOOST_JOIN( test_name, _exp_fail_num_spec )()                       \
-    : autoboost::unit_test::ut_detail::                                     \
-      auto_tc_exp_fail<BOOST_AUTO_TC_UNIQUE_ID( test_name ) >( n )      \
-    {}                                                                  \
-} BOOST_JOIN( test_name, _exp_fail_num_spec_inst );                     \
-                                                                        \
-/**/
-
-// ************************************************************************** //
-// **************            BOOST_FIXTURE_TEST_CASE           ************** //
-// ************************************************************************** //
-
-#define BOOST_FIXTURE_TEST_CASE( test_name, F )                         \
-struct test_name : public F { void test_method(); };                    \
-                                                                        \
-static void BOOST_AUTO_TC_INVOKER( test_name )()                        \
-{                                                                       \
-    test_name t;                                                        \
-    t.test_method();                                                    \
-}                                                                       \
-                                                                        \
-struct BOOST_AUTO_TC_UNIQUE_ID( test_name ) {};                         \
-                                                                        \
-BOOST_AUTO_TU_REGISTRAR( test_name )(                                   \
-    autoboost::unit_test::make_test_case(                                   \
-        &BOOST_AUTO_TC_INVOKER( test_name ), #test_name ),              \
-    autoboost::unit_test::ut_detail::auto_tc_exp_fail<                      \
-        BOOST_AUTO_TC_UNIQUE_ID( test_name )>::instance()->value() );   \
-                                                                        \
-void test_name::test_method()                                           \
-/**/
-
-// ************************************************************************** //
-// **************             BOOST_AUTO_TEST_CASE             ************** //
-// ************************************************************************** //
-
-#define BOOST_AUTO_TEST_CASE( test_name )                               \
-BOOST_FIXTURE_TEST_CASE( test_name, BOOST_AUTO_TEST_CASE_FIXTURE )
-/**/
-
-// ************************************************************************** //
-// **************       BOOST_FIXTURE_TEST_CASE_TEMPLATE       ************** //
-// ************************************************************************** //
-
-#define BOOST_FIXTURE_TEST_CASE_TEMPLATE( test_name, type_name, TL, F ) \
-template<typename type_name>                                            \
-struct test_name : public F                                             \
-{ void test_method(); };                                                \
-                                                                        \
-struct BOOST_AUTO_TC_INVOKER( test_name ) {                             \
-    template<typename TestType>                                         \
-    static void run( autoboost::type<TestType>* = 0 )                       \
-    {                                                                   \
-        test_name<TestType> t;                                          \
-        t.test_method();                                                \
-    }                                                                   \
-};                                                                      \
-                                                                        \
-BOOST_AUTO_TU_REGISTRAR( test_name )(                                   \
-    autoboost::unit_test::ut_detail::template_test_case_gen<                \
-        BOOST_AUTO_TC_INVOKER( test_name ),TL >(                        \
-          BOOST_STRINGIZE( test_name ) ) );                             \
-                                                                        \
-template<typename type_name>                                            \
-void test_name<type_name>::test_method()                                \
-/**/
-
-// ************************************************************************** //
-// **************        BOOST_AUTO_TEST_CASE_TEMPLATE         ************** //
-// ************************************************************************** //
-
-#define BOOST_AUTO_TEST_CASE_TEMPLATE( test_name, type_name, TL )       \
-BOOST_FIXTURE_TEST_CASE_TEMPLATE( test_name, type_name, TL, BOOST_AUTO_TEST_CASE_FIXTURE )
-
-// ************************************************************************** //
-// **************           BOOST_TEST_CASE_TEMPLATE           ************** //
-// ************************************************************************** //
-
-#define BOOST_TEST_CASE_TEMPLATE( name, typelist )                          \
-    autoboost::unit_test::ut_detail::template_test_case_gen<name,typelist >(    \
-        BOOST_TEST_STRINGIZE( name ) )                                      \
-/**/
-
-// ************************************************************************** //
-// **************      BOOST_TEST_CASE_TEMPLATE_FUNCTION       ************** //
-// ************************************************************************** //
-
-#define BOOST_TEST_CASE_TEMPLATE_FUNCTION( name, type_name )    \
-template<typename type_name>                                    \
-void BOOST_JOIN( name, _impl )( autoboost::type<type_name>* );      \
-                                                                \
-struct name {                                                   \
-    template<typename TestType>                                 \
-    static void run( autoboost::type<TestType>* frwrd = 0 )         \
-    {                                                           \
-       BOOST_JOIN( name, _impl )( frwrd );                      \
-    }                                                           \
-};                                                              \
-                                                                \
-template<typename type_name>                                    \
-void BOOST_JOIN( name, _impl )( autoboost::type<type_name>* )       \
-/**/
-
-// ************************************************************************** //
-// **************              BOOST_GLOBAL_FIXURE             ************** //
-// ************************************************************************** //
-
-#define BOOST_GLOBAL_FIXTURE( F ) \
-static autoboost::unit_test::ut_detail::global_fixture_impl<F> BOOST_JOIN( gf_, F ) ; \
-/**/
-
-// ************************************************************************** //
-// **************         BOOST_AUTO_TEST_CASE_FIXTURE         ************** //
-// ************************************************************************** //
-
-namespace autoboost { namespace unit_test { namespace ut_detail {
-
-struct nil_t {};
-
-} // namespace ut_detail
-} // unit_test
-} // namespace autoboost
-
-// Intentionally is in global namespace, so that FIXURE_TEST_SUITE can reset it in user code.
-typedef ::autoboost::unit_test::ut_detail::nil_t BOOST_AUTO_TEST_CASE_FIXTURE;
-
-// ************************************************************************** //
-// **************   Auto registration facility helper macros   ************** //
-// ************************************************************************** //
-
-#define BOOST_AUTO_TU_REGISTRAR( test_name )    \
-static autoboost::unit_test::ut_detail::auto_test_unit_registrar BOOST_JOIN( BOOST_JOIN( test_name, _registrar ), __LINE__ )
-#define BOOST_AUTO_TC_INVOKER( test_name )      BOOST_JOIN( test_name, _invoker )
-#define BOOST_AUTO_TC_UNIQUE_ID( test_name )    BOOST_JOIN( test_name, _id )
-
-// ************************************************************************** //
-// **************                BOOST_TEST_MAIN               ************** //
-// ************************************************************************** //
-
-#if defined(BOOST_TEST_MAIN)
-
-#ifdef BOOST_TEST_ALTERNATIVE_INIT_API
-bool init_unit_test()                   {
-#else
-::autoboost::unit_test::test_suite*
-init_unit_test_suite( int, char* [] )   {
-#endif
-
-#ifdef BOOST_TEST_MODULE
-    using namespace ::autoboost::unit_test;
-    assign_op( framework::master_test_suite().p_name.value, BOOST_TEST_STRINGIZE( BOOST_TEST_MODULE ).trim( "\"" ), 0 );
-    
-#endif
-
-#ifdef BOOST_TEST_ALTERNATIVE_INIT_API
-    return true;
-}
-#else
-    return 0;
-}
-#endif
-
-#endif
-
-//____________________________________________________________________________//
-
-#endif // BOOST_TEST_UNIT_TEST_SUITE_HPP_071894GER
-
diff --git a/contrib/autoboost/boost/test/unit_test_suite_impl.hpp b/contrib/autoboost/boost/test/unit_test_suite_impl.hpp
deleted file mode 100644
index a86c1ad27..000000000
--- a/contrib/autoboost/boost/test/unit_test_suite_impl.hpp
+++ /dev/null
@@ -1,434 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines test_unit, test_case, test_case_results, test_suite and test_tree_visitor
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_SUITE_IMPL_HPP_071894GER
-#define BOOST_TEST_UNIT_TEST_SUITE_IMPL_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/utils/class_properties.hpp>
-#include <boost/test/utils/callback.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-#include <boost/test/detail/workaround.hpp>
-#include <boost/test/test_observer.hpp>
-
-// Boost
-#include <boost/shared_ptr.hpp>
-#include <boost/mpl/for_each.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/type.hpp>
-#include <boost/type_traits/is_const.hpp>
-
-// STL
-#include <typeinfo> // for typeid
-#include <string>   // for std::string
-#include <list>     // for std::list
-#include <vector>   // for std::vector
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                   test_unit                  ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL test_unit {
-public:
-    enum { type = tut_any };
-
-    // Constructor
-    test_unit( const_string tu_name, test_unit_type t );
-
-    // dependencies management
-    void    depends_on( test_unit* tu );
-    bool    check_dependencies() const;
-
-    // Public r/o properties
-    typedef BOOST_READONLY_PROPERTY(test_unit_id,(framework_impl))  id_t;
-    typedef BOOST_READONLY_PROPERTY(test_unit_id,(test_suite))      parent_id_t;
-    readonly_property<test_unit_type>   p_type;                 // type for this test unit
-    readonly_property<const_string>     p_type_name;            // "case"/"suite"
-    id_t                                p_id;                   // unique id for this test unit
-    parent_id_t                         p_parent_id;            // parent test suite id
-
-    // Public r/w properties
-    readwrite_property<std::string>     p_name;                 // name for this test unit
-    readwrite_property<unsigned>        p_timeout;              // timeout for the test unit execution 
-    readwrite_property<counter_t>       p_expected_failures;    // number of expected failures in this test unit
-    mutable readwrite_property<bool>    p_enabled;              // enabled status for this unit
-
-    void                                increase_exp_fail( unsigned num );
-
-protected:
-    ~test_unit();
-
-private:
-    // Data members
-    std::list<test_unit_id>             m_dependencies;
-};
-
-// ************************************************************************** //
-// **************              test_case_generator             ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL test_unit_generator {
-public:
-    virtual test_unit*  next() const = 0;
-
-protected:
-    BOOST_TEST_PROTECTED_VIRTUAL ~test_unit_generator() {}
-};
-
-// ************************************************************************** //
-// **************                   test_case                  ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL test_case : public test_unit {
-public:
-    enum { type = tut_case };
-
-    // Constructor
-    test_case( const_string tc_name, callback0<> const& test_func );
-
-    // Access methods
-    callback0<> const&  test_func() const { return m_test_func; }
-
-private:
-    friend class framework_impl;
-    ~test_case() {}
-
-    // BOOST_MSVC <= 1200 have problems with callback as property
-    // Data members
-    callback0<> m_test_func;
-};
-
-// ************************************************************************** //
-// **************                  test_suite                  ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL test_suite : public test_unit {
-public:
-    enum { type = tut_suite };
-
-    // Constructor
-    explicit        test_suite( const_string ts_name );
-
-    // test unit list management
-    void            add( test_unit* tu, counter_t expected_failures = 0, unsigned timeout = 0 );
-    void            add( test_unit_generator const& gen, unsigned timeout = 0 );
-    void            remove( test_unit_id id );
-
-    // access methods
-    test_unit_id    get( const_string tu_name ) const;
-    std::size_t     size() const { return m_members.size(); }
-
-protected:
-    friend BOOST_TEST_DECL 
-    void        traverse_test_tree( test_suite const&, test_tree_visitor& );
-    friend class framework_impl;
-    virtual     ~test_suite() {}
-
-    // Data members
-    std::vector<test_unit_id> m_members;
-};
-
-// ************************************************************************** //
-// **************               master_test_suite              ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL master_test_suite_t : public test_suite {
-public:
-    master_test_suite_t() : test_suite( "Master Test Suite" )
-    , argc( 0 )
-    , argv( 0 )
-    {}
-    
-    // Data members    
-    int      argc;
-    char**   argv;
-};
-
-
-// ************************************************************************** //
-// **************               test_tree_visitor              ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL test_tree_visitor {
-public:
-    // test tree visitor interface
-    virtual void    visit( test_case const& )               {}
-    virtual bool    test_suite_start( test_suite const& )   { return true; }
-    virtual void    test_suite_finish( test_suite const& )  {}
-
-protected:
-    BOOST_TEST_PROTECTED_VIRTUAL ~test_tree_visitor() {}
-};
-
-// ************************************************************************** //
-// **************               traverse_test_tree             ************** //
-// ************************************************************************** //
-
-BOOST_TEST_DECL void    traverse_test_tree( test_case const&, test_tree_visitor& );
-BOOST_TEST_DECL void    traverse_test_tree( test_suite const&, test_tree_visitor& );
-BOOST_TEST_DECL void    traverse_test_tree( test_unit_id     , test_tree_visitor& );
-
-//____________________________________________________________________________//
-
-inline void
-traverse_test_tree( test_unit const& tu, test_tree_visitor& V )
-{
-    if( tu.p_type == tut_case )
-        traverse_test_tree( static_cast<test_case const&>( tu ), V );
-    else
-        traverse_test_tree( static_cast<test_suite const&>( tu ), V );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                test_case_counter             ************** //
-// ************************************************************************** //
-
-class test_case_counter : public test_tree_visitor {
-public:
-    // Constructor
-    test_case_counter() : p_count( 0 ) {}
-
-    BOOST_READONLY_PROPERTY( counter_t, (test_case_counter)) p_count;
-private:
-    // test tree visitor interface
-    virtual void    visit( test_case const& );
-    virtual bool    test_suite_start( test_suite const& ts )    { return ts.p_enabled; }
-};
-
-// ************************************************************************** //
-// **************               test_being_aborted             ************** //
-// ************************************************************************** //
-
-struct BOOST_TEST_DECL test_being_aborted {};
-
-// ************************************************************************** //
-// **************               object generators              ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-BOOST_TEST_DECL std::string normalize_test_case_name( const_string tu_name );
-
-template<typename InstanceType,typename UserTestCase>
-struct user_tc_method_invoker {
-    typedef void (UserTestCase::*TestMethod )();
-
-    user_tc_method_invoker( shared_ptr<InstanceType> inst, TestMethod test_method )
-    : m_inst( inst ), m_test_method( test_method ) {}
-
-    void operator()() { ((*m_inst).*m_test_method)(); }
-
-    shared_ptr<InstanceType> m_inst;
-    TestMethod               m_test_method;
-};
-
-} // namespace ut_detail
-
-//____________________________________________________________________________//
-
-inline test_case*
-make_test_case( callback0<> const& test_func, const_string tc_name )
-{
-    return new test_case( ut_detail::normalize_test_case_name( tc_name ), test_func );
-}
-
-//____________________________________________________________________________//
-
-template<typename UserTestCase, typename InstanceType>
-inline test_case*
-make_test_case( void (UserTestCase::*           test_method )(),
-                const_string                    tc_name,
-                autoboost::shared_ptr<InstanceType> user_test_case )
-{
-    return new test_case( ut_detail::normalize_test_case_name( tc_name ), 
-                          ut_detail::user_tc_method_invoker<InstanceType,UserTestCase>( user_test_case, test_method ) );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************           auto_test_unit_registrar           ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-struct BOOST_TEST_DECL auto_test_unit_registrar
-{
-    // Constructors
-                auto_test_unit_registrar( test_case* tc, counter_t exp_fail );
-    explicit    auto_test_unit_registrar( const_string ts_name );
-    explicit    auto_test_unit_registrar( test_unit_generator const& tc_gen );
-    explicit    auto_test_unit_registrar( int );
-
-private:
-    static std::list<test_suite*>& curr_ts_store();
-};
-
-//____________________________________________________________________________//
-
-template<typename T>
-struct auto_tc_exp_fail {
-    auto_tc_exp_fail() : m_value( 0 ) {}
-
-    explicit    auto_tc_exp_fail( unsigned v )
-    : m_value( v )
-    {
-        instance() = this;
-    }
-
-    static auto_tc_exp_fail*& instance() 
-    {
-        static auto_tc_exp_fail     inst; 
-        static auto_tc_exp_fail*    inst_ptr = &inst; 
-
-        return inst_ptr;
-    }
-
-    unsigned    value() const { return m_value; }
-
-private:
-    // Data members
-    unsigned    m_value;
-};
-
-//____________________________________________________________________________//
-
-} // namespace ut_detail
-
-// ************************************************************************** //
-// **************                global_fixture                ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL global_fixture : public test_observer { 
-public: 
-    // Constructor
-    global_fixture();
-}; 
-
-//____________________________________________________________________________//
-
-namespace ut_detail {
-
-template<typename F> 
-struct global_fixture_impl : public global_fixture {
-    // Constructor
-    global_fixture_impl(): m_fixure( 0 )    {}
-
-    // test observer interface
-    virtual void    test_start( counter_t ) { m_fixure = new F; }
-    virtual void    test_finish()           { delete m_fixure; m_fixure = 0; } 
-    virtual void    test_aborted()          { delete m_fixure; m_fixure = 0; } 
-
-private:
-    // Data members
-    F*  m_fixure;
-}; 
-
-// ************************************************************************** //
-// **************          test_case_template_invoker          ************** //
-// ************************************************************************** //
-
-template<typename TestCaseTemplate,typename TestType>
-class test_case_template_invoker {
-public:
-    void    operator()()    { TestCaseTemplate::run( (autoboost::type<TestType>*)0 ); }
-};
-
-// ************************************************************************** //
-// **************           generate_test_case_4_type          ************** //
-// ************************************************************************** //
-
-template<typename Generator,typename TestCaseTemplate>
-struct generate_test_case_4_type {
-    explicit    generate_test_case_4_type( const_string tc_name, Generator& G )
-    : m_test_case_name( tc_name )
-    , m_holder( G )
-    {}
-
-    template<typename TestType>
-    void        operator()( mpl::identity<TestType> )
-    {
-        std::string full_name;
-        assign_op( full_name, m_test_case_name, 0 );
-        full_name += '<';
-        full_name += typeid(TestType).name();
-        if( autoboost::is_const<TestType>::value )
-            full_name += " const";
-        full_name += '>';
-
-        m_holder.m_test_cases.push_back( 
-            new test_case( full_name, test_case_template_invoker<TestCaseTemplate,TestType>() ) );
-    }
-
-private:
-    // Data members
-    const_string    m_test_case_name;
-    Generator&      m_holder;
-};
-
-// ************************************************************************** //
-// **************              test_case_template              ************** //
-// ************************************************************************** //
-
-template<typename TestCaseTemplate,typename TestTypesList>
-class template_test_case_gen : public test_unit_generator {
-public:
-    // Constructor
-    template_test_case_gen( const_string tc_name )
-    {
-        typedef generate_test_case_4_type<template_test_case_gen<TestCaseTemplate,TestTypesList>,
-                                          TestCaseTemplate
-        > single_test_gen;
-        mpl::for_each<TestTypesList,mpl::make_identity<mpl::_> >( single_test_gen( tc_name, *this ) );
-    }
-
-    virtual test_unit* next() const
-    {
-        if( m_test_cases.empty() )
-            return 0;
-    
-        test_unit* res = m_test_cases.front();
-        m_test_cases.pop_front();
-
-        return res;
-    }
-
-    // Data members
-    mutable std::list<test_unit*> m_test_cases;
-};
-
-//____________________________________________________________________________//
-
-} // namespace ut_detail
-
-} // unit_test
-
-} // namespace autoboost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_SUITE_IMPL_HPP_071894GER
-
diff --git a/contrib/autoboost/boost/test/utils/algorithm.hpp b/contrib/autoboost/boost/test/utils/algorithm.hpp
deleted file mode 100644
index a1f7e07f2..000000000
--- a/contrib/autoboost/boost/test/utils/algorithm.hpp
+++ /dev/null
@@ -1,228 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2004-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : addition to STL algorithms
-// ***************************************************************************
-
-#ifndef BOOST_ALGORITHM_HPP_062304GER
-#define BOOST_ALGORITHM_HPP_062304GER
-
-#include <utility>
-#include <algorithm> // std::find
-#include <functional> // std::bind1st
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-/// @brief this algorithm search through two collections for first mismatch position that get returned as a pair
-/// of iterators, first pointing to the mismatch position in first collection, second iterator in second one
-
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-template <class InputIter1, class InputIter2>
-inline std::pair<InputIter1, InputIter2>
-mismatch( InputIter1 first1, InputIter1 last1,
-          InputIter2 first2, InputIter2 last2 )
-{
-    while( first1 != last1 && first2 != last2 && *first1 == *first2 ) {
-        ++first1;
-        ++first2;
-    }
-
-    return std::pair<InputIter1, InputIter2>(first1, first2);
-}
-
-//____________________________________________________________________________//
-
-/// @brief this algorithm search through two collections for first mismatch position that get returned as a pair
-/// of iterators, first pointing to the mismatch position in first collection, second iterator in second one. This algorithms
-/// uses supplied predicate for collection elements comparison
-
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-/// @param pred - predicate to be used for search
-template <class InputIter1, class InputIter2, class Predicate>
-inline std::pair<InputIter1, InputIter2>
-mismatch( InputIter1 first1, InputIter1 last1,
-          InputIter2 first2, InputIter2 last2,
-          Predicate pred )
-{
-    while( first1 != last1 && first2 != last2 && pred( *first1, *first2 ) ) {
-        ++first1;
-        ++first2;
-    }
-
-    return std::pair<InputIter1, InputIter2>(first1, first2);
-}
-
-//____________________________________________________________________________//
-
-/// @brief this algorithm search through first collection for first element that does not belong a second one
-
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-template<class ForwardIterator1, class ForwardIterator2>
-inline ForwardIterator1
-find_first_not_of( ForwardIterator1 first1, ForwardIterator1 last1, 
-                   ForwardIterator2 first2, ForwardIterator2 last2 )
-{
-    while( first1 != last1 ) {
-        if( std::find( first2, last2, *first1 ) == last2 )
-            break;
-        ++first1;
-    }
-
-    return first1;
-}
-
-//____________________________________________________________________________//
-
-/// @brief this algorithm search through first collection for first element that does not satisfy binary 
-/// predicate in conjunction will any element in second collection
-
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-/// @param pred - predicate to be used for search
-template<class ForwardIterator1, class ForwardIterator2, class Predicate>
-inline ForwardIterator1
-find_first_not_of( ForwardIterator1 first1, ForwardIterator1 last1, 
-                   ForwardIterator2 first2, ForwardIterator2 last2, 
-                   Predicate pred )
-{
-    while( first1 != last1 ) {
-        if( std::find_if( first2, last2, std::bind1st( pred, *first1 ) ) == last2 )
-            break;
-        ++first1;
-    }
-
-    return first1;
-}
-
-//____________________________________________________________________________//
-
-/// @brief this algorithm search through first collection for last element that belongs to a second one
-
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-template<class BidirectionalIterator1, class ForwardIterator2>
-inline BidirectionalIterator1
-find_last_of( BidirectionalIterator1 first1, BidirectionalIterator1 last1, 
-              ForwardIterator2 first2, ForwardIterator2 last2 )
-{
-    if( first1 == last1 || first2 == last2 )
-        return last1;
-
-    BidirectionalIterator1 it1 = last1;
-    while( --it1 != first1 && std::find( first2, last2, *it1 ) == last2 ) {}
-
-    return it1 == first1 && std::find( first2, last2, *it1 ) == last2 ? last1 : it1;
-}
-
-//____________________________________________________________________________//
-
-/// @brief this algorithm search through first collection for last element that satisfy binary 
-/// predicate in conjunction will at least one element in second collection
-
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-/// @param pred - predicate to be used for search
-template<class BidirectionalIterator1, class ForwardIterator2, class Predicate>
-inline BidirectionalIterator1
-find_last_of( BidirectionalIterator1 first1, BidirectionalIterator1 last1, 
-              ForwardIterator2 first2, ForwardIterator2 last2, 
-              Predicate pred )
-{
-    if( first1 == last1 || first2 == last2 )
-        return last1;
-
-    BidirectionalIterator1 it1 = last1;
-    while( --it1 != first1 && std::find_if( first2, last2, std::bind1st( pred, *it1 ) ) == last2 ) {}
-
-    return it1 == first1 && std::find_if( first2, last2, std::bind1st( pred, *it1 ) ) == last2 ? last1 : it1;
-}
-
-//____________________________________________________________________________//
-
-/// @brief this algorithm search through first collection for last element that does not belong to a second one
-
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-template<class BidirectionalIterator1, class ForwardIterator2>
-inline BidirectionalIterator1
-find_last_not_of( BidirectionalIterator1 first1, BidirectionalIterator1 last1, 
-                  ForwardIterator2 first2, ForwardIterator2 last2 )
-{
-    if( first1 == last1 || first2 == last2 )
-        return last1;
-
-    BidirectionalIterator1 it1 = last1;
-    while( --it1 != first1 && std::find( first2, last2, *it1 ) != last2 ) {}
-
-    return it1 == first1 && std::find( first2, last2, *it1 ) != last2 ? last1 : it1;
-}
-
-//____________________________________________________________________________//
-
-/// @brief this algorithm search through first collection for last element that does not satisfy binary 
-/// predicate in conjunction will any element in second collection
-
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-/// @param pred - predicate to be used for search
-template<class BidirectionalIterator1, class ForwardIterator2, class Predicate>
-inline BidirectionalIterator1
-find_last_not_of( BidirectionalIterator1 first1, BidirectionalIterator1 last1, 
-                  ForwardIterator2 first2, ForwardIterator2 last2, 
-                  Predicate pred )
-{
-    if( first1 == last1 || first2 == last2 )
-        return last1;
-
-    BidirectionalIterator1 it1 = last1;
-    while( --it1 != first1 && std::find_if( first2, last2, std::bind1st( pred, *it1 ) ) != last2 ) {}
-
-    return it1 == first1 && std::find_if( first2, last2, std::bind1st( pred, *it1 ) ) == last2 ? last1 : it1;
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_ALGORITHM_HPP_062304GER
-
-
diff --git a/contrib/autoboost/boost/test/utils/assign_op.hpp b/contrib/autoboost/boost/test/utils/assign_op.hpp
deleted file mode 100644
index e0170aba9..000000000
--- a/contrib/autoboost/boost/test/utils/assign_op.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : overloadable assignment
-// ***************************************************************************
-
-#ifndef BOOST_TEST_ASSIGN_OP_033005GER
-#define BOOST_TEST_ASSIGN_OP_033005GER
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************             generic assign operator          ************** //
-// ************************************************************************** //
-
-// generic
-template<typename T,typename S>
-inline void
-assign_op( T& t, S const& s, long )
-{
-    t = s;
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-#endif // BOOST_TEST_ASSIGN_OP_033005GER
-
diff --git a/contrib/autoboost/boost/test/utils/basic_cstring/basic_cstring.hpp b/contrib/autoboost/boost/test/utils/basic_cstring/basic_cstring.hpp
deleted file mode 100644
index 74e8822dc..000000000
--- a/contrib/autoboost/boost/test/utils/basic_cstring/basic_cstring.hpp
+++ /dev/null
@@ -1,731 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2004-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : class basic_cstring wraps C string and provide std_string like 
-//                interface
-// ***************************************************************************
-
-#ifndef BOOST_TEST_BASIC_CSTRING_HPP_071894GER
-#define BOOST_TEST_BASIC_CSTRING_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/utils/basic_cstring/basic_cstring_fwd.hpp>
-#include <boost/test/utils/basic_cstring/bcs_char_traits.hpp>
-
-// STL
-#include <string>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                basic_cstring                 ************** //
-// ************************************************************************** //
-
-template<typename CharT>
-class basic_cstring {
-    typedef basic_cstring<CharT>                        self_type;
-public:
-    // Subtypes
-    typedef ut_detail::bcs_char_traits<CharT>           traits_type;
-    typedef typename ut_detail::bcs_char_traits<CharT>::std_string  std_string;
-
-    typedef CharT                                       value_type;
-    typedef value_type*                                 pointer;
-    typedef value_type const*                           const_pointer;
-    typedef value_type&                                 reference;
-    typedef const value_type&                           const_reference;
-    typedef std::size_t                                 size_type;
-    typedef std::ptrdiff_t                              difference_type;
-
-    typedef value_type const*                           const_iterator;
-    typedef value_type*                                 iterator;
-
-    // !! should also present reverse_iterator, const_reverse_iterator
-
-#if !BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
-    enum npos_type { npos = static_cast<size_type>(-1) };
-#else
-    // IBM/VisualAge version 6 is not able to handle enums larger than 4 bytes.
-    // But size_type is 8 bytes in 64bit mode.
-    static const size_type npos = -1 ;
-#endif
-
-    static pointer  null_str();
-
-    // Constructors; default copy constructor is generated by compiler
-    basic_cstring();
-    basic_cstring( std_string const& s );
-    basic_cstring( pointer s );
-    basic_cstring( pointer s, size_type arg_size );
-    basic_cstring( pointer first, pointer last );
-
-    // data access methods
-    value_type      operator[]( size_type index ) const;
-    value_type      at( size_type index ) const;
-
-    // size operators
-    size_type       size() const;
-    bool            is_empty() const;
-    void            clear();
-    void            resize( size_type new_len );
-
-    // !! only for STL container conformance use is_empty instead
-    bool            empty() const; 
-
-    // Trimming
-    self_type&      trim_right( size_type trim_size );
-    self_type&      trim_left( size_type trim_size );
-    self_type&      trim_right( iterator it );
-    self_type&      trim_left( iterator it );
-#ifndef __IBMCPP__
-    self_type&      trim_left( self_type exclusions = self_type() ) ;
-    self_type&      trim_right( self_type exclusions = self_type() ) ;
-    self_type&      trim( self_type exclusions = self_type() ) ;
-#else
-    // VisualAge version 6 has in this case a problem with the default arguments.
-    self_type&      trim_left( self_type exclusions ) ;
-    self_type&      trim_right( self_type exclusions ) ;
-    self_type&      trim( self_type exclusions ) ;
-    self_type&      trim_left() { trim_left( self_type() ) ; }
-    self_type&      trim_right() { trim_right( self_type() ) ; }
-    self_type&      trim() { trim( self_type() ) ; }
-#endif
-
-    // Assignment operators
-    basic_cstring&  operator=( self_type const& s );
-    basic_cstring&  operator=( std_string const& s );
-    basic_cstring&  operator=( pointer s );
-
-    template<typename CharT2>
-    basic_cstring&  assign( basic_cstring<CharT2> const& s ) { *this = basic_cstring<CharT>( s.begin(), s.end() ); return *this; }
-    basic_cstring&  assign( self_type const& s, size_type pos, size_type len );
-    basic_cstring&  assign( std_string const& s );
-    basic_cstring&  assign( std_string const& s, size_type pos, size_type len );
-    basic_cstring&  assign( pointer s );
-    basic_cstring&  assign( pointer s, size_type len );
-    basic_cstring&  assign( pointer f, pointer l );
-
-    // swapping
-    void            swap( self_type& s );
-
-    // Iterators
-    iterator        begin();
-    const_iterator  begin() const;
-    iterator        end();
-    const_iterator  end() const;
-
-    // !! should have rbegin, rend
-
-    // substring search operation
-    size_type       find( basic_cstring ) const;
-    size_type       rfind( basic_cstring ) const;
-    self_type       substr( size_type beg_index, size_type end_index = npos ) const;
-
-private:
-    static self_type default_trim_ex();
-
-    // Data members
-    iterator        m_begin;
-    iterator        m_end;
-};
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::pointer
-basic_cstring<CharT>::null_str()
-{
-    static CharT null = 0;
-    return &null;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline
-basic_cstring<CharT>::basic_cstring()
-: m_begin( null_str() )
-, m_end( m_begin )
-{
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline
-basic_cstring<CharT>::basic_cstring( std_string const& s )
-: m_begin( s.c_str() )
-, m_end( m_begin + s.size() )
-{
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline
-basic_cstring<CharT>::basic_cstring( pointer s )
-: m_begin( s ? s : null_str() )
-, m_end  ( m_begin + (s ? traits_type::length( s ) : 0 ) )
-{
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline
-basic_cstring<CharT>::basic_cstring( pointer s, size_type arg_size )
-: m_begin( s ), m_end( m_begin + arg_size )
-{
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline
-basic_cstring<CharT>::basic_cstring( pointer first, pointer last )
-: m_begin( first )
-, m_end( last )
-{
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::value_type
-basic_cstring<CharT>::operator[]( size_type index ) const
-{
-    return m_begin[index];
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::value_type
-basic_cstring<CharT>::at( size_type index ) const
-{
-    if( m_begin + index >= m_end )
-        return static_cast<value_type>(0);
-
-    return m_begin[index];
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::size_type
-basic_cstring<CharT>::size() const
-{
-    return m_end - m_begin;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-basic_cstring<CharT>::is_empty() const
-{
-    return m_end == m_begin;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-basic_cstring<CharT>::empty() const
-{
-    return is_empty();
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline void
-basic_cstring<CharT>::clear()
-{
-    m_begin = m_end;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline void
-basic_cstring<CharT>::resize( size_type new_len )
-{
-    if( m_begin + new_len < m_end )
-        m_end = m_begin + new_len;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::trim_left( size_type trim_size )
-{
-    m_begin += trim_size;
-    if( m_end <= m_begin )
-        clear();
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::trim_left( iterator it )
-{
-    m_begin = it;
-    if( m_end <= m_begin )
-        clear();
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::trim_left( basic_cstring exclusions )
-{
-    if( exclusions.is_empty() )
-        exclusions = default_trim_ex();
-
-    iterator it;
-    for( it = begin(); it != end(); ++it ) {
-        if( traits_type::find( exclusions.begin(), exclusions.size(), *it ) == reinterpret_cast<pointer>(0) )
-            break;
-    }
-    
-    return trim_left( it );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::trim_right( size_type trim_size )
-{
-    m_end  -= trim_size;
-    if( m_end <= m_begin )
-        clear();
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::trim_right( iterator it )
-{
-    m_end = it;
-    if( m_end <= m_begin )
-        clear();
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::trim_right( basic_cstring exclusions )
-{
-    if( exclusions.is_empty() )
-        exclusions = default_trim_ex();
-
-    iterator it;
-
-    for( it = end()-1; it != begin()-1; --it ) {
-        if( self_type::traits_type::find( exclusions.begin(),  exclusions.size(), *it ) == reinterpret_cast<pointer>(0) )
-            break;
-    }
-    
-    return trim_right( it+1 );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::trim( basic_cstring exclusions )
-{
-    trim_left( exclusions );
-    trim_right( exclusions );
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::operator=( basic_cstring<CharT> const& s )
-{
-    m_begin = s.m_begin;
-    m_end   = s.m_end;
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::operator=( std_string const& s )
-{
-    return *this = self_type( s );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::operator=( pointer s )
-{
-    return *this = self_type( s );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::assign( basic_cstring<CharT> const& s, size_type pos, size_type len )
-{
-    return *this = self_type( s.m_begin + pos, len );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::assign( std_string const& s )
-{
-    return *this = self_type( s );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::assign( std_string const& s, size_type pos, size_type len )
-{
-    return *this = self_type( s.c_str() + pos, len );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::assign( pointer s )
-{
-    return *this = self_type( s );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::assign( pointer s, size_type len )
-{
-    return *this = self_type( s, len );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::assign( pointer f, pointer l )
-{
-    return *this = self_type( f, l );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline void
-basic_cstring<CharT>::swap( basic_cstring<CharT>& s )
-{
-    // do not want to include alogrithm
-    pointer tmp1    = m_begin;
-    pointer tmp2    = m_end;
-
-    m_begin         = s.m_begin;
-    m_end           = s.m_end;
-
-    s.m_begin       = tmp1;
-    s.m_end         = tmp2;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::iterator
-basic_cstring<CharT>::begin()
-{
-    return m_begin;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::const_iterator
-basic_cstring<CharT>::begin() const
-{
-    return m_begin;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::iterator
-basic_cstring<CharT>::end()
-{
-    return m_end;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::const_iterator
-basic_cstring<CharT>::end() const
-{
-    return m_end;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::size_type
-basic_cstring<CharT>::find( basic_cstring<CharT> str ) const
-{
-    if( str.is_empty() || str.size() > size() )
-        return static_cast<size_type>(npos);
-
-    const_iterator it   = begin();
-    const_iterator last = end() - str.size() + 1;
-
-    while( it != last ) {
-        if( traits_type::compare( it, str.begin(), str.size() ) == 0 )
-            break;
-
-        ++it;
-    }
-
-    return it == last ? static_cast<size_type>(npos) : it - begin();
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::size_type
-basic_cstring<CharT>::rfind( basic_cstring<CharT> str ) const
-{
-    if( str.is_empty() || str.size() > size() )
-        return static_cast<size_type>(npos);
-
-    const_iterator it   = end() - str.size();
-    const_iterator last = begin()-1;
-
-    while( it != last ) {
-        if( traits_type::compare( it, str.begin(), str.size() ) == 0 )
-            break;
-
-        --it;
-    }
-
-    return it == last ? static_cast<size_type>(npos) : static_cast<size_type>(it - begin());
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>
-basic_cstring<CharT>::substr( size_type beg_index, size_type end_index ) const
-{
-    return beg_index > size()
-            ?       self_type()
-            : end_index > size()
-                ?   self_type( m_begin + beg_index, m_end )
-                :   self_type( m_begin + beg_index, m_begin + end_index );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>
-basic_cstring<CharT>::default_trim_ex()
-{
-    static CharT ws[3] = { CharT(' '), CharT('\t'), CharT('\n') }; // !! wide case
-
-    return self_type( ws, 3 );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************             comparison operators             ************** //
-// ************************************************************************** //
-
-template<typename CharT1,typename CharT2>
-inline bool
-operator==( basic_cstring<CharT1> const& s1, basic_cstring<CharT2> const& s2 )
-{
-    typedef typename basic_cstring<CharT1>::traits_type traits_type;
-    return s1.size() == s2.size() && 
-               traits_type::compare( s1.begin(), s2.begin(), s1.size() ) == 0;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT1,typename CharT2>
-inline bool
-operator==( basic_cstring<CharT1> const& s1, CharT2* s2 )
-{
-#if !defined(__DMC__)
-    return s1 == basic_cstring<CharT2>( s2 );
-#else
-    return s1 == basic_cstring<CharT2 const>( s2 );
-#endif
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-operator==( basic_cstring<CharT> const& s1, typename basic_cstring<CharT>::std_string const& s2 )
-{
-    return s1 == basic_cstring<CharT>( s2 );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT1,typename CharT2>
-inline bool
-operator==( CharT1* s2, basic_cstring<CharT2> const& s1 )
-{
-    return s1 == s2;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-operator==( typename basic_cstring<CharT>::std_string const& s2, basic_cstring<CharT> const& s1 )
-{
-    return s1 == s2;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-operator!=( basic_cstring<CharT> const& s1, CharT* s2 )
-{
-    return !(s1 == s2);
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-operator!=( CharT* s2, basic_cstring<CharT> const& s1 )
-{
-    return !(s1 == s2);
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-operator!=( basic_cstring<CharT> const& s1, basic_cstring<CharT> const& s2 )
-{
-    return !(s1 == s2);
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-operator!=( basic_cstring<CharT> const& s1, typename basic_cstring<CharT>::std_string const& s2 )
-{
-    return !(s1 == s2);
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-operator!=( typename basic_cstring<CharT>::std_string const& s2, basic_cstring<CharT> const& s1 )
-{
-    return !(s1 == s2);
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  first_char                  ************** //
-// ************************************************************************** //
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::value_type
-first_char( basic_cstring<CharT> source )
-{
-    typedef typename basic_cstring<CharT>::value_type string_value_type;
-
-    return source.is_empty() ? static_cast<string_value_type>(0) : *source.begin();
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  last_char                   ************** //
-// ************************************************************************** //
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::value_type
-last_char( basic_cstring<CharT> source )
-{
-    typedef typename basic_cstring<CharT>::value_type string_value_type;
-
-    return source.is_empty() ? static_cast<string_value_type>(0) : *(source.end()-1);
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  assign_op                   ************** //
-// ************************************************************************** //
-
-template<typename CharT1, typename CharT2>
-inline void
-assign_op( std::basic_string<CharT1>& target, basic_cstring<CharT2> src, int )
-{
-    target.assign( src.begin(), src.size() );
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_BASIC_CSTRING_HPP_071894GER
diff --git a/contrib/autoboost/boost/test/utils/basic_cstring/basic_cstring_fwd.hpp b/contrib/autoboost/boost/test/utils/basic_cstring/basic_cstring_fwd.hpp
deleted file mode 100644
index de49e2a16..000000000
--- a/contrib/autoboost/boost/test/utils/basic_cstring/basic_cstring_fwd.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2004-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : basic_cstring class wrap C string and provide std_string like 
-//                interface
-// ***************************************************************************
-
-#ifndef BOOST_TEST_BASIC_CSTRING_FWD_HPP_071894GER
-#define BOOST_TEST_BASIC_CSTRING_FWD_HPP_071894GER
-
-#include <boost/detail/workaround.hpp>
-
-namespace autoboost {
-
-namespace unit_test {
-
-template<typename CharT> class      basic_cstring;
-typedef basic_cstring<char const>   const_string;
-#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590041))
-typedef const_string                literal_string;
-#else
-typedef const_string const          literal_string;
-#endif
-
-typedef char const* const           c_literal_string;
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-#endif // BOOST_TEST_BASIC_CSTRING_FWD_HPP_071894GER
-
diff --git a/contrib/autoboost/boost/test/utils/basic_cstring/bcs_char_traits.hpp b/contrib/autoboost/boost/test/utils/basic_cstring/bcs_char_traits.hpp
deleted file mode 100644
index b33fe0850..000000000
--- a/contrib/autoboost/boost/test/utils/basic_cstring/bcs_char_traits.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2004-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : generic char traits class; wraps std::char_traits
-// ***************************************************************************
-
-#ifndef BOOST_TEST_BCS_CHAR_TRAITS_HPP_071894GER
-#define BOOST_TEST_BCS_CHAR_TRAITS_HPP_071894GER
-
-// Boost
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/test/detail/config.hpp>
-#include <boost/type_traits/add_const.hpp>
-
-// STL
-#include <string>                       // std::char_traits
-#include <cstddef>                      // std::size_t
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-namespace ut_detail {
-
-template<typename CharT> struct bcs_base_char           { typedef CharT type; };
-
-template<> struct bcs_base_char<char const>             { typedef char type; };
-template<> struct bcs_base_char<unsigned char>          { typedef char type; };
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-template<> struct bcs_base_char<unsigned char const>    { typedef char type; };
-#endif
-
-template<> struct bcs_base_char<wchar_t const>          { typedef wchar_t type; };
-
-// ************************************************************************** //
-// **************               bcs_char_traits                ************** //
-// ************************************************************************** //
-
-template<typename CharT>
-struct bcs_char_traits_impl
-{
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-    typedef CharT const const_char;
-#else
-    typedef typename autoboost::add_const<CharT>::type const_char;
-#endif
-    static bool eq( CharT c1, CharT c2 )
-    {
-        return c1 == c2;
-    }
-    static bool lt( CharT c1, CharT c2 )
-    {
-        return c1 < c2;
-    }
-
-    static int compare( const_char* cstr1, const_char* cstr2, std::size_t n )
-    {
-        while( n > 0 ) {
-            if( !eq( *cstr1, *cstr2 ) )
-                return lt( *cstr1, *cstr2 ) ? -1 : 1;
-            ++cstr1;
-            ++cstr2;
-            --n;
-        }
-
-        return 0;
-    }
-
-    static std::size_t length( const_char* cstr )
-    {
-        const_char null_char = CharT();
-
-        const_char* ptr = cstr;
-        while( !eq( *ptr, null_char ) )
-            ++ptr;
-
-        return ptr - cstr;
-    }
-
-    static const_char* find( const_char* s, std::size_t n, CharT c )
-    {
-        while( n > 0 ) {
-            if( eq( *s, c ) )
-                return s;
-
-            ++s;
-            --n;
-        }
-        return 0;
-    }
-};
-
-#ifdef BOOST_CLASSIC_IOSTREAMS
-template<typename CharT>
-struct char_traits_with_find : std::string_char_traits<CharT> {
-    static CharT const* find( CharT const* s, std::size_t n, CharT c )
-    {
-        while( n > 0 ) {
-            if( eq( *s, c ) )
-                return s;
-
-            ++s;
-            --n;
-        }
-        return 0;
-    }
-};
-
-template<> struct bcs_char_traits_impl<char> : char_traits_with_find<char> {};
-template<> struct bcs_char_traits_impl<wchar_t> : char_traits_with_find<wchar_t> {};
-#else
-template<> struct bcs_char_traits_impl<char> : std::char_traits<char> {};
-template<> struct bcs_char_traits_impl<wchar_t> : std::char_traits<wchar_t> {};
-#endif
-
-template<typename CharT>
-class bcs_char_traits : public bcs_char_traits_impl<CharT> {
-    typedef typename ut_detail::bcs_base_char<CharT>::type                              the_base_char;
-public:
-#ifdef BOOST_CLASSIC_IOSTREAMS
-    typedef std::basic_string<the_base_char, std::string_char_traits<the_base_char> >   std_string;
-#else
-    typedef std::basic_string<the_base_char, std::char_traits<the_base_char> >          std_string;
-#endif
-};
-
-} // namespace ut_detail
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_BCS_CHAR_TRAITS_HPP_071894GER
diff --git a/contrib/autoboost/boost/test/utils/basic_cstring/compare.hpp b/contrib/autoboost/boost/test/utils/basic_cstring/compare.hpp
deleted file mode 100644
index ac3038a98..000000000
--- a/contrib/autoboost/boost/test/utils/basic_cstring/compare.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2004-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : class basic_cstring comparisons implementation
-// ***************************************************************************
-
-#ifndef  BOOST_TEST_BASIC_CSTRING_COMPARE_HPP_071894GER
-#define  BOOST_TEST_BASIC_CSTRING_COMPARE_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-
-// STL
-#include <functional>
-#include <cctype>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-# if defined(BOOST_NO_STDC_NAMESPACE) && !BOOST_WORKAROUND(__BORLANDC__, <= 0x570)
-namespace std { using ::toupper; }
-# endif
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                case_ins_compare              ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-template<class CharT>
-struct case_ins
-{
-    static bool         eq( CharT c1, CharT c2 ) { return (std::toupper)( c1 ) == (std::toupper)( c2 ); }
-    static bool         lt( CharT c1, CharT c2 ) { return (std::toupper)( c1 ) <  (std::toupper)( c2 ); }
-
-    static int          compare( CharT const* s1, CharT const* s2, std::size_t n )
-    {
-        for( std::size_t i = 0; i < n; ++i ) {
-            if( !eq( s1[i], s2[i] ) )
-                return lt( s1[i], s2[i] ) ? -1 : 1;
-        }
-        return 0;
-    }
-};
-
-} // namespace ut_detail
-
-// ************************************************************************** //
-// **************                  case_ins_eq                 ************** //
-// ************************************************************************** //
-
-template<class CharT>
-inline bool
-case_ins_eq( basic_cstring<CharT> x, basic_cstring<CharT> y )
-{
-    return x.size() == y.size() && ut_detail::case_ins<CharT>::compare( x.begin(), y.begin(), x.size() ) == 0;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 case_ins_less                ************** //
-// ************************************************************************** //
-
-template<class CharT>
-class case_ins_less : public std::binary_function<basic_cstring<CharT>,basic_cstring<CharT>,bool>
-{
-public:
-    bool operator()( basic_cstring<CharT> x, basic_cstring<CharT> y ) const
-    {
-        return x.size() != y.size() 
-                ? x.size() < y.size() 
-                : ut_detail::case_ins<CharT>::compare( x.begin(), y.begin(), x.size() ) < 0;
-    }
-};
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  operator <                  ************** //
-// ************************************************************************** //
-
-template<class CharT>
-inline bool
-operator <( autoboost::unit_test::basic_cstring<CharT> const& x,
-            autoboost::unit_test::basic_cstring<CharT> const& y )
-{
-    typedef typename autoboost::unit_test::basic_cstring<CharT>::traits_type traits_type;
-    return x.size() != y.size() 
-            ? x.size() < y.size() 
-            : traits_type::compare( x.begin(), y.begin(), x.size() ) < 0;
-}
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_BASIC_CSTRING_COMPARE_HPP_071894GER
diff --git a/contrib/autoboost/boost/test/utils/basic_cstring/io.hpp b/contrib/autoboost/boost/test/utils/basic_cstring/io.hpp
deleted file mode 100644
index 0a738e69e..000000000
--- a/contrib/autoboost/boost/test/utils/basic_cstring/io.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2004-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : basic_cstring i/o implementation
-// ***************************************************************************
-
-#ifndef  BOOST_TEST_BASIC_CSTRING_IO_HPP_071894GER
-#define  BOOST_TEST_BASIC_CSTRING_IO_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-
-// STL
-#include <iosfwd>
-#include <string>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-#ifdef BOOST_CLASSIC_IOSTREAMS
-
-template<typename CharT>
-inline std::ostream&
-operator<<( std::ostream& os, basic_cstring<CharT> const& str )
-{
-    typedef typename ut_detail::bcs_base_char<CharT>::type char_type;
-    char_type const* const beg = reinterpret_cast<char_type const* const>( str.begin() );
-    char_type const* const end = reinterpret_cast<char_type const* const>( str.end() );
-    os << std::basic_string<char_type>( beg, end - beg );
-
-    return os;
-}
-
-#else
-
-template<typename CharT1, typename Tr,typename CharT2>
-inline std::basic_ostream<CharT1,Tr>&
-operator<<( std::basic_ostream<CharT1,Tr>& os, basic_cstring<CharT2> const& str )
-{
-    CharT1 const* const beg = reinterpret_cast<CharT1 const*>( str.begin() ); // !!
-    CharT1 const* const end = reinterpret_cast<CharT1 const*>( str.end() );
-    os << std::basic_string<CharT1,Tr>( beg, end - beg );
-
-    return os;
-}
-
-#endif
-
-//____________________________________________________________________________//
-
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_BASIC_CSTRING_IO_HPP_071894GER
diff --git a/contrib/autoboost/boost/test/utils/callback.hpp b/contrib/autoboost/boost/test/utils/callback.hpp
deleted file mode 100644
index 749946fbc..000000000
--- a/contrib/autoboost/boost/test/utils/callback.hpp
+++ /dev/null
@@ -1,310 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : 
-// ***************************************************************************
-
-#ifndef BOOST_TEST_CALLBACK_020505GER
-#define BOOST_TEST_CALLBACK_020505GER
-
-// Boost
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/shared_ptr.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) || BOOST_WORKAROUND(BOOST_INTEL, <= 700)
-#  define BOOST_CALLBACK_EXPLICIT_COPY_CONSTRUCTOR
-#endif
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-namespace ut_detail {
-
-struct unused {};
-
-template<typename R>
-struct invoker {
-    template<typename Functor>
-    R       invoke( Functor& f )                        { return f(); }
-    template<typename Functor, typename T1>
-    R       invoke( Functor& f, T1 t1 )                 { return f( t1 ); }
-    template<typename Functor, typename T1, typename T2>
-    R       invoke( Functor& f, T1 t1, T2 t2 )          { return f( t1, t2 ); }
-    template<typename Functor, typename T1, typename T2, typename T3>
-    R       invoke( Functor& f, T1 t1, T2 t2, T3 t3 )   { return f( t1, t2, t3 ); }
-};
-
-//____________________________________________________________________________//
-
-template<>
-struct invoker<unused> {
-    template<typename Functor>
-    unused  invoke( Functor& f )                        { f(); return unused(); }
-    template<typename Functor, typename T1>
-    unused  invoke( Functor& f, T1 t1 )                 { f( t1 ); return unused(); }
-    template<typename Functor, typename T1, typename T2>
-    unused  invoke( Functor& f, T1 t1, T2 t2 )          { f( t1, t2 ); return unused(); }
-    template<typename Functor, typename T1, typename T2, typename T3>
-    unused  invoke( Functor& f, T1 t1, T2 t2, T3 t3 )   { f( t1, t2, t3 ); return unused(); }
-};
-
-//____________________________________________________________________________//
-
-} // namespace ut_detail
-
-// ************************************************************************** //
-// **************             unit_test::callback0             ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-template<typename R>
-struct callback0_impl {
-    virtual ~callback0_impl() {}
-
-    virtual R invoke() = 0;
-};
-
-//____________________________________________________________________________//
-
-template<typename R, typename Functor>
-struct callback0_impl_t : callback0_impl<R> {
-    // Constructor
-    explicit callback0_impl_t( Functor f ) : m_f( f ) {}
-
-    virtual R invoke() { return invoker<R>().invoke( m_f ); }
-
-private:
-    // Data members
-    Functor m_f;
-};
-
-//____________________________________________________________________________//
-
-} // namespace ut_detail
-
-template<typename R = ut_detail::unused>
-class callback0 {
-public:
-    // Constructors
-    callback0() {}
-#ifdef BOOST_CALLBACK_EXPLICIT_COPY_CONSTRUCTOR
-    callback0( callback0 const& rhs ) : m_impl( rhs.m_impl ) {}
-#endif
-
-    template<typename Functor>
-    callback0( Functor f )
-    : m_impl( new ut_detail::callback0_impl_t<R,Functor>( f ) ) {}
-    
-    void        operator=( callback0 const& rhs ) { m_impl = rhs.m_impl; }
-
-    template<typename Functor>
-    void        operator=( Functor f ) { m_impl.reset( new ut_detail::callback0_impl_t<R,Functor>( f ) );  }
-
-    R           operator()() const { return m_impl->invoke(); }
-
-    bool        operator!() const { return !m_impl; }
-
-private:
-    // Data members
-    autoboost::shared_ptr<ut_detail::callback0_impl<R> > m_impl;
-};
-
-// ************************************************************************** //
-// **************             unit_test::callback1             ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-template<typename R, typename T1>
-struct callback1_impl {
-    virtual ~callback1_impl() {}
-
-    virtual R invoke( T1 t1 ) = 0;
-};
-
-//____________________________________________________________________________//
-
-template<typename R, typename T1,typename Functor>
-struct callback1_impl_t : callback1_impl<R,T1> {
-    // Constructor
-    explicit callback1_impl_t( Functor f ) : m_f( f ) {}
-
-    virtual R invoke( T1 t1 ) { return invoker<R>().invoke( m_f, t1 ); }
-
-private:
-    // Data members
-    Functor m_f;
-};
-
-//____________________________________________________________________________//
-
-} // namespace ut_detail
-
-template<typename T1,typename R = ut_detail::unused>
-class callback1 {
-public:
-    // Constructors
-    callback1() {}
-#ifdef BOOST_CALLBACK_EXPLICIT_COPY_CONSTRUCTOR
-    callback1( callback1 const& rhs ) : m_impl( rhs.m_impl ) {}
-#endif
-
-    template<typename Functor>
-    callback1( Functor f )
-    : m_impl( new ut_detail::callback1_impl_t<R,T1,Functor>( f ) ) {}
-
-    void        operator=( callback1 const& rhs ) { m_impl = rhs.m_impl; }
-
-    template<typename Functor>
-    void        operator=( Functor f ) { m_impl.reset( new ut_detail::callback1_impl_t<R,T1,Functor>( f ) );  }
-
-    R           operator()( T1 t1 ) const { return m_impl->invoke( t1 ); }
-
-    bool        operator!() const { return !m_impl; }
-
-private:
-    // Data members
-    autoboost::shared_ptr<ut_detail::callback1_impl<R,T1> > m_impl;
-};
-
-// ************************************************************************** //
-// **************             unit_test::callback2             ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-template<typename R, typename T1,typename T2>
-struct callback2_impl {
-    virtual ~callback2_impl() {}
-
-    virtual R invoke( T1 t1, T2 t2 ) = 0;
-};
-
-//____________________________________________________________________________//
-
-template<typename R, typename T1, typename T2, typename Functor>
-struct callback2_impl_t : callback2_impl<R,T1,T2> {
-    // Constructor
-    explicit callback2_impl_t( Functor f ) : m_f( f ) {}
-
-    virtual R invoke( T1 t1, T2 t2 ) { return invoker<R>().template invoke<Functor,T1,T2>( m_f, t1, t2 ); }
-
-private:
-    // Data members
-    Functor m_f;
-};
-
-//____________________________________________________________________________//
-
-} // namespace ut_detail
-
-template<typename T1,typename T2, typename R = ut_detail::unused>
-class callback2 {
-public:
-    // Constructors
-    callback2() {}
-#ifdef BOOST_CALLBACK_EXPLICIT_COPY_CONSTRUCTOR
-    callback2( callback2 const& rhs ) : m_impl( rhs.m_impl ) {}
-#endif
-
-    template<typename Functor>
-                callback2( Functor f ) : m_impl( new ut_detail::callback2_impl_t<R,T1,T2,Functor>( f ) ) {}
-
-    void        operator=( callback2 const& rhs ) { m_impl = rhs.m_impl; }
-
-    template<typename Functor>
-    void        operator=( Functor f ) { m_impl.reset( new ut_detail::callback2_impl_t<R,T1,T2,Functor>( f ) );  }
-
-    R           operator()( T1 t1, T2 t2 ) const { return m_impl->invoke( t1, t2 ); }
-
-    bool        operator!() const { return !m_impl; }
-
-private:
-    // Data members
-    autoboost::shared_ptr<ut_detail::callback2_impl<R,T1,T2> > m_impl;
-};
-
-// ************************************************************************** //
-// **************             unit_test::callback3             ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-template<typename R, typename T1, typename T2, typename T3>
-struct callback3_impl {
-    virtual ~callback3_impl() {}
-
-    virtual R invoke( T1 t1, T2 t2, T3 t3 ) = 0;
-};
-
-//____________________________________________________________________________//
-
-template<typename R, typename T1, typename T2, typename T3, typename Functor>
-struct callback3_impl_t : callback3_impl<R,T1,T2,T3> {
-    // Constructor
-    explicit callback3_impl_t( Functor f ) : m_f( f ) {}
-
-    virtual R invoke( T1 t1, T2 t2, T3 t3 ) { return invoker<R>().invoke( m_f, t1, t2, t3 ); }
-
-private:
-    // Data members
-    Functor m_f;
-};
-
-//____________________________________________________________________________//
-
-} // namespace ut_detail
-
-template<typename T1,typename T2, typename T3, typename R = ut_detail::unused>
-class callback3 {
-public:
-    // Constructors
-    callback3() {}
-#ifdef BOOST_CALLBACK_EXPLICIT_COPY_CONSTRUCTOR
-    callback3( callback3 const& rhs ) : m_impl( rhs.m_impl ) {}
-#endif
-
-    template<typename Functor>
-    callback3( Functor f )
-    : m_impl( new ut_detail::callback3_impl_t<R,T1,T2,T3,Functor>( f ) ) {}
-
-    void        operator=( callback3 const& rhs ) { m_impl = rhs.m_impl; }
-
-    template<typename Functor>
-    void        operator=( Functor f ) { m_impl.reset( new ut_detail::callback3_impl_t<R,T1,T2,T3,Functor>( f ) );  }
-
-    R           operator()( T1 t1, T2 t2, T3 t3 ) const { return m_impl->invoke( t1, t2, t3 ); }
-
-    bool        operator!() const { return !m_impl; }
-
-private:
-    // Data members
-    autoboost::shared_ptr<ut_detail::callback3_impl<R,T1,T2,T3> > m_impl;
-};
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-#undef BOOST_CALLBACK_EXPLICIT_COPY_CONSTRUCTOR
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_CALLBACK_020505GER
diff --git a/contrib/autoboost/boost/test/utils/class_properties.hpp b/contrib/autoboost/boost/test/utils/class_properties.hpp
deleted file mode 100644
index 4df8b78b0..000000000
--- a/contrib/autoboost/boost/test/utils/class_properties.hpp
+++ /dev/null
@@ -1,221 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : simple facility that mimmic notion of read-only read-write 
-//  properties in C++ classes. Original idea by Henrik Ravn.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_CLASS_PROPERTIES_HPP_071894GER
-#define BOOST_TEST_CLASS_PROPERTIES_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-
-// Boost
-#if !BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
-#include <boost/preprocessor/seq/for_each.hpp>
-#endif
-#include <boost/call_traits.hpp>
-#include <boost/type_traits/add_pointer.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/utility/addressof.hpp>
-
-// STL
-#include <iosfwd>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                 class_property               ************** //
-// ************************************************************************** //
-
-template<class PropertyType>
-class class_property {
-protected:
-    typedef typename call_traits<PropertyType>::const_reference     read_access_t;
-    typedef typename call_traits<PropertyType>::param_type          write_param_t;
-    typedef typename add_pointer<typename add_const<PropertyType>::type>::type address_res_t;
-public:
-    // Constructor
-                    class_property() : value( PropertyType() ) {}
-    explicit        class_property( write_param_t init_value )
-    : value( init_value ) {}
-
-    // Access methods
-    operator        read_access_t() const   { return value; }
-    read_access_t   get() const             { return value; }
-    bool            operator!() const       { return !value; }
-    address_res_t   operator&() const       { return &value; }
-
-    // Data members
-#ifndef BOOST_TEST_NO_PROTECTED_USING
-protected:
-#endif
-    PropertyType        value;
-};
-
-//____________________________________________________________________________//
-
-#ifdef BOOST_CLASSIC_IOSTREAMS
-
-template<class PropertyType>
-inline std::ostream&
-operator<<( std::ostream& os, class_property<PropertyType> const& p )
-
-#else
-
-template<typename CharT1, typename Tr,class PropertyType>
-inline std::basic_ostream<CharT1,Tr>&
-operator<<( std::basic_ostream<CharT1,Tr>& os, class_property<PropertyType> const& p )
-
-#endif
-{
-    return os << p.get();
-}
-
-//____________________________________________________________________________//
-
-#define DEFINE_PROPERTY_FREE_BINARY_OPERATOR( op )                              \
-template<class PropertyType>                                                    \
-inline bool                                                                     \
-operator op( PropertyType const& lhs, class_property<PropertyType> const& rhs ) \
-{                                                                               \
-    return lhs op rhs.get();                                                    \
-}                                                                               \
-template<class PropertyType>                                                    \
-inline bool                                                                     \
-operator op( class_property<PropertyType> const& lhs, PropertyType const& rhs ) \
-{                                                                               \
-    return lhs.get() op rhs;                                                    \
-}                                                                               \
-template<class PropertyType>                                                    \
-inline bool                                                                     \
-operator op( class_property<PropertyType> const& lhs,                           \
-             class_property<PropertyType> const& rhs )                          \
-{                                                                               \
-    return lhs.get() op rhs.get();                                              \
-}                                                                               \
-/**/
-
-DEFINE_PROPERTY_FREE_BINARY_OPERATOR( == )
-DEFINE_PROPERTY_FREE_BINARY_OPERATOR( != )
-
-#undef DEFINE_PROPERTY_FREE_BINARY_OPERATOR
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-
-#define DEFINE_PROPERTY_LOGICAL_OPERATOR( op )                                  \
-template<class PropertyType>                                                    \
-inline bool                                                                     \
-operator op( bool b, class_property<PropertyType> const& p )                    \
-{                                                                               \
-    return b op p.get();                                                        \
-}                                                                               \
-template<class PropertyType>                                                    \
-inline bool                                                                     \
-operator op( class_property<PropertyType> const& p, bool b )                    \
-{                                                                               \
-    return b op p.get();                                                        \
-}                                                                               \
-/**/
-
-DEFINE_PROPERTY_LOGICAL_OPERATOR( && )
-DEFINE_PROPERTY_LOGICAL_OPERATOR( || )
-
-#endif
-
-// ************************************************************************** //
-// **************               readonly_property              ************** //
-// ************************************************************************** //
-
-template<class PropertyType>
-class readonly_property : public class_property<PropertyType> {
-    typedef class_property<PropertyType>         base_prop;
-    typedef typename base_prop::address_res_t    arrow_res_t;
-protected:
-    typedef typename base_prop::write_param_t    write_param_t;
-public:
-    // Constructor
-                    readonly_property() {}
-    explicit        readonly_property( write_param_t init_value ) : base_prop( init_value ) {}
-
-    // access methods
-    arrow_res_t     operator->() const      { return autoboost::addressof( base_prop::value ); }
-};
-
-//____________________________________________________________________________//
-
-#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
-
-#define BOOST_READONLY_PROPERTY( property_type, friends ) autoboost::unit_test::readwrite_property<property_type >
-
-#else
-
-#define BOOST_READONLY_PROPERTY_DECLARE_FRIEND(r, data, elem) friend class elem;
-
-#define BOOST_READONLY_PROPERTY( property_type, friends )                           \
-class BOOST_JOIN( readonly_property, __LINE__ )                                     \
-: public autoboost::unit_test::readonly_property<property_type > {                      \
-    typedef autoboost::unit_test::readonly_property<property_type > base_prop;          \
-    BOOST_PP_SEQ_FOR_EACH( BOOST_READONLY_PROPERTY_DECLARE_FRIEND, ' ', friends )   \
-    typedef base_prop::write_param_t  write_param_t;                                \
-public:                                                                             \
-                BOOST_JOIN( readonly_property, __LINE__ )() {}                      \
-    explicit    BOOST_JOIN( readonly_property, __LINE__ )( write_param_t init_v  )  \
-    : base_prop( init_v ) {}                                                        \
-}                                                                                   \
-/**/
-
-#endif
-
-// ************************************************************************** //
-// **************              readwrite_property              ************** //
-// ************************************************************************** //
-
-template<class PropertyType>
-class readwrite_property : public class_property<PropertyType> {
-    typedef class_property<PropertyType>                base_prop;
-    typedef typename add_pointer<PropertyType>::type    arrow_res_t;
-    typedef typename base_prop::address_res_t           const_arrow_res_t;
-    typedef typename base_prop::write_param_t           write_param_t;
-public:
-                    readwrite_property() : base_prop() {}
-    explicit        readwrite_property( write_param_t init_value ) : base_prop( init_value ) {}
-
-    // access methods
-    void            set( write_param_t v )  { base_prop::value = v; }
-    arrow_res_t     operator->()            { return autoboost::addressof( base_prop::value ); }
-    const_arrow_res_t operator->() const    { return autoboost::addressof( base_prop::value ); }
-
-#ifndef BOOST_TEST_NO_PROTECTED_USING
-    using           base_prop::value;
-#endif
-};
-
-//____________________________________________________________________________//
-
-} // unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#undef BOOST_TEST_NO_PROTECTED_USING
-
-#endif // BOOST_TEST_CLASS_PROPERTIES_HPP_071894GER
diff --git a/contrib/autoboost/boost/test/utils/custom_manip.hpp b/contrib/autoboost/boost/test/utils/custom_manip.hpp
deleted file mode 100644
index ddf3f7ee2..000000000
--- a/contrib/autoboost/boost/test/utils/custom_manip.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : simple helpers for creating cusom output manipulators
-// ***************************************************************************
-
-#ifndef BOOST_TEST_CUSTOM_MANIP_HPP_071894GER
-#define BOOST_TEST_CUSTOM_MANIP_HPP_071894GER
-
-// STL
-#include <iosfwd>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************          custom manipulators helpers         ************** //
-// ************************************************************************** //
-
-template<typename Manip>
-struct custom_printer {
-    explicit custom_printer( std::ostream& ostr ) : m_ostr( &ostr ) {}
-
-    std::ostream& operator*() const { return *m_ostr; }
-
-private:
-    std::ostream* const m_ostr;
-};
-
-//____________________________________________________________________________//
-
-template<typename Uniq> struct custom_manip {};
-
-//____________________________________________________________________________//
-
-template<typename Uniq>
-inline custom_printer<custom_manip<Uniq> >
-operator<<( std::ostream& ostr, custom_manip<Uniq> const& ) { return custom_printer<custom_manip<Uniq> >( ostr ); }
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_CUSTOM_MANIP_HPP_071894GER
diff --git a/contrib/autoboost/boost/test/utils/fixed_mapping.hpp b/contrib/autoboost/boost/test/utils/fixed_mapping.hpp
deleted file mode 100644
index e191c804e..000000000
--- a/contrib/autoboost/boost/test/utils/fixed_mapping.hpp
+++ /dev/null
@@ -1,124 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : fixed sized mapping with specified invalid value
-// ***************************************************************************
-
-#ifndef BOOST_TEST_FIXED_MAPPING_HPP_071894GER
-#define BOOST_TEST_FIXED_MAPPING_HPP_071894GER
-
-// Boost
-#include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/preprocessor/arithmetic/add.hpp>
-#include <boost/call_traits.hpp>
-#include <boost/detail/binary_search.hpp>
-
-// STL
-#include <vector>
-#include <functional>
-#include <algorithm>
-#include <utility>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// configurable maximum fixed sized mapping size supported by this header.
-// You can redefine it before inclusion of this file.
-#ifndef MAX_MAP_SIZE
-#define MAX_MAP_SIZE 20
-#endif
-
-#define CONSTR_DECL_MID( z, i, dummy1 ) key_param_type key##i, value_param_type v##i,
-#define CONSTR_BODY_MID( z, i, dummy1 ) add_pair( key##i, v##i );
-
-#define CONSTR_DECL( z, n, dummy1 )                                 \
-    fixed_mapping( BOOST_PP_REPEAT_ ## z( n, CONSTR_DECL_MID, "" )  \
-                         value_param_type invalid_value )           \
-    : m_invalid_value( invalid_value )                              \
-    {                                                               \
-        BOOST_PP_REPEAT_ ## z( n, CONSTR_BODY_MID, "" )             \
-        init();                                                     \
-    }                                                               \
-/**/
-
-#define CONTRUCTORS( n ) BOOST_PP_REPEAT( n, CONSTR_DECL, "" )
-
-template<typename Key, typename Value, typename Compare = std::less<Key> >
-class fixed_mapping
-{
-    typedef std::pair<Key,Value>                            elem_type;
-    typedef std::vector<elem_type>                          map_type;
-    typedef typename std::vector<elem_type>::const_iterator iterator;
-
-    typedef typename call_traits<Key>::param_type           key_param_type;
-    typedef typename call_traits<Value>::param_type         value_param_type;
-    typedef typename call_traits<Value>::const_reference    value_ref_type;
-
-#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
-    struct p1; friend struct p1;
-    struct p2; friend struct p2;
-#endif
-
-    // bind( Compare(), bind(select1st<elem_type>(), _1),  bind(identity<Key>(), _2) )
-    struct p1 : public std::binary_function<elem_type,Key,bool>
-    {
-        bool operator()( elem_type const& x, Key const& y ) const { return Compare()( x.first, y ); }
-    };
-
-    // bind( Compare(), bind(select1st<elem_type>(), _1), bind(select1st<elem_type>(), _2) )
-    struct p2 : public std::binary_function<elem_type,elem_type,bool>
-    {
-        bool operator()( elem_type const& x, elem_type const& y ) const { return Compare()( x.first, y.first ); }
-    };
-
-public:
-    // Constructors
-    CONTRUCTORS( BOOST_PP_ADD( MAX_MAP_SIZE, 1 ) )
-
-    // key -> value access
-    value_ref_type  operator[]( key_param_type key ) const
-    {
-        iterator it = autoboost::detail::lower_bound( m_map.begin(), m_map.end(), key, p1() );
-
-        return (it == m_map.end() || Compare()( key, it->first ) ) ? m_invalid_value : it->second;
-    }
-
-private:
-    // Implementation
-    void            init()                                                  { std::sort( m_map.begin(), m_map.end(), p2() ); }
-    void            add_pair( key_param_type key, value_param_type value )  { m_map.push_back( elem_type( key, value ) ); }
-
-    // Data members
-    Value           m_invalid_value;
-    map_type        m_map;
-};
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#undef MAX_MAP_SIZE
-#undef CONSTR_DECL_MID
-#undef CONSTR_BODY_MID
-#undef CONSTR_DECL
-#undef CONTRUCTORS
-
-#endif // BOOST_TEST_FIXED_MAPPING_HPP_071894GER
-
diff --git a/contrib/autoboost/boost/test/utils/foreach.hpp b/contrib/autoboost/boost/test/utils/foreach.hpp
deleted file mode 100644
index 755bd53f8..000000000
--- a/contrib/autoboost/boost/test/utils/foreach.hpp
+++ /dev/null
@@ -1,281 +0,0 @@
-//  (C) Copyright Eric Niebler 2004-2005
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : this is an abridged version of an excelent BOOST_FOREACH facility
-//  presented by Eric Niebler. I am so fond of it so I can't wait till it 
-//  going to be accepted into Boost. Also I need version with less number of dependencies 
-//  and more portable. This version doesn't support rvalues and will reeveluate it's 
-//  parameters, but should be good enough for my purposes.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_FOREACH_HPP_021005GER
-#define BOOST_TEST_FOREACH_HPP_021005GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-
-// Boost
-#include <boost/type.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/test/detail/workaround.hpp>
-
-#include <boost/type_traits/is_const.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-namespace for_each {
-
-// ************************************************************************** //
-// **************                  static_any                  ************** //
-// ************************************************************************** //
-
-struct static_any_base
-{
-    operator bool() const { return false; }
-};
-
-//____________________________________________________________________________//
-
-template<typename Iter>
-struct static_any : static_any_base
-{
-    static_any( Iter const& t ) : m_it( t ) {}
-
-    mutable Iter m_it;
-};
-
-//____________________________________________________________________________//
-
-typedef static_any_base const& static_any_t;
-
-//____________________________________________________________________________//
-
-template<typename Iter>
-inline Iter&
-static_any_cast( static_any_t a, Iter* = 0 )
-{
-    return static_cast<Iter&>( static_cast<static_any<Iter> const&>( a ).m_it );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                   is_const                   ************** //
-// ************************************************************************** //
-
-template<typename C>
-inline is_const<C>
-is_const_coll( C& )
-{
-    return is_const<C>();
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                     begin                    ************** //
-// ************************************************************************** //
-
-template<typename C>
-inline static_any<BOOST_DEDUCED_TYPENAME C::iterator>
-begin( C& t, mpl::false_ )
-{
-    return static_any<BOOST_DEDUCED_TYPENAME C::iterator>( t.begin() );
-}
-
-//____________________________________________________________________________//
-
-template<typename C>
-inline static_any<BOOST_DEDUCED_TYPENAME C::const_iterator>
-begin( C const& t, mpl::true_ )
-{
-    return static_any<BOOST_DEDUCED_TYPENAME C::const_iterator>( t.begin() );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                      end                     ************** //
-// ************************************************************************** //
-
-template<typename C>
-inline static_any<BOOST_DEDUCED_TYPENAME C::iterator>
-end( C& t, mpl::false_ )
-{
-    return static_any<BOOST_DEDUCED_TYPENAME C::iterator>( t.end() );
-}
-
-//____________________________________________________________________________//
-
-template<typename C>
-inline static_any<BOOST_DEDUCED_TYPENAME C::const_iterator>
-end( C const& t, mpl::true_ )
-{
-    return static_any<BOOST_DEDUCED_TYPENAME C::const_iterator>( t.end() );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                      done                    ************** //
-// ************************************************************************** //
-
-template<typename C>
-inline bool
-done( static_any_t cur, static_any_t end, C&, mpl::false_ )
-{
-    return  static_any_cast<BOOST_DEDUCED_TYPENAME C::iterator>( cur ) ==
-            static_any_cast<BOOST_DEDUCED_TYPENAME C::iterator>( end );
-}
-
-//____________________________________________________________________________//
-
-template<typename C>
-inline bool
-done( static_any_t cur, static_any_t end, C const&, mpl::true_ )
-{
-    return  static_any_cast<BOOST_DEDUCED_TYPENAME C::const_iterator>( cur ) ==
-            static_any_cast<BOOST_DEDUCED_TYPENAME C::const_iterator>( end );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                      next                    ************** //
-// ************************************************************************** //
-
-template<typename C>
-inline void
-next( static_any_t cur, C&, mpl::false_ )
-{
-    ++static_any_cast<BOOST_DEDUCED_TYPENAME C::iterator>( cur );
-}
-
-//____________________________________________________________________________//
-
-template<typename C>
-inline void
-next( static_any_t cur, C const&, mpl::true_ )
-{
-    ++static_any_cast<BOOST_DEDUCED_TYPENAME C::const_iterator>( cur );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                      deref                   ************** //
-// ************************************************************************** //
-
-template<class RefType,typename C>
-inline RefType
-deref( static_any_t cur, C&, ::autoboost::type<RefType>, mpl::false_ )
-{
-    return *static_any_cast<BOOST_DEDUCED_TYPENAME C::iterator>( cur );
-}
-
-//____________________________________________________________________________//
-
-template<class RefType,typename C>
-inline RefType
-deref( static_any_t cur, C const&, ::autoboost::type<RefType>, mpl::true_ )
-{
-    return *static_any_cast<BOOST_DEDUCED_TYPENAME C::const_iterator>( cur );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************              BOOST_TEST_FOREACH              ************** //
-// ************************************************************************** //
-
-#define BOOST_TEST_FE_ANY                   ::autoboost::unit_test::for_each::static_any_t
-#define BOOST_TEST_FE_IS_CONST( COL )       ::autoboost::unit_test::for_each::is_const_coll( COL )
-
-#define BOOST_TEST_FE_BEG( COL )            \
-    ::autoboost::unit_test::for_each::begin(    \
-        COL,                                \
-        BOOST_TEST_FE_IS_CONST( COL ) )     \
-/**/
-
-#define BOOST_TEST_FE_END( COL )            \
-    ::autoboost::unit_test::for_each::end(      \
-        COL,                                \
-        BOOST_TEST_FE_IS_CONST( COL ) )     \
-/**/
-
-#define BOOST_TEST_FE_DONE( COL )           \
-    ::autoboost::unit_test::for_each::done(     \
-        BOOST_TEST_FE_CUR_VAR,              \
-        BOOST_TEST_FE_END_VAR,              \
-        COL,                                \
-        BOOST_TEST_FE_IS_CONST( COL ) )     \
-/**/
-
-#define BOOST_TEST_FE_NEXT( COL )           \
-    ::autoboost::unit_test::for_each::next(     \
-        BOOST_TEST_FE_CUR_VAR,              \
-        COL,                                \
-        BOOST_TEST_FE_IS_CONST( COL ) )     \
-/**/
-
-#define BOOST_FOREACH_NOOP(COL)             \
-    ((void)&(COL))
-
-#define BOOST_TEST_FE_DEREF( COL, RefType ) \
-    ::autoboost::unit_test::for_each::deref(    \
-        BOOST_TEST_FE_CUR_VAR,              \
-        COL,                                \
-        ::autoboost::type<RefType >(),          \
-        BOOST_TEST_FE_IS_CONST( COL ) )     \
-/**/
-
-#if BOOST_WORKAROUND( BOOST_MSVC, == 1310 )
-#define BOOST_TEST_LINE_NUM
-#else
-#define BOOST_TEST_LINE_NUM     __LINE__
-#endif
-
-#define BOOST_TEST_FE_CUR_VAR   BOOST_JOIN( _fe_cur_, BOOST_TEST_LINE_NUM )
-#define BOOST_TEST_FE_END_VAR   BOOST_JOIN( _fe_end_, BOOST_TEST_LINE_NUM )
-#define BOOST_TEST_FE_CON_VAR   BOOST_JOIN( _fe_con_, BOOST_TEST_LINE_NUM )
-
-#define BOOST_TEST_FOREACH( RefType, var, COL )                                             \
-if( BOOST_TEST_FE_ANY BOOST_TEST_FE_CUR_VAR = BOOST_TEST_FE_BEG( COL ) ) {} else            \
-if( BOOST_TEST_FE_ANY BOOST_TEST_FE_END_VAR = BOOST_TEST_FE_END( COL ) ) {} else            \
-for( bool BOOST_TEST_FE_CON_VAR = true;                                                     \
-          BOOST_TEST_FE_CON_VAR && !BOOST_TEST_FE_DONE( COL );                              \
-          BOOST_TEST_FE_CON_VAR ? BOOST_TEST_FE_NEXT( COL ) : BOOST_FOREACH_NOOP( COL ))    \
-                                                                                            \
-    if( (BOOST_TEST_FE_CON_VAR = false, false) ) {} else                                    \
-    for( RefType var = BOOST_TEST_FE_DEREF( COL, RefType );                                 \
-         !BOOST_TEST_FE_CON_VAR; BOOST_TEST_FE_CON_VAR = true )                             \
-/**/
-
-//____________________________________________________________________________//
-
-} // namespace for_each
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_FOREACH_HPP_021005GER
diff --git a/contrib/autoboost/boost/test/utils/iterator/input_iterator_facade.hpp b/contrib/autoboost/boost/test/utils/iterator/input_iterator_facade.hpp
deleted file mode 100644
index f7768f4ff..000000000
--- a/contrib/autoboost/boost/test/utils/iterator/input_iterator_facade.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2004-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : Input iterator facade 
-// ***************************************************************************
-
-#ifndef BOOST_INPUT_ITERATOR_FACADE_HPP_071894GER
-#define BOOST_INPUT_ITERATOR_FACADE_HPP_071894GER
-
-// Boost
-#include <boost/iterator/iterator_facade.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************          input_iterator_core_access          ************** //
-// ************************************************************************** //
-
-class input_iterator_core_access
-{
-#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-public:
-#else
-    template <class I, class V, class R, class TC> friend class input_iterator_facade;
-#endif
-
-    template <class Facade>
-    static bool get( Facade& f )
-    {
-        return f.get();
-    }
-
-private:
-    // objects of this class are useless
-    input_iterator_core_access(); //undefined
-};
-
-// ************************************************************************** //
-// **************            input_iterator_facade             ************** //
-// ************************************************************************** //
-
-template<typename Derived,
-         typename ValueType,
-         typename Reference = ValueType const&,
-         typename Traversal = single_pass_traversal_tag>
-class input_iterator_facade : public iterator_facade<Derived,ValueType,Traversal,Reference>
-{
-public:
-    // Constructor
-    input_iterator_facade() : m_valid( false ), m_value() {}
-
-protected: // provide access to the Derived
-    void                init()
-    {
-        m_valid = true;
-        increment();
-    }
-
-    // Data members
-    mutable bool        m_valid;
-    ValueType           m_value;
-
-private:
-    friend class autoboost::iterator_core_access;
-
-    // iterator facade interface implementation
-    void                increment()
-    {
-        // we make post-end incrementation indefinetly safe 
-        if( m_valid )
-            m_valid = input_iterator_core_access::get( *static_cast<Derived*>(this) );
-    }
-    Reference           dereference() const
-    {
-        return m_value;
-    }
-
-    // iterator facade interface implementation
-    bool                equal( input_iterator_facade const& rhs ) const
-    {
-        // two invalid iterator equals, inequal otherwise
-        return !m_valid && !rhs.m_valid;
-    }
-};
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_INPUT_ITERATOR_FACADE_HPP_071894GER
-
diff --git a/contrib/autoboost/boost/test/utils/iterator/token_iterator.hpp b/contrib/autoboost/boost/test/utils/iterator/token_iterator.hpp
deleted file mode 100644
index 8e2329715..000000000
--- a/contrib/autoboost/boost/test/utils/iterator/token_iterator.hpp
+++ /dev/null
@@ -1,418 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2004-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : token iterator for string and range tokenization
-// ***************************************************************************
-
-#ifndef BOOST_TOKEN_ITERATOR_HPP_071894GER
-#define BOOST_TOKEN_ITERATOR_HPP_071894GER
-
-// Boost
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-
-#include <boost/test/utils/iterator/input_iterator_facade.hpp>
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-#include <boost/test/utils/named_params.hpp>
-#include <boost/test/utils/foreach.hpp>
-
-// STL
-#include <iosfwd>
-#include <cctype>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std{ using ::ispunct; using ::isspace; }
-#endif
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************               ti_delimeter_type              ************** //
-// ************************************************************************** //
-
-enum ti_delimeter_type { 
-    dt_char,        // character is delimeter if it among explicit list of some characters
-    dt_ispunct,     // character is delimeter if it satisfies ispunct functor
-    dt_isspace,     // character is delimeter if it satisfies isspace functor
-    dt_none         // no character is delimeter
-};
-
-namespace ut_detail {
-
-// ************************************************************************** //
-// **************             default_char_compare             ************** //
-// ************************************************************************** //
-
-template<typename CharT>
-class default_char_compare {
-public:
-    bool operator()( CharT c1, CharT c2 )
-    {
-#ifdef BOOST_CLASSIC_IOSTREAMS
-        return std::string_char_traits<CharT>::eq( c1, c2 );
-#else
-        return std::char_traits<CharT>::eq( c1, c2 );
-#endif
-    }
-};
-
-// ************************************************************************** //
-// **************                 delim_policy                 ************** //
-// ************************************************************************** //
-
-template<typename CharT,typename CharCompare>
-class delim_policy {
-    typedef basic_cstring<CharT const> cstring;
-public:
-    // Constructor
-    explicit    delim_policy( ti_delimeter_type t = dt_char, cstring d = cstring() )
-    : m_type( t )
-    {
-        set_delimeters( d );
-    }
-
-    void        set_delimeters( ti_delimeter_type t ) { m_type = t; }
-    template<typename Src>
-    void        set_delimeters( Src d )
-    {
-        nfp::optionally_assign( m_delimeters, d );
-        
-        if( !m_delimeters.is_empty() )
-            m_type = dt_char;
-    }
-
-    bool        operator()( CharT c )
-    {
-        switch( m_type ) {
-        case dt_char: {
-            BOOST_TEST_FOREACH( CharT, delim, m_delimeters )
-                if( CharCompare()( delim, c ) )
-                    return true;
-
-            return false;
-        }
-        case dt_ispunct:
-            return (std::ispunct)( c ) != 0;
-        case dt_isspace:
-            return (std::isspace)( c ) != 0;
-        case dt_none:
-            return false;
-        }
-
-        return false;
-    }
-
-private:
-    // Data members
-    cstring             m_delimeters;
-    ti_delimeter_type   m_type;
-};
-
-// ************************************************************************** //
-// **************                 token_assigner               ************** //
-// ************************************************************************** //
-
-template<typename TraversalTag>
-struct token_assigner {
-#if BOOST_WORKAROUND( BOOST_DINKUMWARE_STDLIB, < 306 )
-    template<typename Iterator, typename C, typename T>
-    static void assign( Iterator b, Iterator e, std::basic_string<C,T>& t )
-    { for( ; b != e; ++b ) t += *b; }
-    
-    template<typename Iterator, typename C>
-    static void assign( Iterator b, Iterator e, basic_cstring<C>& t )  { t.assign( b, e ); }
-#else
-    template<typename Iterator, typename Token>
-    static void assign( Iterator b, Iterator e, Token& t )  { t.assign( b, e ); }
-#endif
-    template<typename Iterator, typename Token>
-    static void append_move( Iterator& b, Token& )          { ++b; }
-};
-
-//____________________________________________________________________________//
-
-template<>
-struct token_assigner<single_pass_traversal_tag> {
-    template<typename Iterator, typename Token>
-    static void assign( Iterator b, Iterator e, Token& t )  {}
-
-    template<typename Iterator, typename Token>
-    static void append_move( Iterator& b, Token& t )        { t += *b; ++b; }
-};
-
-} // namespace ut_detail
-
-// ************************************************************************** //
-// **************                  modifiers                   ************** //
-// ************************************************************************** //
-
-namespace {
-nfp::keyword<struct dropped_delimeters_t >           dropped_delimeters;
-nfp::keyword<struct kept_delimeters_t >              kept_delimeters;
-nfp::typed_keyword<bool,struct keep_empty_tokens_t > keep_empty_tokens;
-nfp::typed_keyword<std::size_t,struct max_tokens_t > max_tokens;
-}
-
-// ************************************************************************** //
-// **************             token_iterator_base              ************** //
-// ************************************************************************** //
-
-template<typename Derived,
-         typename CharT,
-         typename CharCompare   = ut_detail::default_char_compare<CharT>,
-         typename ValueType     = basic_cstring<CharT const>,
-         typename Reference     = basic_cstring<CharT const>,
-         typename Traversal     = forward_traversal_tag>
-class token_iterator_base
-: public input_iterator_facade<Derived,ValueType,Reference,Traversal> {
-    typedef basic_cstring<CharT const>                                      cstring;
-    typedef ut_detail::delim_policy<CharT,CharCompare>                      delim_policy;
-    typedef input_iterator_facade<Derived,ValueType,Reference,Traversal>    base;
-
-protected:
-    // Constructor
-    explicit    token_iterator_base()
-    : m_is_dropped( dt_isspace )
-    , m_is_kept( dt_ispunct )
-    , m_keep_empty_tokens( false )
-    , m_tokens_left( static_cast<std::size_t>(-1) )
-    , m_token_produced( false )
-    {
-    }
-
-    template<typename Modifier>
-    void
-    apply_modifier( Modifier const& m )
-    {
-        if( m.has( dropped_delimeters ) )
-            m_is_dropped.set_delimeters( m[dropped_delimeters] );
-
-        if( m.has( kept_delimeters ) )
-            m_is_kept.set_delimeters( m[kept_delimeters] );
-
-        if( m.has( keep_empty_tokens ) )
-            m_keep_empty_tokens = true;
-
-        nfp::optionally_assign( m_tokens_left, m, max_tokens );
-    }
-
-    template<typename Iter> 
-    bool                    get( Iter& begin, Iter end )
-    {
-        typedef ut_detail::token_assigner<BOOST_DEDUCED_TYPENAME iterator_traversal<Iter>::type> Assigner;
-        Iter check_point;
-
-        this->m_value.clear();
-
-        if( !m_keep_empty_tokens ) {
-            while( begin != end && m_is_dropped( *begin ) )
-                ++begin;
-
-            if( begin == end )
-                return false;
-
-            check_point = begin;
-
-            if( m_tokens_left == 1 )
-                while( begin != end )
-                    Assigner::append_move( begin, this->m_value );
-            else if( m_is_kept( *begin ) )
-                Assigner::append_move( begin, this->m_value );
-            else
-                while( begin != end && !m_is_dropped( *begin ) && !m_is_kept( *begin ) )
-                    Assigner::append_move( begin, this->m_value );
-
-            --m_tokens_left;
-        } 
-        else { // m_keep_empty_tokens is true
-            check_point = begin;
-
-            if( begin == end ) {
-                if( m_token_produced ) 
-                    return false;
-
-                m_token_produced = true;
-            }
-            if( m_is_kept( *begin ) ) {
-                if( m_token_produced ) 
-                    Assigner::append_move( begin, this->m_value );
-
-                m_token_produced = !m_token_produced;
-            } 
-            else if( !m_token_produced && m_is_dropped( *begin ) )
-                m_token_produced = true;
-            else {
-                if( m_is_dropped( *begin ) )
-                    check_point = ++begin;
-
-                while( begin != end && !m_is_dropped( *begin ) && !m_is_kept( *begin ) )
-                    Assigner::append_move( begin, this->m_value );
-
-                m_token_produced = true;
-            }
-        }
-
-        Assigner::assign( check_point, begin, this->m_value );
-
-        return true;
-    }
-
-private:
-    // Data members
-    delim_policy            m_is_dropped;
-    delim_policy            m_is_kept;
-    bool                    m_keep_empty_tokens;
-    std::size_t             m_tokens_left;
-    bool                    m_token_produced;
-};
-
-// ************************************************************************** //
-// **************          basic_string_token_iterator         ************** //
-// ************************************************************************** //
-
-template<typename CharT,
-         typename CharCompare = ut_detail::default_char_compare<CharT> >
-class basic_string_token_iterator
-: public token_iterator_base<basic_string_token_iterator<CharT,CharCompare>,CharT,CharCompare> {
-    typedef basic_cstring<CharT const> cstring;
-    typedef token_iterator_base<basic_string_token_iterator<CharT,CharCompare>,CharT,CharCompare> base;
-public:
-    explicit    basic_string_token_iterator() {}
-    explicit    basic_string_token_iterator( cstring src )
-    : m_src( src )
-    {
-        this->init();
-    }
-
-    template<typename Src, typename Modifier>
-    basic_string_token_iterator( Src src, Modifier const& m )
-    : m_src( src )
-    {
-        this->apply_modifier( m );
-
-        this->init();
-    }
-
-private:
-    friend class input_iterator_core_access;
-
-    // input iterator implementation
-    bool        get()
-    {
-        typename cstring::iterator begin = m_src.begin();
-        bool res = base::get( begin, m_src.end() );
-
-        m_src.assign( begin, m_src.end() );
-
-        return res;
-    }
-
-    // Data members
-    cstring     m_src;
-};
-
-typedef basic_string_token_iterator<char>       string_token_iterator;
-typedef basic_string_token_iterator<wchar_t>    wstring_token_iterator;
-
-// ************************************************************************** //
-// **************              range_token_iterator            ************** //
-// ************************************************************************** //
-
-template<typename Iter,
-         typename CharCompare = ut_detail::default_char_compare<BOOST_DEDUCED_TYPENAME iterator_value<Iter>::type>,
-         typename ValueType   = std::basic_string<BOOST_DEDUCED_TYPENAME iterator_value<Iter>::type>,
-         typename Reference   = ValueType const&>
-class range_token_iterator
-: public token_iterator_base<range_token_iterator<Iter,CharCompare,ValueType,Reference>,
-                             typename iterator_value<Iter>::type,CharCompare,ValueType,Reference> {
-    typedef basic_cstring<typename ValueType::value_type> cstring;
-    typedef token_iterator_base<range_token_iterator<Iter,CharCompare,ValueType,Reference>,
-                                typename iterator_value<Iter>::type,CharCompare,ValueType,Reference> base;
-public:
-    explicit    range_token_iterator() {}
-    explicit    range_token_iterator( Iter begin, Iter end = Iter() )
-    : m_begin( begin ), m_end( end )
-    {
-        this->init();
-    }
-    range_token_iterator( range_token_iterator const& rhs )
-    : base( rhs )
-    {
-        if( this->m_valid ) {
-            m_begin = rhs.m_begin;
-            m_end   = rhs.m_end;
-        }
-    }
-
-    template<typename Modifier>
-    range_token_iterator( Iter begin, Iter end, Modifier const& m )
-    : m_begin( begin ), m_end( end )
-    {
-        this->apply_modifier( m );
-
-        this->init();
-    }
-
-private:
-    friend class input_iterator_core_access;
-
-    // input iterator implementation
-    bool        get()
-    {
-        return base::get( m_begin, m_end );
-    }
-
-    // Data members
-    Iter m_begin;
-    Iter m_end;
-};
-
-// ************************************************************************** //
-// **************            make_range_token_iterator         ************** //
-// ************************************************************************** //
-
-template<typename Iter>
-inline range_token_iterator<Iter>
-make_range_token_iterator( Iter begin, Iter end = Iter() )
-{
-    return range_token_iterator<Iter>( begin, end );
-}
-
-//____________________________________________________________________________//
-
-template<typename Iter,typename Modifier>
-inline range_token_iterator<Iter>
-make_range_token_iterator( Iter begin, Iter end, Modifier const& m )
-{
-    return range_token_iterator<Iter>( begin, end, m );
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TOKEN_ITERATOR_HPP_071894GER
-
diff --git a/contrib/autoboost/boost/test/utils/lazy_ostream.hpp b/contrib/autoboost/boost/test/utils/lazy_ostream.hpp
deleted file mode 100644
index f959a69dd..000000000
--- a/contrib/autoboost/boost/test/utils/lazy_ostream.hpp
+++ /dev/null
@@ -1,114 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : contains definition for all test tools in test toolbox
-// ***************************************************************************
-
-#ifndef BOOST_TEST_LAZY_OSTREAM_HPP_070708GER
-#define BOOST_TEST_LAZY_OSTREAM_HPP_070708GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-
-// STL
-#include <iosfwd>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  lazy_ostream                ************** //
-// ************************************************************************** //
-
-namespace autoboost {
-
-namespace unit_test {
-
-class lazy_ostream {
-public:
-    static lazy_ostream&    instance()                                              { static lazy_ostream inst; return inst; }
-
-    friend std::ostream&    operator<<( std::ostream& ostr, lazy_ostream const& o ) { return o( ostr ); }
-
-    // access method
-    bool                    empty() const                                           { return m_empty; }
-
-    // actual printing interface; to be accessed only by this class and children
-    virtual std::ostream&   operator()( std::ostream& ostr ) const                  { return ostr; }
-protected:
-    explicit                lazy_ostream( bool empty = true ) : m_empty( empty )    {}
-
-    // protected destructor to make sure right one is called
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
-public:
-#endif
-    BOOST_TEST_PROTECTED_VIRTUAL ~lazy_ostream()                                    {}
-
-private:
-    // Data members
-    bool                    m_empty;
-};
-
-//____________________________________________________________________________//
-
-template<typename T>
-class lazy_ostream_impl : public lazy_ostream {
-public:
-    lazy_ostream_impl( lazy_ostream const& prev, T value )
-    : lazy_ostream( false )
-    , m_prev( prev )
-    , m_value( value )
-    {}
-private:
-    virtual std::ostream&   operator()( std::ostream& ostr ) const
-    {
-        return m_prev(ostr) << m_value;
-    }
-
-    // Data members
-    lazy_ostream const&     m_prev;
-    T                       m_value;
-};
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline lazy_ostream_impl<T const&>
-operator<<( lazy_ostream const& prev, T const& v )
-{
-    return lazy_ostream_impl<T const&>( prev, v );
-}
-
-//____________________________________________________________________________//
-
-#if BOOST_TEST_USE_STD_LOCALE
-
-template<typename R,typename S>
-inline lazy_ostream_impl<R& (BOOST_TEST_CALL_DECL *)(S&)>
-operator<<( lazy_ostream const& prev, R& (BOOST_TEST_CALL_DECL *man)(S&) )
-{
-    return lazy_ostream_impl<R& (BOOST_TEST_CALL_DECL *)(S&)>( prev, man );
-}
-
-//____________________________________________________________________________//
-
-#endif
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_LAZY_OSTREAM_HPP_070708GER
diff --git a/contrib/autoboost/boost/test/utils/named_params.hpp b/contrib/autoboost/boost/test/utils/named_params.hpp
deleted file mode 100644
index d655e41ca..000000000
--- a/contrib/autoboost/boost/test/utils/named_params.hpp
+++ /dev/null
@@ -1,329 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : facilities for named function parameters support
-// ***************************************************************************
-
-#ifndef BOOST_TEST_NAMED_PARAM_022505GER
-#define BOOST_TEST_NAMED_PARAM_022505GER
-
-// Boost
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-// Boost.Test
-#include <boost/test/utils/rtti.hpp>
-#include <boost/test/utils/assign_op.hpp>
-
-#include <boost/type_traits/remove_reference.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace nfp { // named function parameters
-
-// ************************************************************************** //
-// **************              forward declarations            ************** //
-// ************************************************************************** //
-
-template<typename T, typename unique_id,typename RefType>   struct named_parameter;
-template<typename unique_id,bool required>                  struct keyword;
-
-namespace nfp_detail {
-
-template<typename NP1,typename NP2>        struct named_parameter_combine;
-
-// ************************************************************************** //
-// **************          access_to_invalid_parameter         ************** //
-// ************************************************************************** //
-
-struct access_to_invalid_parameter {};
-
-//____________________________________________________________________________//
-
-inline void 
-report_access_to_invalid_parameter()
-{
-    throw access_to_invalid_parameter();
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                       nil                    ************** //
-// ************************************************************************** //
-
-struct nil {
-    template<typename T>
-#if defined(__GNUC__) || defined(__HP_aCC) || defined(__EDG__) || defined(__SUNPRO_CC)
-    operator T() const
-#else
-    operator T const&() const
-#endif
-    { report_access_to_invalid_parameter(); static T* v = 0; return *v; }
-
-    template<typename T>
-    T any_cast() const
-    { report_access_to_invalid_parameter(); static typename remove_reference<T>::type* v = 0; return *v; }
-
-    template<typename Arg1>
-    nil operator()( Arg1 const& )
-    { report_access_to_invalid_parameter(); return nil(); }
-
-    template<typename Arg1,typename Arg2>
-    nil operator()( Arg1 const&, Arg2 const& )
-    { report_access_to_invalid_parameter(); return nil(); }
-
-    template<typename Arg1,typename Arg2,typename Arg3>
-    nil operator()( Arg1 const&, Arg2 const&, Arg3 const& )
-    { report_access_to_invalid_parameter(); return nil(); }
-
-    // Visitation support
-    template<typename Visitor>
-    void            apply_to( Visitor& V ) const {}
-
-    static nil&     inst() { static nil s_inst; return s_inst; }
-private:
-    nil() {}
-};
-    
-// ************************************************************************** //
-// **************              named_parameter_base            ************** //
-// ************************************************************************** //
-
-template<typename Derived>
-struct named_parameter_base {
-    template<typename NP>
-    named_parameter_combine<NP,Derived>
-    operator,( NP const& np ) const { return named_parameter_combine<NP,Derived>( np, *static_cast<Derived const*>(this) ); }
-};
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************             named_parameter_combine          ************** //
-// ************************************************************************** //
-
-template<typename NP, typename Rest = nil>
-struct named_parameter_combine 
-: Rest
-, named_parameter_base<named_parameter_combine<NP,Rest> > {
-    typedef typename NP::ref_type  res_type;
-    typedef named_parameter_combine<NP,Rest> self_type;
-
-    // Constructor
-    named_parameter_combine( NP const& np, Rest const& r )
-    : Rest( r )
-    , m_param( np )
-    {}
-
-    // Access methods
-    res_type    operator[]( keyword<typename NP::id,true> kw ) const    { return m_param[kw]; }
-    res_type    operator[]( keyword<typename NP::id,false> kw ) const   { return m_param[kw]; }
-    using       Rest::operator[];
-
-    bool        has( keyword<typename NP::id,false> kw ) const          { return m_param.has( kw ); }
-    using       Rest::has;
-
-    void        erase( keyword<typename NP::id,false> kw ) const        { m_param.erase( kw ); }
-    using       Rest::erase;
-
-#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206)) || \
-    BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0610))
-    template<typename NP>
-    named_parameter_combine<NP,self_type> operator,( NP const& np ) const
-    { return named_parameter_combine<NP,self_type>( np, *this ); }
-#else
-    using       named_parameter_base<named_parameter_combine<NP,Rest> >::operator,;
-#endif
-
-    // Visitation support
-    template<typename Visitor>
-    void            apply_to( Visitor& V ) const
-    {
-        m_param.apply_to( V );
-
-        Rest::apply_to( V );
-    }
-private:
-    // Data members
-    NP          m_param;
-};
-
-} // namespace nfp_detail
-
-// ************************************************************************** //
-// **************                 named_parameter              ************** //
-// ************************************************************************** //
-
-template<typename T, typename unique_id,typename ReferenceType=T&>
-struct named_parameter
-: nfp_detail::named_parameter_base<named_parameter<T, unique_id,ReferenceType> >
-{
-    typedef nfp_detail::nil nil_t;
-    typedef T               data_type;
-    typedef ReferenceType   ref_type;
-    typedef unique_id       id;
-
-    // Constructor
-    explicit        named_parameter( ref_type v ) 
-    : m_value( v )
-    , m_erased( false )
-    {}
-    named_parameter( named_parameter const& np )
-    : m_value( np.m_value )
-    , m_erased( np.m_erased )
-    {}
-
-    // Access methods
-    ref_type        operator[]( keyword<unique_id,true> ) const     { return m_erased ? nil_t::inst().template any_cast<ref_type>() :  m_value; }
-    ref_type        operator[]( keyword<unique_id,false> ) const    { return m_erased ? nil_t::inst().template any_cast<ref_type>() :  m_value; }
-    template<typename UnknownId>
-    nil_t           operator[]( keyword<UnknownId,false> ) const    { return nil_t::inst(); }
-
-    bool            has( keyword<unique_id,false> ) const           { return !m_erased; }
-    template<typename UnknownId>
-    bool            has( keyword<UnknownId,false> ) const           { return false; }
-
-    void            erase( keyword<unique_id,false> ) const         { m_erased = true; }
-    template<typename UnknownId>
-    void            erase( keyword<UnknownId,false> ) const         {}
-
-    // Visitation support
-    template<typename Visitor>
-    void            apply_to( Visitor& V ) const
-    {
-        V.set_parameter( rtti::type_id<unique_id>(), m_value );
-    }
-
-private:
-    // Data members
-    ref_type        m_value;
-    mutable bool    m_erased;
-};
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                    no_params                 ************** //
-// ************************************************************************** //
-
-namespace nfp_detail {
-typedef named_parameter<char, struct no_params_type_t,char> no_params_type;
-} // namespace nfp_detail
-
-namespace {
-nfp_detail::no_params_type no_params( '\0' );
-} // local namespace
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                     keyword                  ************** //
-// ************************************************************************** //
-
-template<typename unique_id, bool required = false>
-struct keyword {
-    typedef unique_id id;
-
-    template<typename T>
-    named_parameter<T const,unique_id>
-    operator=( T const& t ) const       { return named_parameter<T const,unique_id>( t ); }
-
-    template<typename T>
-    named_parameter<T,unique_id>
-    operator=( T& t ) const   { return named_parameter<T,unique_id>( t ); }
-
-    named_parameter<char const*,unique_id,char const*>
-    operator=( char const* t ) const   { return named_parameter<char const*,unique_id,char const*>( t ); }
-};
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  typed_keyword               ************** //
-// ************************************************************************** //
-
-template<typename T, typename unique_id, bool required = false>
-struct typed_keyword : keyword<unique_id,required> {
-    named_parameter<T const,unique_id>
-    operator=( T const& t ) const       { return named_parameter<T const,unique_id>( t ); }
-
-    named_parameter<T,unique_id>
-    operator=( T& t ) const             { return named_parameter<T,unique_id>( t ); }
-};
-
-//____________________________________________________________________________//
-
-template<typename unique_id>
-struct typed_keyword<bool,unique_id,false>
-: keyword<unique_id,false>
-, named_parameter<bool,unique_id,bool> {
-    typedef unique_id id;
-
-    typed_keyword() : named_parameter<bool,unique_id,bool>( true ) {}
-
-    named_parameter<bool,unique_id,bool>
-    operator!() const           { return named_parameter<bool,unique_id,bool>( false ); }
-};
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                optionally_assign             ************** //
-// ************************************************************************** //
-
-template<typename T>
-inline void
-optionally_assign( T&, nfp_detail::nil )
-{
-    nfp_detail::report_access_to_invalid_parameter();
-}
-
-//____________________________________________________________________________//
-
-template<typename T, typename Source>
-inline void
-#if BOOST_WORKAROUND( __MWERKS__, BOOST_TESTED_AT( 0x3003 ) ) \
-    || BOOST_WORKAROUND( __DECCXX_VER, BOOST_TESTED_AT(60590042) )
-optionally_assign( T& target, Source src )
-#else
-optionally_assign( T& target, Source const& src )
-#endif
-{
-    using namespace unit_test;
-
-    assign_op( target, src, static_cast<int>(0) );
-}
-
-//____________________________________________________________________________//
-
-template<typename T, typename Params, typename Keyword>
-inline void
-optionally_assign( T& target, Params const& p, Keyword k )
-{
-    if( p.has(k) )
-        optionally_assign( target, p[k] );
-}
-
-//____________________________________________________________________________//
-
-} // namespace nfp
-
-} // namespace autoboost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_NAMED_PARAM_022505GER
-
diff --git a/contrib/autoboost/boost/test/utils/rtti.hpp b/contrib/autoboost/boost/test/utils/rtti.hpp
deleted file mode 100644
index cd5ddfd10..000000000
--- a/contrib/autoboost/boost/test/utils/rtti.hpp
+++ /dev/null
@@ -1,64 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : simple facilities for accessing type information at runtime
-// ***************************************************************************
-
-#ifndef BOOST_TEST_RTTI_HPP_062604GER
-#define BOOST_TEST_RTTI_HPP_062604GER
-
-#include <cstddef>
-
-namespace autoboost {
-
-namespace rtti {
-
-// ************************************************************************** //
-// **************                   rtti::type_id              ************** //
-// ************************************************************************** //
-
-typedef std::ptrdiff_t id_t;
-
-namespace rtti_detail {
-
-template<typename T>
-struct rttid_holder {
-    static id_t id() { return reinterpret_cast<id_t>( &inst() ); }
-
-private:
-    struct rttid {};
-
-    static rttid const& inst() { static rttid s_inst;  return s_inst; }
-};
-
-} // namespace rtti_detail
-
-//____________________________________________________________________________//
-
-template<typename T>   
-inline id_t
-type_id()
-{
-    return rtti_detail::rttid_holder<T>::id();
-}
-
-//____________________________________________________________________________//
-
-#define BOOST_RTTI_SWITCH( type_id_ ) if( ::autoboost::rtti::id_t switch_by_id = type_id_ )
-#define BOOST_RTTI_CASE( type )       if( switch_by_id == ::autoboost::rtti::type_id<type>() )
-
-//____________________________________________________________________________//
-
-} // namespace rtti
-
-} // namespace autoboost
-
-#endif // BOOST_RT_RTTI_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/argument.hpp b/contrib/autoboost/boost/test/utils/runtime/argument.hpp
deleted file mode 100644
index 64e1ac149..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/argument.hpp
+++ /dev/null
@@ -1,112 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : model of actual argument (both typed and abstract interface)
-// ***************************************************************************
-
-#ifndef BOOST_RT_ARGUMENT_HPP_062604GER
-#define BOOST_RT_ARGUMENT_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-#include <boost/test/utils/runtime/fwd.hpp>
-#include <boost/test/utils/runtime/validation.hpp>
-
-// Boost.Test
-#include <boost/test/utils/class_properties.hpp>
-#include <boost/test/utils/rtti.hpp>
-
-// STL
-#include <cassert>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-// ************************************************************************** //
-// **************              runtime::argument               ************** //
-// ************************************************************************** //
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable:4244)
-#endif
-
-class argument {
-public:
-    // Constructor
-    argument( parameter const& p, rtti::id_t value_type )
-    : p_formal_parameter( p )
-    , p_value_type( value_type )
-    {}
-
-    // Destructor
-    virtual     ~argument()  {}
-
-    // Public properties
-    unit_test::readonly_property<parameter const&> p_formal_parameter;
-    unit_test::readonly_property<rtti::id_t>       p_value_type;
-};
-
-// ************************************************************************** //
-// **************             runtime::typed_argument          ************** //
-// ************************************************************************** //
-
-template<typename T>
-class typed_argument : public argument {
-public:
-    // Constructor
-    explicit typed_argument( parameter const& p )
-    : argument( p, rtti::type_id<T>() )
-    {}
-    typed_argument( parameter const& p, T const& t )
-    : argument( p, rtti::type_id<T>() )
-    , p_value( t )
-    {}
-
-    unit_test::readwrite_property<T>    p_value;
-};
-
-// ************************************************************************** //
-// **************               runtime::arg_value             ************** //
-// ************************************************************************** //
-
-template<typename T>
-inline T const&
-arg_value( argument const& arg_ )
-{
-    assert( arg_.p_value_type == rtti::type_id<T>() ); // detect logic error
-
-    return static_cast<typed_argument<T> const&>( arg_ ).p_value.value;
-}
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline T&
-arg_value( argument& arg_ )
-{
-    assert( arg_.p_value_type == rtti::type_id<T>() ); // detect logic error
-
-    return static_cast<typed_argument<T>&>( arg_ ).p_value.value;
-}
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-
-//____________________________________________________________________________//
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_ARGUMENT_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/argument_factory.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/argument_factory.hpp
deleted file mode 100644
index a05e6160a..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/argument_factory.hpp
+++ /dev/null
@@ -1,218 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : generic typed_argument_factory implementation
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_ARGUMENT_FACTORY_HPP_062604GER
-#define BOOST_RT_CLA_ARGUMENT_FACTORY_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#include <boost/test/utils/runtime/fwd.hpp>
-#include <boost/test/utils/runtime/validation.hpp>
-#include <boost/test/utils/runtime/argument.hpp>
-#include <boost/test/utils/runtime/trace.hpp>
-#include <boost/test/utils/runtime/interpret_argument_value.hpp>
-
-#include <boost/test/utils/runtime/cla/fwd.hpp>
-#include <boost/test/utils/runtime/cla/value_generator.hpp>
-#include <boost/test/utils/runtime/cla/value_handler.hpp>
-#include <boost/test/utils/runtime/cla/validation.hpp>
-#include <boost/test/utils/runtime/cla/argv_traverser.hpp>
-#include <boost/test/utils/runtime/cla/detail/argument_value_usage.hpp>
-
-#include <boost/test/utils/runtime/cla/iface/argument_factory.hpp>
-
-// Boost.Test
-#include <boost/test/utils/callback.hpp>
-
-// Boost
-#include <boost/optional.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************           default_value_interpreter          ************** //
-// ************************************************************************** //
-
-namespace rt_cla_detail {
-
-struct default_value_interpreter {
-    template<typename T>
-    void operator()( argv_traverser& tr, autoboost::optional<T>& value )
-    {
-        if( interpret_argument_value( tr.token(), value, 0 ) )
-            tr.next_token();
-    }
-};
-
-} // namespace rt_cla_detail
-
-// ************************************************************************** //
-// **************             typed_argument_factory           ************** //
-// ************************************************************************** //
-
-template<typename T>
-struct typed_argument_factory : public argument_factory {
-    // Constructor
-    typed_argument_factory()
-    : m_value_interpreter( rt_cla_detail::default_value_interpreter() )
-    {}
-    BOOST_RT_PARAM_UNNEEDED_VIRTUAL ~typed_argument_factory() {}
-
-    // properties modification
-    template<typename Modifier>
-    void                accept_modifier( Modifier const& m )
-    {
-        optionally_assign( m_value_handler, m, handler );
-        optionally_assign( m_value_interpreter, m, interpreter );
-
-        if( m.has( default_value ) ) {
-            BOOST_RT_PARAM_VALIDATE_LOGIC( !m_value_generator, 
-                BOOST_RT_PARAM_LITERAL( "multiple value generators for parameter" ) );
-
-            T const& dv_ref = m[default_value];
-            m_value_generator = rt_cla_detail::const_generator<T>( dv_ref );
-        }
-
-        if( m.has( default_refer_to ) ) {
-            BOOST_RT_PARAM_VALIDATE_LOGIC( !m_value_generator, 
-                BOOST_RT_PARAM_LITERAL( "multiple value generators for parameter" ) );
-
-            cstring ref_id = m[default_refer_to];
-            m_value_generator = rt_cla_detail::ref_generator<T>( ref_id );
-        }
-
-        if( m.has( assign_to ) ) {
-            BOOST_RT_PARAM_VALIDATE_LOGIC( !m_value_handler, 
-                BOOST_RT_PARAM_LITERAL( "multiple value handlers for parameter" ) );
-
-            m_value_handler = rt_cla_detail::assigner<T>( m[assign_to] );
-        }
-    }
-
-    // Argument factory implementation
-    virtual argument_ptr produce_using( parameter& p, argv_traverser& tr );
-    virtual argument_ptr produce_using( parameter& p, parser const& );
-    virtual void         argument_usage_info( format_stream& fs );
-
-// !! private?
-    // Data members
-    unit_test::callback2<parameter const&,T&>                   m_value_handler;
-    unit_test::callback2<parser const&,autoboost::optional<T>&>     m_value_generator;
-    unit_test::callback2<argv_traverser&,autoboost::optional<T>&>   m_value_interpreter;
-};
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline argument_ptr
-typed_argument_factory<T>::produce_using( parameter& p, argv_traverser& tr )
-{
-    autoboost::optional<T> value;
-
-    try {
-        m_value_interpreter( tr, value );
-    }
-    catch( ... ) { // !! should we do that?
-        BOOST_RT_PARAM_TRACE( "Fail to parse argument value" );
-
-        if( !p.p_optional_value )
-            throw;
-    }
-
-    argument_ptr actual_arg = p.actual_argument();
-
-    BOOST_RT_CLA_VALIDATE_INPUT( !!value || p.p_optional_value, tr, 
-        BOOST_RT_PARAM_LITERAL( "Argument value missing for parameter " ) << p.id_2_report() );
-
-    BOOST_RT_CLA_VALIDATE_INPUT( !actual_arg || p.p_multiplicable, tr, 
-        BOOST_RT_PARAM_LITERAL( "Unexpected repetition of the parameter " ) << p.id_2_report() );
-
-    if( !!value && !!m_value_handler )
-        m_value_handler( p, *value );
-
-    if( !p.p_multiplicable )
-        actual_arg.reset( p.p_optional_value && (rtti::type_id<T>() != rtti::type_id<bool>())
-            ? static_cast<argument*>(new typed_argument<autoboost::optional<T> >( p, value ))
-            : static_cast<argument*>(new typed_argument<T>( p, *value )) );
-    else {
-        typedef std::list<autoboost::optional<T> > optional_list;
-
-        if( !actual_arg )
-            actual_arg.reset( p.p_optional_value 
-                ? static_cast<argument*>(new typed_argument<optional_list>( p ))
-                : static_cast<argument*>(new typed_argument<std::list<T> >( p )) );
-
-        if( p.p_optional_value ) {
-            optional_list& values = arg_value<optional_list>( *actual_arg );
-
-            values.push_back( value );
-        }
-        else {
-            std::list<T>& values = arg_value<std::list<T> >( *actual_arg );
-            
-            values.push_back( *value );
-        }
-    }
-
-    return actual_arg;
-}
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline argument_ptr 
-typed_argument_factory<T>::produce_using( parameter& p, parser const& pa )
-{
-    argument_ptr actual_arg;
-
-    if( !m_value_generator )
-        return actual_arg;
-
-    autoboost::optional<T> value;
-    m_value_generator( pa, value );
-
-    if( !value )
-        return actual_arg;
-
-    if( !!m_value_handler )
-        m_value_handler( p, *value );
-
-    actual_arg.reset( new typed_argument<T>( p, *value ) );
-
-    return actual_arg;
-}
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline void
-typed_argument_factory<T>::argument_usage_info( format_stream& fs )
-{
-    rt_cla_detail::argument_value_usage( fs, 0, reinterpret_cast<T*>(0) );
-}
-
-//____________________________________________________________________________//
-
-} // namespace autoboost
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace cla
-
-#endif // BOOST_RT_CLA_ARGUMENT_FACTORY_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/argv_traverser.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/argv_traverser.hpp
deleted file mode 100644
index af07cca14..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/argv_traverser.hpp
+++ /dev/null
@@ -1,98 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines facility to hide input traversing details
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_ARGV_TRAVERSER_HPP_062604GER
-#define BOOST_RT_CLA_ARGV_TRAVERSER_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-// Boost.Test
-#include <boost/test/utils/class_properties.hpp>
-
-// Boost
-#include <boost/noncopyable.hpp>
-#include <boost/shared_array.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************          runtime::cla::argv_traverser        ************** //
-// ************************************************************************** //
-
-class argv_traverser : noncopyable {
-    class parser;
-public:
-    // Constructor
-    argv_traverser();
-
-    // public_properties
-    unit_test::readwrite_property<bool>         p_ignore_mismatch;
-    unit_test::readwrite_property<char_type>    p_separator;
-
-    // argc+argv <-> internal buffer exchange
-    void            init( int argc, char_type** argv );
-    void            remainder( int& argc, char_type** argv );
-
-    // token based parsing
-    cstring         token() const;
-    void            next_token();
-
-    // whole input parsing
-    cstring         input() const;
-    void            trim( std::size_t size );
-    bool            match_front( cstring );
-    bool            match_front( char_type c );
-    bool            eoi() const;
-
-    // transaction logic support
-    void            commit();
-    void            rollback();
-
-    // current position access; used to save some reference points in input
-    std::size_t     input_pos() const;
-
-    // returns true if mismatch detected during input parsing handled successfully
-    bool            handle_mismatch();
-
-private:
-    // Data members
-    dstring                 m_buffer;
-    cstring                 m_work_buffer;
-
-    cstring                 m_token;
-    cstring::iterator       m_commited_end;
-
-    shared_array<char_type> m_remainder;
-    std::size_t             m_remainder_size;
-};
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#ifndef BOOST_RT_PARAM_OFFLINE
-
-#  define BOOST_RT_PARAM_INLINE inline
-#  include <boost/test/utils/runtime/cla/argv_traverser.ipp>
-
-#endif
-
-#endif // BOOST_RT_CLA_ARGV_TRAVERSER_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/argv_traverser.ipp b/contrib/autoboost/boost/test/utils/runtime/cla/argv_traverser.ipp
deleted file mode 100644
index c189d2ec9..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/argv_traverser.ipp
+++ /dev/null
@@ -1,209 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : implements facility to hide input traversing details
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_ARGV_TRAVERSER_IPP_070604GER
-#define BOOST_RT_CLA_ARGV_TRAVERSER_IPP_070604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/trace.hpp>
-
-#include <boost/test/utils/runtime/cla/argv_traverser.hpp>
-
-// STL
-#include <memory>
-#include <cstring>
-
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::memcpy; }
-#endif
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************          runtime::cla::argv_traverser        ************** //
-// ************************************************************************** //
-
-BOOST_RT_PARAM_INLINE
-argv_traverser::argv_traverser()
-: p_ignore_mismatch( false ), p_separator( BOOST_RT_PARAM_LITERAL( ' ' ) )
-{
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE void
-argv_traverser::init( int argc, char_type** argv )
-{
-    for( int index = 1; index < argc; ++index ) {
-        m_buffer += argv[index];
-        if( index != argc-1 )
-            m_buffer += BOOST_RT_PARAM_LITERAL( ' ' );
-    }
-
-    m_remainder.reset( new char_type[m_buffer.size()+1] );
-    m_remainder_size    = 0;
-    m_work_buffer       = m_buffer;
-    m_commited_end      = m_work_buffer.begin();
-
-    BOOST_RT_PARAM_TRACE( "Input buffer: " << m_buffer );
-
-    next_token();
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE void
-argv_traverser::remainder( int& argc, char_type** argv )
-{
-    argc = 1;
-    std::size_t pos = 0;
-    while(pos < m_remainder_size ) {
-        argv[argc++] = m_remainder.get() + pos;
-
-        pos = std::find( m_remainder.get() + pos, m_remainder.get() + m_remainder_size, 
-                         BOOST_RT_PARAM_LITERAL( ' ' ) ) - m_remainder.get();
-        m_remainder[pos++] = BOOST_RT_PARAM_LITERAL( '\0' );
-    }
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE cstring
-argv_traverser::token() const
-{
-    return m_token;
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE void
-argv_traverser::next_token()
-{
-    if( m_work_buffer.is_empty() )
-        return;
-
-    m_work_buffer.trim_left( m_token.size() ); // skip remainder of current token
-
-    if( m_work_buffer.size() != m_buffer.size() ) // !! is there a better way to identify first token
-        m_work_buffer.trim_left( 1 ); // skip separator if not first token;
-
-    m_token.assign( m_work_buffer.begin(),
-                    std::find( m_work_buffer.begin(), m_work_buffer.end(), p_separator ) );
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE cstring
-argv_traverser::input() const
-{
-    return m_work_buffer;
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE void
-argv_traverser::trim( std::size_t size )
-{
-    m_work_buffer.trim_left( size );
-
-    if( size <= m_token.size() )
-        m_token.trim_left( size );
-    else {
-        m_token.assign( m_work_buffer.begin(),
-                        std::find( m_work_buffer.begin(), m_work_buffer.end(), p_separator ) );
-    }
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE bool
-argv_traverser::match_front( cstring str )
-{
-    return m_work_buffer.size() < str.size() ? false : m_work_buffer.substr( 0, str.size() ) == str;
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE bool
-argv_traverser::match_front( char_type c )
-{
-    return first_char( m_work_buffer ) == c;
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE bool
-argv_traverser::eoi() const
-{
-    return m_work_buffer.is_empty();
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE void
-argv_traverser::commit()
-{
-    m_commited_end = m_work_buffer.begin();
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE void
-argv_traverser::rollback()
-{
-    m_work_buffer.assign( m_commited_end, m_work_buffer.end() );
-    m_token.assign( m_work_buffer.begin(),
-                    std::find( m_work_buffer.begin(), m_work_buffer.end(), p_separator ) );
-
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE std::size_t
-argv_traverser::input_pos() const
-{
-    return m_work_buffer.begin() - m_commited_end;
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE bool
-argv_traverser::handle_mismatch()
-{
-    if( !p_ignore_mismatch )
-        return false;
-
-    std::memcpy( m_remainder.get() + m_remainder_size, token().begin(), token().size() );
-    m_remainder_size += token().size();
-    m_remainder[m_remainder_size++] = p_separator;
-
-    next_token();
-    commit();
-
-    return true;
-}
-
-//____________________________________________________________________________//
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_ARGV_TRAVERSER_IPP_070604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/basic_parameter.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/basic_parameter.hpp
deleted file mode 100644
index 6ffdf49bb..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/basic_parameter.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : generic custom parameter generator
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_BASIC_PARAMETER_HPP_062604GER
-#define BOOST_RT_CLA_BASIC_PARAMETER_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#include <boost/test/utils/runtime/cla/typed_parameter.hpp>
-
-// Boost.Test
-#include <boost/test/utils/rtti.hpp>
-
-// Boost
-#include <boost/utility/base_from_member.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************         runtime::cla::basic_parameter        ************** //
-// ************************************************************************** //
-
-template<typename T, typename IdPolicy>
-class basic_parameter : private base_from_member<IdPolicy>, public typed_parameter<T> {
-public:
-    // Constructors
-    explicit    basic_parameter( cstring n ) 
-    : base_from_member<IdPolicy>()
-    , typed_parameter<T>( base_from_member<IdPolicy>::member )
-    {
-        this->accept_modifier( name = n );
-    }
-
-    // parameter properties modification
-    template<typename Modifier>
-    void        accept_modifier( Modifier const& m )
-    {
-        typed_parameter<T>::accept_modifier( m );
-
-        base_from_member<IdPolicy>::member.accept_modifier( m );
-    }
-};
-
-//____________________________________________________________________________//
-
-#define BOOST_RT_CLA_NAMED_PARAM_GENERATORS( param_type )                                       \
-template<typename T>                                                                            \
-inline shared_ptr<param_type ## _t<T> >                                                         \
-param_type( cstring name = cstring() )                                                          \
-{                                                                                               \
-    return shared_ptr<param_type ## _t<T> >( new param_type ## _t<T>( name ) );                 \
-}                                                                                               \
-                                                                                                \
-inline shared_ptr<param_type ## _t<cstring> >                                                   \
-param_type( cstring name = cstring() )                                                          \
-{                                                                                               \
-    return shared_ptr<param_type ## _t<cstring> >( new param_type ## _t<cstring>( name ) );     \
-}                                                                                               \
-/**/
-
-//____________________________________________________________________________//
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_BASIC_PARAMETER_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/char_parameter.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/char_parameter.hpp
deleted file mode 100644
index 03b09e196..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/char_parameter.hpp
+++ /dev/null
@@ -1,98 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines model of parameter with single char name
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_CHAR_PARAMETER_HPP_062604GER
-#define BOOST_RT_CLA_CHAR_PARAMETER_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-#include <boost/test/utils/runtime/validation.hpp>
-
-#include <boost/test/utils/runtime/cla/basic_parameter.hpp>
-#include <boost/test/utils/runtime/cla/id_policy.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************               char_name_policy               ************** //
-// ************************************************************************** //
-
-class char_name_policy : public basic_naming_policy {
-public:
-    // Constructor
-    char_name_policy();
-    BOOST_RT_PARAM_UNNEEDED_VIRTUAL ~char_name_policy() {}
-
-    // policy interface
-    virtual bool    conflict_with( identification_policy const& ) const;
-
-    // Accept modifier
-    template<typename Modifier>
-    void            accept_modifier( Modifier const& m )
-    {
-        basic_naming_policy::accept_modifier( m );
-
-        BOOST_RT_PARAM_VALIDATE_LOGIC( p_name->size() <= 1, "Invalid parameter name "  << p_name );
-    }
-};
-
-// ************************************************************************** //
-// **************          runtime::cla::char_parameter        ************** //
-// ************************************************************************** //
-
-template<typename T>
-class char_parameter_t : public basic_parameter<T,char_name_policy> {
-    typedef basic_parameter<T,char_name_policy> base;
-public:
-    // Constructors
-    explicit    char_parameter_t( char_type name ) : base( cstring( &name, 1 ) ) {}
-};
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline shared_ptr<char_parameter_t<T> >
-char_parameter( char_type name )
-{
-    return shared_ptr<char_parameter_t<T> >( new char_parameter_t<T>( name ) );
-}
-
-//____________________________________________________________________________//
-
-inline shared_ptr<char_parameter_t<cstring> >
-char_parameter( char_type name )
-{
-    return shared_ptr<char_parameter_t<cstring> >( new char_parameter_t<cstring>( name ) );
-}
-
-//____________________________________________________________________________//
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#ifndef BOOST_RT_PARAM_OFFLINE
-
-#  define BOOST_RT_PARAM_INLINE inline
-#  include <boost/test/utils/runtime/cla/char_parameter.ipp>
-
-#endif
-
-#endif // BOOST_RT_CLA_CHAR_PARAMETER_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/char_parameter.ipp b/contrib/autoboost/boost/test/utils/runtime/cla/char_parameter.ipp
deleted file mode 100644
index e1c457c27..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/char_parameter.ipp
+++ /dev/null
@@ -1,57 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : implements model of parameter with single char name
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_CHAR_PARAMETER_IPP_062904GER
-#define BOOST_RT_CLA_CHAR_PARAMETER_IPP_062904GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#include <boost/test/utils/runtime/cla/char_parameter.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************               char_name_policy               ************** //
-// ************************************************************************** //
-
-BOOST_RT_PARAM_INLINE 
-char_name_policy::char_name_policy()
-: basic_naming_policy( rtti::type_id<char_name_policy>() )
-{
-    assign_op( p_prefix.value, BOOST_RT_PARAM_CSTRING_LITERAL( "-" ), 0 );
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE bool
-char_name_policy::conflict_with( identification_policy const& id ) const
-{
-    return id.p_type_id == p_type_id && 
-           p_name == static_cast<char_name_policy const&>( id ).p_name;
-}
-
-//____________________________________________________________________________//
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_CHAR_PARAMETER_IPP_062904GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/detail/argument_value_usage.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/detail/argument_value_usage.hpp
deleted file mode 100644
index b0d927ee4..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/detail/argument_value_usage.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Permission to copy, use, modify, sell and distribute this software
-//  is granted provided this copyright notice appears in all copies.
-//  This software is provided "as is" without express or implied warranty,
-//  and with no claim as to its suitability for any purpose.
-  
-//  See http://www.boost.org for updates, documentation, and revision history.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : argument usage printing helpers
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_ARGUMENT_VALUE_USAGE_HPP_062604GER
-#define BOOST_RT_CLA_ARGUMENT_VALUE_USAGE_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-#include <boost/test/utils/runtime/cla/argv_traverser.hpp>
-
-// Boost.Test
-#include <boost/test/utils/basic_cstring/io.hpp>
-#include <boost/test/utils/basic_cstring/compare.hpp>
-
-#include <boost/lexical_cast.hpp>
-
-// STL
-// !! can we eliminate these includes?
-#include <list>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-namespace rt_cla_detail {
-
-// ************************************************************************** //
-// **************             argument_value_usage             ************** //
-// ************************************************************************** //
-
-// generic case
-template<typename T>
-inline void
-argument_value_usage( format_stream& fs, long, T* = 0 )
-{
-    fs << BOOST_RT_PARAM_CSTRING_LITERAL( "<value>" );
-}
-
-//____________________________________________________________________________//
-
-// specialization for list of values
-template<typename T>
-inline void
-argument_value_usage( format_stream& fs, int, std::list<T>* = 0 )
-{
-    fs << BOOST_RT_PARAM_CSTRING_LITERAL( "(<value1>, ..., <valueN>)" );
-}
-
-//____________________________________________________________________________//
-
-// specialization for type bool
-inline void
-argument_value_usage( format_stream& fs,  int, bool* = 0 )
-{
-    fs << BOOST_RT_PARAM_CSTRING_LITERAL( "yes|y|no|n" );
-}
-
-//____________________________________________________________________________//
-
-} // namespace rt_cla_detail
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_ARGUMENT_VALUE_USAGE_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/dual_name_parameter.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/dual_name_parameter.hpp
deleted file mode 100644
index 0eb648e1e..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/dual_name_parameter.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines model of generic parameter with dual naming
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_DUAL_NAME_PARAMETER_HPP_062604GER
-#define BOOST_RT_CLA_DUAL_NAME_PARAMETER_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#include <boost/test/utils/runtime/cla/named_parameter.hpp>
-#include <boost/test/utils/runtime/cla/char_parameter.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************               dual_name_policy               ************** //
-// ************************************************************************** //
-
-class dual_name_policy : public dual_id_policy<dual_name_policy,string_name_policy,char_name_policy> {
-public:
-    dual_name_policy();
-
-    // Accept modifier
-    template<typename Modifier>
-    void    accept_modifier( Modifier const& m )
-    {
-        if( m.has( prefix ) ) {
-            set_prefix( m[prefix] );
-            m.erase( prefix );
-        }
-
-        if( m.has( name ) ) {
-            set_name( m[name] );
-            m.erase( name );
-        }
-
-        if( m.has( separator ) ) {
-            set_separator( m[separator] );
-            m.erase( separator );
-        }
-
-        dual_id_policy<dual_name_policy,string_name_policy,char_name_policy>::accept_modifier( m );
-    }
-private:
-    void    set_prefix( cstring );
-    void    set_name( cstring );
-    void    set_separator( cstring );
-};
-
-// ************************************************************************** //
-// **************       runtime::cla::dual_name_parameter      ************** //
-// ************************************************************************** //
-
-template<typename T>
-class dual_name_parameter_t : public basic_parameter<T,dual_name_policy> {
-    typedef basic_parameter<T,dual_name_policy> base;
-public:
-    // Constructors
-    explicit    dual_name_parameter_t( cstring name ) : base( name ) {}
-};
-
-//____________________________________________________________________________//
-
-BOOST_RT_CLA_NAMED_PARAM_GENERATORS( dual_name_parameter )
-
-//____________________________________________________________________________//
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#ifndef BOOST_RT_PARAM_OFFLINE
-
-#  define BOOST_RT_PARAM_INLINE inline
-#  include <boost/test/utils/runtime/cla/dual_name_parameter.ipp>
-
-#endif
-
-#endif // BOOST_RT_CLA_DUAL_NAME_PARAMETER_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/dual_name_parameter.ipp b/contrib/autoboost/boost/test/utils/runtime/cla/dual_name_parameter.ipp
deleted file mode 100644
index 1e224eebc..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/dual_name_parameter.ipp
+++ /dev/null
@@ -1,90 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : implements model of generic parameter with dual naming
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_DUAL_NAME_PARAMETER_IPP_062904GER
-#define BOOST_RT_CLA_DUAL_NAME_PARAMETER_IPP_062904GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-#include <boost/test/utils/runtime/validation.hpp>
-
-#include <boost/test/utils/runtime/cla/dual_name_parameter.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************               dual_name_policy               ************** //
-// ************************************************************************** //
-
-BOOST_RT_PARAM_INLINE 
-dual_name_policy::dual_name_policy()
-{
-    m_primary.accept_modifier( prefix = BOOST_RT_PARAM_CSTRING_LITERAL( "--" ) );
-    m_secondary.accept_modifier( prefix = BOOST_RT_PARAM_CSTRING_LITERAL( "-" ) );
-}
-
-//____________________________________________________________________________//
-
-namespace {
-
-template<typename K>
-inline void
-split( string_name_policy& snp, char_name_policy& cnp, cstring src, K const& k )
-{
-    cstring::iterator sep = std::find( src.begin(), src.end(), BOOST_RT_PARAM_LITERAL( '|' ) );
-    
-    if( sep != src.begin() )
-        snp.accept_modifier( k = cstring( src.begin(), sep ) );
-
-    if( sep != src.end() )
-        cnp.accept_modifier( k = cstring( sep+1, src.end() ) );
-}
-
-} // local namespace
-
-BOOST_RT_PARAM_INLINE void
-dual_name_policy::set_prefix( cstring src )
-{
-    split( m_primary, m_secondary, src, prefix );
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE void
-dual_name_policy::set_name( cstring src )
-{
-    split( m_primary, m_secondary, src, name );
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE void
-dual_name_policy::set_separator( cstring src )
-{
-    split( m_primary, m_secondary, src, separator );
-}
-
-//____________________________________________________________________________//
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_DUAL_NAME_PARAMETER_IPP_062904GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/fwd.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/fwd.hpp
deleted file mode 100644
index 71dd536aa..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/fwd.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : cla subsystem forward declarations
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_FWD_HPP_062604GER
-#define BOOST_RT_CLA_FWD_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-// Boost
-#include <boost/shared_ptr.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-class parser;
-class parameter;
-typedef shared_ptr<parameter> parameter_ptr;
-class naming_policy;
-typedef shared_ptr<naming_policy> naming_policy_ptr;
-class argv_traverser;
-
-namespace rt_cla_detail {
-
-template<typename T> class const_generator;
-template<typename T> class ref_generator;
-
-template<typename T> class assigner;
-
-class named_parameter_base;
-class positional_parameter_base;
-
-} // namespace rt_cla_detail
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_FWD_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/id_policy.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/id_policy.hpp
deleted file mode 100644
index da38f1ed3..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/id_policy.hpp
+++ /dev/null
@@ -1,145 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : some generic identification policies definition
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_ID_POLICY_HPP_062604GER
-#define BOOST_RT_CLA_ID_POLICY_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#include <boost/test/utils/runtime/cla/fwd.hpp>
-#include <boost/test/utils/runtime/cla/modifier.hpp>
-#include <boost/test/utils/runtime/cla/argv_traverser.hpp>
-
-#include <boost/test/utils/runtime/cla/iface/id_policy.hpp>
-
-// Boost.Test
-#include <boost/test/utils/class_properties.hpp>
-#include <boost/test/utils/rtti.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************               naming_policy_base             ************** //
-// ************************************************************************** //
-// model: <prefix> <name> <separtor>
-
-class basic_naming_policy : public identification_policy {
-public:
-    // Public properties
-    unit_test::readwrite_property<dstring>    p_prefix;
-    unit_test::readwrite_property<dstring>    p_name;
-    unit_test::readwrite_property<dstring>    p_separator;
-
-    // Policy interface
-    virtual bool    responds_to( cstring name ) const       { return p_name == name; }
-    virtual cstring id_2_report() const                     { return p_name.get(); }
-    virtual void    usage_info( format_stream& fs ) const;
-    virtual bool    matching( parameter const& p, argv_traverser& tr, bool primary ) const;
-
-    // Accept modifier
-    template<typename Modifier>
-    void            accept_modifier( Modifier const& m )
-    {
-        nfp::optionally_assign( p_prefix.value,    m, prefix );
-        nfp::optionally_assign( p_name.value,      m, name );
-        nfp::optionally_assign( p_separator.value, m, separator );
-    }
-
-protected:
-    explicit basic_naming_policy( rtti::id_t dyn_type )
-    : identification_policy( dyn_type )
-    {}
-    BOOST_RT_PARAM_UNNEEDED_VIRTUAL ~basic_naming_policy() {}
-
-    // Naming policy interface
-    virtual bool    match_prefix( argv_traverser& tr ) const;
-    virtual bool    match_name( argv_traverser& tr ) const;
-    virtual bool    match_separator( argv_traverser& tr, bool optional_value ) const;
-};
-
-// ************************************************************************** //
-// **************                 dual_id_policy               ************** //
-// ************************************************************************** //
-
-template<typename MostDerived,typename PrimaryId,typename SecondId>
-class dual_id_policy : public identification_policy {
-public:
-    // Constructor
-    dual_id_policy()
-    : identification_policy( rtti::type_id<MostDerived>() )
-    , m_primary()
-    , m_secondary()
-    {}
-
-    // Policy interface
-    virtual bool    responds_to( cstring name ) const
-    {
-        return m_primary.responds_to( name ) || m_secondary.responds_to( name );
-    }
-    virtual bool    conflict_with( identification_policy const& id_p ) const
-    {
-        return id_p.conflict_with( m_primary ) || id_p.conflict_with( m_secondary );
-    }
-    virtual cstring id_2_report() const
-    {
-        return m_primary.id_2_report();
-    }
-    virtual void    usage_info( format_stream& fs ) const
-    {
-        fs << BOOST_RT_PARAM_LITERAL( '{' );
-        m_primary.usage_info( fs );
-        fs << BOOST_RT_PARAM_LITERAL( '|' );
-        m_secondary.usage_info( fs );
-        fs << BOOST_RT_PARAM_LITERAL( '}' );
-    }
-    virtual bool    matching( parameter const& p, argv_traverser& tr, bool primary ) const
-    {
-        return m_primary.matching( p, tr, primary ) || m_secondary.matching( p, tr, primary );
-    }
-
-    // Accept modifier
-    template<typename Modifier>
-    void    accept_modifier( Modifier const& m )
-    {
-        m_primary.accept_modifier( m );
-        m_secondary.accept_modifier( m );
-    }
-
-protected:
-    BOOST_RT_PARAM_UNNEEDED_VIRTUAL ~dual_id_policy() {}
-
-    // Data members
-    PrimaryId       m_primary;
-    SecondId        m_secondary;
-};
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#ifndef BOOST_RT_PARAM_OFFLINE
-
-#  define BOOST_RT_PARAM_INLINE inline
-#  include <boost/test/utils/runtime/cla/id_policy.ipp>
-
-#endif
-
-#endif // BOOST_RT_CLA_ID_POLICY_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/id_policy.ipp b/contrib/autoboost/boost/test/utils/runtime/cla/id_policy.ipp
deleted file mode 100644
index 39cf87a14..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/id_policy.ipp
+++ /dev/null
@@ -1,118 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : some generic identification policies implementation
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_ID_POLICY_IPP_062904GER
-#define BOOST_RT_CLA_ID_POLICY_IPP_062904GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#include <boost/test/utils/runtime/cla/id_policy.hpp>
-#include <boost/test/utils/runtime/cla/parameter.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************              basic_naming_policy             ************** //
-// ************************************************************************** //
-
-BOOST_RT_PARAM_INLINE void
-basic_naming_policy::usage_info( format_stream& fs ) const
-{
-    fs << p_prefix << p_name << p_separator;
-
-    if( p_separator->empty() )
-        fs << BOOST_RT_PARAM_LITERAL( ' ' );
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE bool
-basic_naming_policy::match_prefix( argv_traverser& tr ) const
-{
-    if( !tr.match_front( p_prefix.get() ) )
-        return false;
-
-    tr.trim( p_prefix->size() );
-    return true;
-}
-
-//____________________________________________________________________________//
-    
-BOOST_RT_PARAM_INLINE bool
-basic_naming_policy::match_name( argv_traverser& tr ) const
-{
-    if( !tr.match_front( p_name.get() ) )
-        return false;
-
-    tr.trim( p_name->size() );
-    return true;
-}
-
-//____________________________________________________________________________//
-    
-BOOST_RT_PARAM_INLINE bool
-basic_naming_policy::match_separator( argv_traverser& tr, bool optional_value ) const
-{
-    if( p_separator->empty() ) {
-        if( !tr.token().is_empty() )
-            return false;
-
-        tr.trim( 1 );
-    }
-    else {
-        if( !tr.match_front( p_separator.get() ) ) {
-            // if parameter has optional value separator is optional as well
-            if( optional_value && ( tr.eoi() || tr.match_front( ' ' ) ) ) {
-                return true;
-            }
-            return false;
-        }
-
-        tr.trim( p_separator->size() );
-    }
-
-    return true;
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE bool
-basic_naming_policy::matching( parameter const& p, argv_traverser& tr, bool ) const
-{
-    if( !match_prefix( tr ) )
-        return false;
-        
-    if( !match_name( tr ) )
-        return false;
-
-    if( !match_separator( tr, p.p_optional_value ) )
-        return false;
-
-    return true;
-}
-
-//____________________________________________________________________________//
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_ID_POLICY_IPP_062904GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/iface/argument_factory.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/iface/argument_factory.hpp
deleted file mode 100644
index b550770b0..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/iface/argument_factory.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines interface for argument_factory
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_IFACE_ARGUMENT_FACTORY_HPP_062604GER
-#define BOOST_RT_CLA_IFACE_ARGUMENT_FACTORY_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-#include <boost/test/utils/runtime/fwd.hpp>
-
-#include <boost/test/utils/runtime/cla/fwd.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************                argument_factory              ************** //
-// ************************************************************************** //
-// another name can be argument production policy
-
-class argument_factory {
-public:
-    // Argument factory interface
-    virtual argument_ptr produce_using( parameter& p, argv_traverser& tr ) = 0;  /// produce argument based on input
-    virtual argument_ptr produce_using( parameter& p, parser const& )      = 0;  /// produce argument based on internal generator and/or values of other parameters
-    virtual void         argument_usage_info( format_stream& fs )          = 0;  /// argument value format information
-protected:
-    BOOST_TEST_PROTECTED_VIRTUAL ~argument_factory() {}
-};
-
-} // namespace autoboost
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace cla
-
-#endif // BOOST_RT_CLA_IFACE_ARGUMENT_FACTORY_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/iface/id_policy.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/iface/id_policy.hpp
deleted file mode 100644
index dc1699125..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/iface/id_policy.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines interface for identification_policy
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_IFACE_ID_POLICY_HPP_062604GER
-#define BOOST_RT_CLA_IFACE_ID_POLICY_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#include <boost/test/utils/runtime/cla/fwd.hpp>
-
-// Boost.Test
-#include <boost/test/utils/class_properties.hpp>
-#include <boost/test/utils/rtti.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************             identification_policy            ************** //
-// ************************************************************************** //
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable:4244)
-#endif
-
-class identification_policy {
-public:
-    // Public properties
-    unit_test::readwrite_property<rtti::id_t>    p_type_id;
-
-    // Policy interface
-    virtual bool    responds_to( cstring name ) const = 0;
-    virtual cstring id_2_report() const = 0;
-    virtual void    usage_info( format_stream& fs ) const = 0;
-    virtual bool    matching( parameter const& p, argv_traverser& tr, bool primary ) const = 0;
-
-    virtual bool    conflict_with( identification_policy const& ) const = 0;
-
-protected:
-    // Constructor
-    explicit        identification_policy( rtti::id_t dyn_type )
-    : p_type_id( dyn_type )
-    {}
-    BOOST_TEST_PROTECTED_VIRTUAL ~identification_policy() {}
-};
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_IFACE_ID_POLICY_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/modifier.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/modifier.hpp
deleted file mode 100644
index 3cb233b62..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/modifier.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : parameter modifiers
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_MODIFIER_HPP_062604GER
-#define BOOST_RT_CLA_MODIFIER_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-// Boost.Test
-#include <boost/test/utils/named_params.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************         environment variable modifiers       ************** //
-// ************************************************************************** //
-
-namespace {
-
-nfp::typed_keyword<bool,struct optional_t>              optional_m;
-nfp::named_parameter<bool,optional_t,bool>              optional( true );
-nfp::typed_keyword<bool,struct required_t>              required_m;
-nfp::named_parameter<bool,required_t,bool>              required( true );
-nfp::typed_keyword<bool,struct multiplicable_t>         multiplicable_m;
-nfp::named_parameter<bool,multiplicable_t,bool>         multiplicable( true );
-nfp::typed_keyword<bool,struct guess_name_t>            guess_name_m;
-nfp::named_parameter<bool,guess_name_t,bool>            guess_name( true );
-nfp::typed_keyword<bool,struct ignore_mismatch_t>       ignore_mismatch_m;
-nfp::named_parameter<bool,ignore_mismatch_t,bool>       ignore_mismatch( true );
-nfp::typed_keyword<bool,struct optional_value_t>        optional_value_m;
-nfp::named_parameter<bool,optional_value_t,bool>        optional_value( true );
-
-nfp::typed_keyword<char_type,struct input_separator_t>  input_separator;
-nfp::typed_keyword<cstring,struct prefix_t>             prefix;
-nfp::typed_keyword<cstring,struct name_t>               name;
-nfp::typed_keyword<cstring,struct separator_t>          separator;
-nfp::typed_keyword<cstring,struct description_t>        description;
-nfp::typed_keyword<cstring,struct refer_to_t>           default_refer_to;
-
-nfp::keyword<struct default_value_t>                    default_value;
-nfp::keyword<struct handler_t>                          handler;
-nfp::keyword<struct interpreter_t>                      interpreter;
-nfp::keyword<struct assign_to_t>                        assign_to;
-
-} // local namespace
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_MODIFIER_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/named_parameter.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/named_parameter.hpp
deleted file mode 100644
index 0a72b14ff..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/named_parameter.hpp
+++ /dev/null
@@ -1,93 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines model of named parameter
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_NAMED_PARAMETER_HPP_062604GER
-#define BOOST_RT_CLA_NAMED_PARAMETER_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#include <boost/test/utils/runtime/cla/basic_parameter.hpp>
-#include <boost/test/utils/runtime/cla/id_policy.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************              string_name_policy              ************** //
-// ************************************************************************** //
-
-class string_name_policy : public basic_naming_policy {
-public:
-    // Constructor
-    string_name_policy();
-    BOOST_RT_PARAM_UNNEEDED_VIRTUAL ~string_name_policy() {}
-
-    // policy interface
-    virtual bool    responds_to( cstring name ) const;
-    virtual bool    conflict_with( identification_policy const& ) const;
-
-    // Accept modifier
-    template<typename Modifier>
-    void            accept_modifier( Modifier const& m )
-    {
-        basic_naming_policy::accept_modifier( m );
-
-        if( m.has( guess_name_m ) )
-            m_guess_name = true;
-    }
-
-private:
-    // Naming policy interface
-    virtual bool    match_name( argv_traverser& tr ) const;
-
-    // Data members
-    bool            m_guess_name;
-};
-
-// ************************************************************************** //
-// **************         runtime::cla::named_parameter        ************** //
-// ************************************************************************** //
-
-template<typename T>
-class named_parameter_t : public basic_parameter<T,string_name_policy> {
-    typedef basic_parameter<T,string_name_policy> base;
-public:
-    // Constructors
-    explicit    named_parameter_t( cstring name ) : base( name ) {}
-};
-
-//____________________________________________________________________________//
-
-BOOST_RT_CLA_NAMED_PARAM_GENERATORS( named_parameter )
-
-//____________________________________________________________________________//
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#ifndef BOOST_RT_PARAM_OFFLINE
-
-#  define BOOST_RT_PARAM_INLINE inline
-#  include <boost/test/utils/runtime/cla/named_parameter.ipp>
-
-#endif
-
-#endif // BOOST_RT_CLA_NAMED_PARAMETER_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/named_parameter.ipp b/contrib/autoboost/boost/test/utils/runtime/cla/named_parameter.ipp
deleted file mode 100644
index 2bf3d3120..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/named_parameter.ipp
+++ /dev/null
@@ -1,129 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : implements model of named parameter
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_NAMED_PARAMETER_IPP_062904GER
-#define BOOST_RT_CLA_NAMED_PARAMETER_IPP_062904GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#include <boost/test/utils/runtime/cla/named_parameter.hpp>
-#include <boost/test/utils/runtime/cla/char_parameter.hpp>
-
-// Boost.Test
-#include <boost/test/utils/algorithm.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************              string_name_policy              ************** //
-// ************************************************************************** //
-
-BOOST_RT_PARAM_INLINE 
-string_name_policy::string_name_policy()
-: basic_naming_policy( rtti::type_id<string_name_policy>() )
-, m_guess_name( false )
-{
-    assign_op( p_prefix.value, BOOST_RT_PARAM_CSTRING_LITERAL( "-" ), 0 );
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE bool
-string_name_policy::responds_to( cstring name ) const
-{
-    std::pair<cstring::iterator,dstring::const_iterator> mm_pos;
-
-    mm_pos = unit_test::mismatch( name.begin(), name.end(), p_name->begin(), p_name->end() );
-
-    return mm_pos.first == name.end() && (m_guess_name || (mm_pos.second == p_name->end()) );
-}
-
-//____________________________________________________________________________//
-
-#ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable:4244)
-#endif
-
-BOOST_RT_PARAM_INLINE bool
-string_name_policy::conflict_with( identification_policy const& id ) const
-{
-    if( id.p_type_id == p_type_id ) {
-        string_name_policy const& snp = static_cast<string_name_policy const&>( id );
-
-        if( p_name->empty() || snp.p_name->empty() )
-            return false;
-
-        if( p_prefix != snp.p_prefix )
-            return false;
-
-        std::pair<dstring::const_iterator,dstring::const_iterator> mm_pos =
-            unit_test::mismatch( p_name->begin(), p_name->end(), snp.p_name->begin(), snp.p_name->end() );
-
-        return mm_pos.first != p_name->begin()                              &&  // there is common substring
-                ((m_guess_name    && (mm_pos.second == snp.p_name->end()) ) ||  // that match other guy and I am guessing
-                (snp.m_guess_name && (mm_pos.first  == p_name->end()) ));       // or me and the other guy is
-    }
-    
-    if( id.p_type_id == rtti::type_id<char_name_policy>() ) {
-        char_name_policy const& cnp = static_cast<char_name_policy const&>( id );
-
-        return m_guess_name                 && 
-               (p_prefix == cnp.p_prefix)   && 
-               unit_test::first_char( cstring( p_name ) ) == unit_test::first_char( cstring( cnp.p_name ) );
-    }
-    
-    return false;    
-}
-
-#ifdef BOOST_MSVC
-#  pragma warning(pop)
-#endif
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE bool
-string_name_policy::match_name( argv_traverser& tr ) const
-{
-    if( !m_guess_name )
-        return basic_naming_policy::match_name( tr );
-
-    cstring in = tr.input();
-
-    std::pair<cstring::iterator,dstring::const_iterator> mm_pos;
-    
-    mm_pos = unit_test::mismatch( in.begin(), in.end(), p_name->begin(), p_name->end() );
-
-    if( mm_pos.first == in.begin() )
-        return false;
-
-    tr.trim( mm_pos.first - in.begin() );
-
-    return true;
-}
-
-//____________________________________________________________________________//
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_NAMED_PARAMETER_IPP_062904GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/parameter.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/parameter.hpp
deleted file mode 100644
index 6014292b6..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/parameter.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines model of formal parameter
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_PARAMETER_HPP_062604GER
-#define BOOST_RT_CLA_PARAMETER_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#include <boost/test/utils/runtime/fwd.hpp>
-#include <boost/test/utils/runtime/parameter.hpp>
-#include <boost/test/utils/runtime/validation.hpp>
-
-#include <boost/test/utils/runtime/cla/fwd.hpp>
-#include <boost/test/utils/runtime/cla/modifier.hpp>
-#include <boost/test/utils/runtime/cla/iface/argument_factory.hpp>
-#include <boost/test/utils/runtime/cla/iface/id_policy.hpp>
-
-// Boost.Test
-#include <boost/test/utils/rtti.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************            runtime::cla::parameter           ************** //
-// ************************************************************************** //
-
-class parameter : public BOOST_RT_PARAM_NAMESPACE::parameter {
-public:
-    parameter( identification_policy& ID, argument_factory& F, bool optional_value = false )
-    : p_optional( false )
-    , p_multiplicable( false )
-    , p_optional_value( optional_value )
-    , m_id_policy( ID )
-    , m_arg_factory( F )
-    {}
-
-    // Destructor
-    virtual         ~parameter()                                {}
-
-    unit_test::readwrite_property<bool>      p_optional;
-    unit_test::readwrite_property<bool>      p_multiplicable;
-    unit_test::readwrite_property<bool>      p_optional_value;
-    unit_test::readwrite_property<dstring>   p_description;
-
-    // parameter properties modification
-    template<typename Modifier>
-    void            accept_modifier( Modifier const& m )
-    {
-        if( m.has( optional_m ) )
-            p_optional.value = true;
-
-        if( m.has( required_m ) )
-            p_optional.value = false;
-
-        if( m.has( multiplicable_m ) )
-            p_multiplicable.value = true;
-
-        if( m.has( optional_value_m ) )
-            p_optional_value.value = true;
-
-        nfp::optionally_assign( p_description.value, m, description );
-    }
-
-    // access methods
-    bool            has_argument() const                        { return m_actual_argument!=0; }
-    argument const& actual_argument() const                     { return *m_actual_argument; }
-    argument_ptr    actual_argument()                           { return m_actual_argument; }
-
-
-    // identification interface
-    bool            responds_to( cstring name ) const           { return m_id_policy.responds_to( name ); }
-    bool            conflict_with( parameter const& p ) const
-    {
-        return (id_2_report() == p.id_2_report() && !id_2_report().is_empty())  ||
-               m_id_policy.conflict_with( p.m_id_policy )                       || 
-               ((m_id_policy.p_type_id != p.m_id_policy.p_type_id) && p.m_id_policy.conflict_with( m_id_policy ));
-    }
-    cstring         id_2_report() const                         { return m_id_policy.id_2_report(); }
-    void            usage_info( format_stream& fs ) const
-    { 
-        m_id_policy.usage_info( fs );
-        if( p_optional_value )
-            fs << BOOST_RT_PARAM_LITERAL( '[' );
-
-        m_arg_factory.argument_usage_info( fs );
-
-        if( p_optional_value )
-            fs << BOOST_RT_PARAM_LITERAL( ']' );
-    }
-
-    // argument match/produce based on input
-    bool            matching( argv_traverser& tr, bool primary ) const
-    {
-        return m_id_policy.matching( *this, tr, primary );
-    }
-
-    // argument production based on different source
-    void            produce_argument( argv_traverser& tr )
-    {
-        m_id_policy.matching( *this, tr, true ); // !! can we save this position somehow
-        m_actual_argument = m_arg_factory.produce_using( *this, tr );
-    }
-    void            produce_argument( parser const& p )
-    {
-        m_actual_argument = m_arg_factory.produce_using( *this, p );
-    }
-
-private:
-    //Data members
-    identification_policy&  m_id_policy;
-    argument_factory&       m_arg_factory;
-    argument_ptr            m_actual_argument;
-};
-
-//____________________________________________________________________________//
-
-template<typename Parameter,typename Modifier>
-inline shared_ptr<Parameter>
-operator-( shared_ptr<Parameter> p, Modifier const& m )
-{
-    p->accept_modifier( m );
-
-    return p;
-}
-
-//____________________________________________________________________________//
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_PARAMETER_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/parser.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/parser.hpp
deleted file mode 100644
index c3057d38a..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/parser.hpp
+++ /dev/null
@@ -1,153 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines parser - public interface for CLA parsing and accessing
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_PARSER_HPP_062604GER
-#define BOOST_RT_CLA_PARSER_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-#include <boost/test/utils/runtime/fwd.hpp>
-#include <boost/test/utils/runtime/argument.hpp>
-
-#include <boost/test/utils/runtime/cla/fwd.hpp>
-#include <boost/test/utils/runtime/cla/modifier.hpp>
-#include <boost/test/utils/runtime/cla/argv_traverser.hpp>
-
-// Boost
-#include <boost/optional.hpp>
-
-// STL
-#include <list>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************             runtime::cla::parser             ************** //
-// ************************************************************************** //
-
-namespace cla_detail {
-
-template<typename Modifier>
-class global_mod_parser {
-public:
-    global_mod_parser( parser& p, Modifier const& m )
-    : m_parser( p )
-    , m_modifiers( m )
-    {}
-
-    template<typename Param>
-    global_mod_parser const&
-    operator<<( shared_ptr<Param> param ) const
-    {
-        param->accept_modifier( m_modifiers );
-
-        m_parser << param;
-
-        return *this;
-    }
-
-private:
-    // Data members;
-    parser&             m_parser;
-    Modifier const&     m_modifiers;
-};
-
-}
-
-// ************************************************************************** //
-// **************             runtime::cla::parser             ************** //
-// ************************************************************************** //
-
-class parser {
-public:
-    typedef std::list<parameter_ptr>::const_iterator param_iterator;
-
-    // Constructor
-    explicit            parser( cstring program_name = cstring() );
-
-    // parameter list construction interface
-    parser&             operator<<( parameter_ptr param );
-
-    // parser and global parameters modifiers
-    template<typename Modifier>
-    cla_detail::global_mod_parser<Modifier>
-    operator-( Modifier const& m )
-    {
-        nfp::optionally_assign( m_traverser.p_separator.value, m, input_separator );
-        nfp::optionally_assign( m_traverser.p_ignore_mismatch.value, m, ignore_mismatch_m );
-
-        return cla_detail::global_mod_parser<Modifier>( *this, m );
-    }
-
-    // input processing method
-    void                parse( int& argc, char_type** argv );
-
-    // parameters access
-    param_iterator      first_param() const;
-    param_iterator      last_param() const;
-
-    // arguments access
-    const_argument_ptr  operator[]( cstring string_id ) const;
-    cstring             get( cstring string_id ) const;    
-
-    template<typename T>
-    T const&            get( cstring string_id ) const
-    {
-        return arg_value<T>( valid_argument( string_id ) );
-    }
-
-    template<typename T>
-    void                get( cstring string_id, autoboost::optional<T>& res ) const
-    {
-        const_argument_ptr actual_arg = (*this)[string_id];
-
-        if( actual_arg )
-            res = arg_value<T>( *actual_arg );
-        else
-            res.reset();
-    }
-
-    // help/usage
-    void                usage( out_stream& ostr );
-    void                help(  out_stream& ostr );
-
-private:
-    argument const&     valid_argument( cstring string_id ) const;
-
-    // Data members
-    argv_traverser              m_traverser;
-    std::list<parameter_ptr>    m_parameters;
-    dstring                     m_program_name;
-};
-
-//____________________________________________________________________________//
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#ifndef BOOST_RT_PARAM_OFFLINE
-
-#  define BOOST_RT_PARAM_INLINE inline
-#  include <boost/test/utils/runtime/cla/parser.ipp>
-
-#endif
-
-#endif // BOOST_RT_CLA_PARSER_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/parser.ipp b/contrib/autoboost/boost/test/utils/runtime/cla/parser.ipp
deleted file mode 100644
index 166db1d23..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/parser.ipp
+++ /dev/null
@@ -1,258 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : implements parser - public interface for CLA parsing and accessing
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_PARSER_IPP_062904GER
-#define BOOST_RT_CLA_PARSER_IPP_062904GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-#include <boost/test/utils/runtime/trace.hpp>
-#include <boost/test/utils/runtime/argument.hpp>
-
-#include <boost/test/utils/runtime/cla/argv_traverser.hpp>
-#include <boost/test/utils/runtime/cla/parameter.hpp>
-#include <boost/test/utils/runtime/cla/modifier.hpp>
-#include <boost/test/utils/runtime/cla/validation.hpp>
-#include <boost/test/utils/runtime/cla/parser.hpp>
-
-// Boost.Test
-#include <boost/test/utils/basic_cstring/io.hpp>
-#include <boost/test/utils/foreach.hpp>
-
-// Boost
-#include <boost/lexical_cast.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************             runtime::cla::parser             ************** //
-// ************************************************************************** //
-
-BOOST_RT_PARAM_INLINE
-parser::parser( cstring program_name )
-{
-    assign_op( m_program_name, program_name, 0 );
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE parser::param_iterator
-parser::first_param() const
-{
-    return m_parameters.begin();
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE parser::param_iterator
-parser::last_param() const
-{
-    return m_parameters.end();
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE argument const&
-parser::valid_argument( cstring string_id ) const
-{
-    const_argument_ptr arg = (*this)[string_id];
-
-    BOOST_RT_PARAM_VALIDATE_LOGIC( !!arg, "Actual argument for parameter " << string_id << " is not present" );
-
-    return *arg;
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE parser&
-parser::operator<<( parameter_ptr new_param )
-{
-    BOOST_TEST_FOREACH( parameter_ptr, old_param, m_parameters ) {
-        BOOST_RT_PARAM_VALIDATE_LOGIC( !old_param->conflict_with( *new_param ),
-            BOOST_RT_PARAM_LITERAL( "Definition of parameter " )                << new_param->id_2_report() << 
-            BOOST_RT_PARAM_LITERAL( " conflicts with defintion of parameter " ) << old_param->id_2_report() );
-    }
-
-    m_parameters.push_back( new_param );
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE void
-parser::parse( int& argc, char_type** argv )
-{
-    if( m_program_name.empty() ) {
-        m_program_name.assign( argv[0] );
-        dstring::size_type pos = m_program_name.find_last_of( BOOST_RT_PARAM_LITERAL( "/\\" ) );
-
-        if( pos != static_cast<dstring::size_type>(cstring::npos) )
-            m_program_name.erase( 0, pos+1 );
-    }
-
-    m_traverser.init( argc, argv );
-
-    try {
-        while( !m_traverser.eoi() ) {
-            parameter_ptr found_param;
-
-            BOOST_RT_PARAM_TRACE( "Total " << m_parameters.size() << " parameters registered" );
-
-            BOOST_TEST_FOREACH( parameter_ptr const&, curr_param, m_parameters ) {
-                BOOST_RT_PARAM_TRACE( "Try parameter " << curr_param->id_2_report() );
-
-                if( curr_param->matching( m_traverser, !found_param ) ) {
-                    BOOST_RT_PARAM_TRACE( "Match found" );
-                    BOOST_RT_CLA_VALIDATE_INPUT( !found_param, (m_traverser.rollback(),m_traverser), "Ambiguous input" );
-
-                    found_param = curr_param;
-                }
-
-                m_traverser.rollback();
-            }
-
-            if( !found_param ) {
-                BOOST_RT_PARAM_TRACE( "No match found" );
-                BOOST_RT_CLA_VALIDATE_INPUT( m_traverser.handle_mismatch(), m_traverser,
-                                             BOOST_RT_PARAM_LITERAL( "Unexpected input" ) );
-
-                continue;
-            }
-
-            BOOST_RT_PARAM_TRACE( "Parse argument value" );
-            found_param->produce_argument( m_traverser );
-
-            m_traverser.commit();
-        }
-
-        BOOST_TEST_FOREACH( parameter_ptr const&, curr_param, m_parameters ) {
-            if( !curr_param->p_optional && !curr_param->actual_argument() ) {
-                curr_param->produce_argument( *this );
-
-                BOOST_RT_PARAM_VALIDATE_LOGIC( curr_param->actual_argument(),
-                    BOOST_RT_PARAM_LITERAL( "Required argument for parameter " ) << curr_param->id_2_report()
-                        << BOOST_RT_PARAM_LITERAL( " is missing" ) );
-            }
-        }
-    }
-    catch( bad_lexical_cast const& ) {
-        BOOST_RT_PARAM_REPORT_LOGIC_ERROR( 
-            BOOST_RT_PARAM_LITERAL( "String to value convertion error during input parsing" ) );
-    }
-
-    m_traverser.remainder( argc, argv );
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE const_argument_ptr
-parser::operator[]( cstring string_id ) const
-{
-    parameter_ptr found_param;
-
-    BOOST_TEST_FOREACH( parameter_ptr const&, curr_param, m_parameters ) {
-        if( curr_param->responds_to( string_id ) ) {
-            BOOST_RT_PARAM_VALIDATE_LOGIC( !found_param,
-                                           BOOST_RT_PARAM_LITERAL( "Ambiguous parameter string id: " ) << string_id );
-
-            found_param = curr_param;
-        }
-    }
-
-    return found_param ? found_param->actual_argument() : argument_ptr();
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE cstring
-parser::get( cstring string_id ) const
-{
-    return get<cstring>( string_id );
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE void
-parser::usage( out_stream& ostr )
-{
-    if( m_program_name.empty() )
-        assign_op( m_program_name, BOOST_RT_PARAM_CSTRING_LITERAL( "<program>" ), 0 );
-
-    format_stream fs;
-
-    fs << m_program_name;
-
-    BOOST_TEST_FOREACH( parameter_ptr const&, curr_param, m_parameters ) {
-        fs << BOOST_RT_PARAM_LITERAL( ' ' );
-
-        if( curr_param->p_optional )
-            fs << BOOST_RT_PARAM_LITERAL( '[' );
-
-        curr_param->usage_info( fs );
-
-        if( curr_param->p_optional )
-            fs << BOOST_RT_PARAM_LITERAL( ']' );
-
-        if( curr_param->p_multiplicable ) {
-            fs << BOOST_RT_PARAM_CSTRING_LITERAL( " ... " );
-            
-            if( curr_param->p_optional )
-                fs << BOOST_RT_PARAM_LITERAL( '[' );
-
-            curr_param->usage_info( fs );
-
-            if( curr_param->p_optional )
-                fs << BOOST_RT_PARAM_LITERAL( ']' );
-        }
-    }
-
-    ostr << BOOST_RT_PARAM_CSTRING_LITERAL( "Usage:\n" ) << fs.str() << std::endl;
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE void
-parser::help( out_stream& ostr )
-{
-    usage( ostr );
-
-    bool need_where = true;
-
-    BOOST_TEST_FOREACH( parameter_ptr const&, curr_param, m_parameters ) {
-        if( curr_param->p_description->empty() )
-            continue;
-
-        if( need_where ) {
-            ostr << BOOST_RT_PARAM_CSTRING_LITERAL( "where:\n" );
-            need_where = false;
-        }
-
-        ostr << curr_param->id_2_report() << BOOST_RT_PARAM_CSTRING_LITERAL( " - " ) << curr_param->p_description << std::endl;
-    }
-}
-
-//____________________________________________________________________________//
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_PARSER_IPP_062904GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/typed_parameter.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/typed_parameter.hpp
deleted file mode 100644
index 5e735d241..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/typed_parameter.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : generic typed parameter model
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_TYPED_PARAMETER_HPP_062604GER
-#define BOOST_RT_CLA_TYPED_PARAMETER_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#include <boost/test/utils/runtime/fwd.hpp>
-#include <boost/test/utils/runtime/validation.hpp>
-
-#include <boost/test/utils/runtime/cla/parameter.hpp>
-#include <boost/test/utils/runtime/cla/argument_factory.hpp>
-
-// Boost.Test
-#include <boost/test/utils/rtti.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************         runtime::cla::typed_parameter        ************** //
-// ************************************************************************** //
-
-template<typename T>
-class typed_parameter : public cla::parameter {
-public:
-    explicit typed_parameter( identification_policy& ID ) 
-    : cla::parameter( ID, m_arg_factory, rtti::type_id<T>() == rtti::type_id<bool>() ) 
-    {}
-
-    // parameter properties modification
-    template<typename Modifier>
-    void    accept_modifier( Modifier const& m )
-    {
-        cla::parameter::accept_modifier( m );
-
-        m_arg_factory.accept_modifier( m );
-
-        BOOST_RT_PARAM_VALIDATE_LOGIC( !p_optional || !m_arg_factory.m_value_generator,
-            BOOST_RT_PARAM_LITERAL( "can't define a value generator for optional parameter " ) << id_2_report() );
-    }
-
-private:
-    // Data members
-    typed_argument_factory<T>   m_arg_factory;
-};
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_TYPED_PARAMETER_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/validation.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/validation.hpp
deleted file mode 100644
index 97c905530..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/validation.hpp
+++ /dev/null
@@ -1,55 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : input validation helpers definition
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_VALIDATION_HPP_062604GER
-#define BOOST_RT_CLA_VALIDATION_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#include <boost/test/utils/runtime/cla/fwd.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************       runtime::cla::report_input_error       ************** //
-// ************************************************************************** //
-
-void report_input_error( argv_traverser const& tr, format_stream& msg );
-
-//____________________________________________________________________________//
-
-#define BOOST_RT_CLA_VALIDATE_INPUT( b, tr, msg ) \
-    if( b ) ; else ::autoboost::BOOST_RT_PARAM_NAMESPACE::cla::report_input_error( tr, format_stream().ref() << msg )
-
-//____________________________________________________________________________//
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#ifndef BOOST_RT_PARAM_OFFLINE
-
-#  define BOOST_RT_PARAM_INLINE inline
-#  include <boost/test/utils/runtime/cla/validation.ipp>
-
-#endif
-
-#endif // BOOST_RT_CLA_VALIDATION_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/validation.ipp b/contrib/autoboost/boost/test/utils/runtime/cla/validation.ipp
deleted file mode 100644
index ef0de25ba..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/validation.ipp
+++ /dev/null
@@ -1,65 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : input validation helpers implementation
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_VALIDATION_IPP_070604GER
-#define BOOST_RT_CLA_VALIDATION_IPP_070604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#include <boost/test/utils/runtime/cla/argv_traverser.hpp>
-#include <boost/test/utils/runtime/cla/validation.hpp>
-#include <boost/test/utils/runtime/validation.hpp> // BOOST_RT_PARAM_NAMESPACE::logic_error
-
-// Boost
-#include <boost/test/utils/basic_cstring/io.hpp>
-
-// STL
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-// ************************************************************************** //
-// **************           runtime::cla::validation           ************** //
-// ************************************************************************** //
-
-BOOST_RT_PARAM_INLINE void
-report_input_error( argv_traverser const& tr, format_stream& msg )
-{
-    if( tr.eoi() )
-        msg << BOOST_RT_PARAM_LITERAL( " at the end of input" );
-    else {
-        msg << BOOST_RT_PARAM_LITERAL( " in the following position: " );
-
-        if( tr.input().size() > 5 )
-            msg << tr.input().substr( 0, 5 ) << BOOST_RT_PARAM_LITERAL( "..." );
-        else
-            msg << tr.input();
-    }
-
-    throw BOOST_RT_PARAM_NAMESPACE::logic_error( msg.str() );
-}
-
-//____________________________________________________________________________//
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_VALIDATION_IPP_070604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/value_generator.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/value_generator.hpp
deleted file mode 100644
index 54be8505a..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/value_generator.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : specific value generators
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_VALUE_GENERATOR_HPP_062604GER
-#define BOOST_RT_CLA_VALUE_GENERATOR_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#include <boost/test/utils/runtime/cla/fwd.hpp>
-#include <boost/test/utils/runtime/cla/parser.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-namespace rt_cla_detail {
-
-// ************************************************************************** //
-// **************        runtime::cla::const_generator         ************** //
-// ************************************************************************** //
-
-template<typename T>
-class const_generator {
-public:
-    // Constructor
-    explicit    const_generator( T const& t ) : m_const_value( t ) {}
-
-    // generator interface
-    void        operator()( parser const&, autoboost::optional<T>& t ) const   { t = m_const_value; }
-
-private:
-    // Data members
-    T           m_const_value;
-};
-
-// ************************************************************************** //
-// **************         runtime::cla::ref_generator          ************** //
-// ************************************************************************** //
-
-template<typename T>
-class ref_generator {
-public:
-    // Constructor
-    explicit    ref_generator( cstring ref_id ) : m_ref_id( ref_id ) {}
-
-    // generator interface
-    void        operator()( parser const& p, autoboost::optional<T>& t ) const
-    {
-        p.get( m_ref_id, t );
-    }
-
-private:
-    // Data members
-    cstring     m_ref_id;
-};
-
-//____________________________________________________________________________//
-
-} // namespace rt_cla_detail
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_VALUE_GENERATOR_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/cla/value_handler.hpp b/contrib/autoboost/boost/test/utils/runtime/cla/value_handler.hpp
deleted file mode 100644
index 22e9e47f3..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/cla/value_handler.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : specific value handlers
-// ***************************************************************************
-
-#ifndef BOOST_RT_CLA_VALUE_HANDLER_HPP_062604GER
-#define BOOST_RT_CLA_VALUE_HANDLER_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#include <boost/test/utils/runtime/cla/fwd.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace cla {
-
-namespace rt_cla_detail {
-
-// ************************************************************************** //
-// **************            runtime::cla::assigner            ************** //
-// ************************************************************************** //
-
-template<typename T>
-class assigner {
-public:
-    // Constructor
-    explicit    assigner( T& loc ) : m_target( loc )    {}
-
-    // value handler implementation
-    void        operator()( parameter const&, T& t )  { m_target = t; }
-
-private:
-    // Data members
-    T&          m_target;
-};
-
-} // namespace rt_cla_detail
-
-} // namespace cla
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CLA_VALUE_HANDLER_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/config.hpp b/contrib/autoboost/boost/test/utils/runtime/config.hpp
deleted file mode 100644
index a48e60acb..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/config.hpp
+++ /dev/null
@@ -1,156 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : Runtime.Param library configuration
-// ***************************************************************************
-
-#ifndef BOOST_RT_CONFIG_HPP_062604GER
-#define BOOST_RT_CONFIG_HPP_062604GER
-
-// Boost
-#include <boost/config.hpp>
-#ifdef BOOST_MSVC
-# pragma warning(disable: 4511) // copy constructor could not be generated
-# pragma warning(disable: 4512) // assignment operator could not be generated
-# pragma warning(disable: 4181) // qualifier applied to reference type; ignored
-# pragma warning(disable: 4675) // resolved overload was found by argument-dependent lookup
-#endif
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-#include <boost/test/utils/wrap_stringstream.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp> // operator<<(autoboost::runtime::cstring)
-
-// STL
-#include <string>
-#include <cstdlib>
-
-//____________________________________________________________________________//
-
-#ifndef BOOST_RT_PARAM_CUSTOM_STRING
-#  ifndef BOOST_RT_PARAM_WIDE_STRING
-#    define BOOST_RT_PARAM_NAMESPACE                            runtime
-#  else
-#    define BOOST_RT_PARAM_NAMESPACE                            wide_runtime
-#  endif
-#endif
-
-#ifdef __SUNPRO_CC
-extern int putenv(char*);
-#endif
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-#ifndef BOOST_RT_PARAM_CUSTOM_STRING
-#  ifndef BOOST_RT_PARAM_WIDE_STRING
-
-typedef char                                                    char_type;
-typedef std::string                                             dstring;
-typedef unit_test::const_string                                 cstring;
-typedef unit_test::literal_string                               literal_cstring;
-typedef wrap_stringstream                                       format_stream;
-
-#ifdef BOOST_CLASSIC_IOSTREAMS
-typedef std::ostream                                            out_stream;
-#else
-typedef std::basic_ostream<char_type>                           out_stream;
-#endif
-
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4996) // putenv
-#endif
-
-#ifndef UNDER_CE
-#if defined(__COMO__) && 0
-inline void
-putenv_impl( cstring name, cstring value )
-{
-    using namespace std;
-    // !! this may actually fail. What should we do?
-    setenv( name.begin(), value.begin(), 1 );
-}
-#else
-inline void
-putenv_impl( cstring name, cstring value )
-{
-    format_stream fs;
-
-    fs << name << '=' << value;
-
-    // !! this may actually fail. What should we do?
-    // const_cast is used to satisfy putenv interface
-    using namespace std;
-    putenv( const_cast<char*>( fs.str().c_str() ) );
-}
-#endif
-#endif
-
-#ifdef BOOST_MSVC 
-#pragma warning(pop) 
-#endif 
-
-#define BOOST_RT_PARAM_LITERAL( l ) l
-#define BOOST_RT_PARAM_CSTRING_LITERAL( l ) cstring( l, sizeof( l ) - 1 )
-#define BOOST_RT_PARAM_GETENV getenv
-#define BOOST_RT_PARAM_PUTENV ::autoboost::BOOST_RT_PARAM_NAMESPACE::putenv_impl
-#define BOOST_RT_PARAM_EXCEPTION_INHERIT_STD
-
-//____________________________________________________________________________//
-
-#  else
-
-typedef wchar_t                                                 char_type;
-typedef std::basic_string<char_type>                            dstring;
-typedef unit_test::basic_cstring<wchar_t const>                 cstring;
-typedef const unit_test::basic_cstring<wchar_t const>           literal_cstring;
-typedef wrap_wstringstream                                      format_stream;
-typedef std::wostream                                           out_stream;
-
-#ifndef UNDER_CE
-inline void
-putenv_impl( cstring name, cstring value )
-{
-    format_stream fs;
-
-    fs << name << '=' << value;
-
-    // !! this may actually fail. What should we do?
-    // const_cast is used to satisfy putenv interface
-    using namespace std;
-    wputenv( const_cast<wchar_t*>( fs.str().c_str() ) );
-}
-#endif
-
-#define BOOST_RT_PARAM_LITERAL( l ) L ## l
-#define BOOST_RT_PARAM_CSTRING_LITERAL( l ) cstring( L ## l, sizeof( L ## l )/sizeof(wchar_t) - 1 )
-#define BOOST_RT_PARAM_GETENV wgetenv
-#define BOOST_RT_PARAM_PUTENV putenv_impl
-
-#  endif
-#endif
-
-#ifdef __GNUC__
-#define BOOST_RT_PARAM_UNNEEDED_VIRTUAL virtual
-#else
-#define BOOST_RT_PARAM_UNNEEDED_VIRTUAL
-#endif
-
-//____________________________________________________________________________//
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_CONFIG_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/env/environment.hpp b/contrib/autoboost/boost/test/utils/runtime/env/environment.hpp
deleted file mode 100644
index e66e38d02..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/env/environment.hpp
+++ /dev/null
@@ -1,172 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines and implements inline model of program environment 
-// ***************************************************************************
-
-#ifndef BOOST_RT_ENV_ENVIRONMENT_HPP_062604GER
-#define BOOST_RT_ENV_ENVIRONMENT_HPP_062604GER
-
-#ifdef UNDER_CE
-#error Windows CE does not support environment variables.
-#endif
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-#include <boost/test/utils/runtime/fwd.hpp>
-#include <boost/test/utils/runtime/argument.hpp>
-#include <boost/test/utils/runtime/interpret_argument_value.hpp>
-
-#include <boost/test/utils/runtime/env/fwd.hpp>
-#include <boost/test/utils/runtime/env/modifier.hpp>
-#include <boost/test/utils/runtime/env/variable.hpp>
-
-// Boost.Test
-#include <boost/test/utils/callback.hpp>
-
-// Boost
-#include <boost/optional.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-// ************************************************************************** //
-// **************      runtime::environment implementation     ************** //
-// ************************************************************************** //
-
-namespace environment {
-
-namespace rt_env_detail {
-
-template<typename T, typename Modifiers>
-variable_data&
-init_new_var( cstring var_name, Modifiers m = nfp::no_params )
-{
-    rt_env_detail::variable_data& new_vd = new_var_record( var_name );
-
-    cstring str_value = sys_read_var( new_vd.m_var_name );
-
-    if( !str_value.is_empty() ) {
-        try {
-            autoboost::optional<T> value;
-
-            if( m.has( interpreter ) )
-                m[interpreter]( str_value, value );
-            else
-                interpret_argument_value( str_value, value, 0 );
-
-            if( !!value ) {
-                new_vd.m_value.reset( new typed_argument<T>( new_vd ) );
-
-                arg_value<T>( *new_vd.m_value ) = *value;
-            }
-        }
-        catch( ... ) { // !! could we do that
-            // !! should we report an error?
-        }
-    }
-
-    if( !new_vd.m_value && m.has( default_value ) ) {
-        new_vd.m_value.reset( new typed_argument<T>( new_vd ) );
-
-        nfp::optionally_assign( arg_value<T>( *new_vd.m_value ), m[default_value] );
-    }
-
-    nfp::optionally_assign( new_vd.m_global_id, m, global_id );
-
-    return new_vd;
-}
-
-//____________________________________________________________________________//
-
-} // namespace rt_env_detail
-
-} // namespace environment
-
-// ************************************************************************** //
-// **************             runtime::environment             ************** //
-// ************************************************************************** //
-
-namespace environment {
-
-    // variable access
-    variable_base
-    var( cstring var_name );
-
-    //________________________________________________________________________//
-
-    template<typename T>
-    inline variable<T>
-    var( cstring var_name )
-    {
-        rt_env_detail::variable_data* vd = rt_env_detail::find_var_record( var_name );
-
-        return environment::variable<T>( !vd ? rt_env_detail::init_new_var<T>( var_name, nfp::no_params ) : *vd );
-    }
-
-    //________________________________________________________________________//
-
-    template<typename T, typename Modifiers>
-    inline variable<T>
-    var( cstring var_name, Modifiers const& m )
-    {
-        rt_env_detail::variable_data* vd = rt_env_detail::find_var_record( var_name );
-
-        return environment::variable<T>( !vd ? rt_env_detail::init_new_var<T>( var_name, m ) : *vd );
-    }
-
-    //________________________________________________________________________//
-
-    // direct variable value access
-    inline cstring
-    get( cstring var_name )
-    {
-        return environment::var<cstring>( var_name ).value();
-    }
-
-    //________________________________________________________________________//
-
-    template<typename T>
-    inline T const&
-    get( cstring var_name )
-    {
-        return environment::var<T>( var_name ).value();
-    }
-
-    //________________________________________________________________________//
-
-    template<typename T>
-    inline void
-    get( cstring var_name, autoboost::optional<T>& res )
-    {
-        variable<T> const& v = environment::var<T>( var_name );
-        v.value( res );
-    }
-
-    //________________________________________________________________________//
-
-} // namespace environment
-
-namespace env = environment;
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#ifndef BOOST_RT_PARAM_OFFLINE
-
-#define BOOST_RT_PARAM_INLINE inline
-#include <boost/test/utils/runtime/env/environment.ipp>
-
-#endif
-
-#endif // BOOST_RT_ENV_ENVIRONMENT_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/env/environment.ipp b/contrib/autoboost/boost/test/utils/runtime/env/environment.ipp
deleted file mode 100644
index 8e0b573d9..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/env/environment.ipp
+++ /dev/null
@@ -1,125 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : implements model of program environment 
-// ***************************************************************************
-
-#ifndef BOOST_RT_ENV_ENVIRONMENT_IPP_062904GER
-#define BOOST_RT_ENV_ENVIRONMENT_IPP_062904GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-#include <boost/test/utils/runtime/validation.hpp>
-
-#include <boost/test/utils/runtime/env/variable.hpp>
-
-// Boost.Test
-#include <boost/test/utils/basic_cstring/compare.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-
-// STL
-#include <map>
-#include <list>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace environment {
-
-// ************************************************************************** //
-// **************             runtime::environment             ************** //
-// ************************************************************************** //
-
-namespace rt_env_detail {
-
-typedef std::map<cstring,rt_env_detail::variable_data> registry;
-typedef std::list<dstring> keys;
-
-BOOST_RT_PARAM_INLINE registry& s_registry()    { static registry instance; return instance; }
-BOOST_RT_PARAM_INLINE keys&     s_keys()        { static keys instance; return instance; }
-
-BOOST_RT_PARAM_INLINE variable_data&
-new_var_record( cstring var_name )
-{
-    // save the name in list of keys
-    s_keys().push_back( dstring() );
-    dstring& key = s_keys().back();
-    assign_op( key, var_name, 0 );
-
-    // create and return new record
-    variable_data& new_var_data = s_registry()[key];
-    
-    new_var_data.m_var_name = key;
-    
-    return new_var_data;
-}
-
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE variable_data*
-find_var_record( cstring var_name )
-{
-    registry::iterator it = s_registry().find( var_name );
-
-    return it == s_registry().end() ? 0 : &(it->second);
-}
-
-//____________________________________________________________________________//
-
-#ifdef BOOST_MSVC 
-#pragma warning(push) 
-#pragma warning(disable:4996) // getenv
-#endif
-
-BOOST_RT_PARAM_INLINE cstring
-sys_read_var( cstring var_name )
-{
-    using namespace std;
-    return BOOST_RT_PARAM_GETENV( var_name.begin() );
-}
-
-#ifdef BOOST_MSVC 
-#pragma warning(pop) 
-#endif
-//____________________________________________________________________________//
-
-BOOST_RT_PARAM_INLINE void
-sys_write_var( cstring var_name, format_stream& var_value )
-{
-    BOOST_RT_PARAM_PUTENV( var_name, cstring( var_value.str() ) );
-}
-
-//____________________________________________________________________________//
-
-} // namespace rt_env_detail
-
-BOOST_RT_PARAM_INLINE variable_base
-var( cstring var_name )
-{
-    rt_env_detail::variable_data* vd = rt_env_detail::find_var_record( var_name );
-
-    BOOST_RT_PARAM_VALIDATE_LOGIC( !!vd,
-                                   BOOST_RT_PARAM_LITERAL( "First access to the environment variable " ) 
-                                        << var_name << BOOST_RT_PARAM_LITERAL( " should be typed" ) );
-
-    return variable_base( *vd );
-}
-
-//____________________________________________________________________________//
-
-} // namespace environment
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_ENV_ENVIRONMENT_IPP_062904GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/env/fwd.hpp b/contrib/autoboost/boost/test/utils/runtime/env/fwd.hpp
deleted file mode 100644
index f21b19dde..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/env/fwd.hpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : environment subsystem forward declarations
-// ***************************************************************************
-
-#ifndef BOOST_RT_ENV_FWD_HPP_062604GER
-#define BOOST_RT_ENV_FWD_HPP_062604GER
-
-#ifdef UNDER_CE
-#error Windows CE does not support environment variables.
-#endif
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace environment {
-
-class variable_base;
-variable_base var( cstring var_name );
-
-namespace rt_env_detail {
-
-struct variable_data;
-
-variable_data&  new_var_record( cstring var_name );
-variable_data*  find_var_record( cstring var_name );
-
-cstring         sys_read_var( cstring var_name );
-void            sys_write_var( cstring var_name, format_stream& var_value );
-
-}
-
-template <typename T> class variable;
-
-} // namespace environment
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_ENV_FWD_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/env/modifier.hpp b/contrib/autoboost/boost/test/utils/runtime/env/modifier.hpp
deleted file mode 100644
index a2c8dc73c..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/env/modifier.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  Use, modification, and distribution are subject to 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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines variable modifiers
-// ***************************************************************************
-
-#ifndef BOOST_RT_ENV_MODIFIER_HPP_062604GER
-#define BOOST_RT_ENV_MODIFIER_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-// Boost.Test
-#include <boost/test/utils/named_params.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace environment {
-
-// ************************************************************************** //
-// **************         environment variable modifiers       ************** //
-// ************************************************************************** //
-
-namespace {
-
-nfp::typed_keyword<cstring,struct global_id_t>   global_id;
-nfp::keyword<struct default_value_t>             default_value;
-nfp::keyword<struct interpreter_t>               interpreter;
-
-} // local namespace
-} // namespace environment
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_ENV_MODIFIER_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/env/variable.hpp b/contrib/autoboost/boost/test/utils/runtime/env/variable.hpp
deleted file mode 100644
index da19bb213..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/env/variable.hpp
+++ /dev/null
@@ -1,223 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines model of program environment variable
-// ***************************************************************************
-
-#ifndef BOOST_RT_ENV_VARIABLE_HPP_062604GER
-#define BOOST_RT_ENV_VARIABLE_HPP_062604GER
-
-#ifdef UNDER_CE
-#error Windows CE does not support environment variables.
-#endif
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-#include <boost/test/utils/runtime/fwd.hpp>
-#include <boost/test/utils/runtime/parameter.hpp>
-#include <boost/test/utils/runtime/argument.hpp>
-
-#include <boost/test/utils/runtime/env/fwd.hpp>
-
-// Boost
-#include <boost/optional.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace environment {
-
-// ************************************************************************** //
-// **************      runtime::environment::variable_data     ************** //
-// ************************************************************************** //
-
-namespace rt_env_detail {
-
-struct variable_data : public runtime::parameter {
-    cstring         m_var_name;
-    dstring         m_global_id;
-    argument_ptr    m_value;
-};
-
-} // namespace rt_env_detail
-
-// ************************************************************************** //
-// **************     runtime::environment::variable_base      ************** //
-// ************************************************************************** //
-
-class variable_base {
-public:
-    explicit    variable_base( rt_env_detail::variable_data& data ) : m_data( &data ) {}
-
-    // arguments access
-    template<typename T>
-    T const&    value() const
-    {
-        return arg_value<T>( *m_data->m_value );
-    }
-
-    template<typename T>
-    void        value( autoboost::optional<T>& res ) const
-    {
-        if( has_value() )
-            res = arg_value<T>( *m_data->m_value );
-        else
-            res.reset();
-    }
-
-    bool        has_value() const   { return m_data->m_value!=0; }
-    cstring     name() const        { return m_data->m_var_name; }
-
-protected:
-    // Data members
-    rt_env_detail::variable_data*  m_data;
-} ;
-
-// ************************************************************************** //
-// **************        runtime::environment::variable        ************** //
-// ************************************************************************** //
-
-template<typename T = cstring>
-class variable : public variable_base {
-public:
-    // Constructors
-    explicit    variable( cstring var_name );
-
-    template<typename Modifiers>
-    explicit    variable( cstring var_name, Modifiers const& m );
-
-    explicit    variable( rt_env_detail::variable_data& data ) 
-    : variable_base( data )                                 {}
-
-    // other variable assignment
-    void        operator=( variable const& v )              { m_data = v.m_data; }
-
-    // access methods
-    T const&    value() const                               { return variable_base::value<T>(); }
-
-#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206)) || \
-    BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0593))
-    template<typename T>
-    void        value( autoboost::optional<T>& res ) const      { variable_base::value( res ); }
-#else
-    using       variable_base::value;
-#endif
-
-    // Value assignment
-    template<typename V>
-    void        operator=( V const& v )
-    {
-        if( !has_value() )
-            m_data->m_value.reset( new typed_argument<T>( *m_data ) );
-
-        arg_value<T>( *m_data->m_value ) = v;
-
-        rt_env_detail::sys_write_var( m_data->m_var_name, format_stream().ref() << value() );
-    }
-}; // class variable
-
-//____________________________________________________________________________//
-
-template<typename CharT, typename Tr,typename T>
-inline std::basic_ostream<CharT,Tr>&
-operator<<( std::basic_ostream<CharT,Tr>& os, variable<T> const& v )
-{
-    os << v.name() << '=';
-
-    if( v.has_value() )
-        os << v.value();
-
-    return os;
-}
-
-//____________________________________________________________________________//
-
-template<typename T, typename V>
-inline bool
-operator==( variable<T> ev, V const& v )
-{
-    return ev.has_value() && ev.value() == v;
-}
-
-//____________________________________________________________________________//
-
-template<typename T, typename V>
-inline bool
-operator==( V const& v, variable<T> ev )
-{
-    return ev.has_value() && ev.value() == v;
-}
-
-//____________________________________________________________________________//
-
-template<typename T, typename V>
-inline bool
-operator!=( variable<T> ev, V const& v )
-{
-    return !ev.has_value() || ev.value() != v;
-}
-
-//____________________________________________________________________________//
-
-template<typename T, typename V>
-inline bool
-operator!=( V const& v, variable<T> ev )
-{
-    return !ev.has_value() || ev.value() != v;
-}
-
-//____________________________________________________________________________//
-
-} // namespace environment
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-// ************************************************************************** //
-// ************************************************************************** //
-// Implementation
-
-#include <boost/test/utils/runtime/env/environment.hpp>
-
-// ************************************************************************** //
-// **************        runtime::environment::variable        ************** //
-// ************************************************************************** //
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-namespace environment {
-
-template<typename T>
-variable<T>::variable( cstring var_name )
-: variable_base( environment::var<T>( var_name ) )
-{}
-
-//____________________________________________________________________________//
-
-template<typename T>
-template<typename Modifiers>
-variable<T>::variable( cstring var_name, Modifiers const& m )
-: variable_base( environment::var<T>( var_name, m ) )
-{}
-
-//____________________________________________________________________________//
-
-} // namespace environment
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_ENV_VARIABLE_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/fwd.hpp b/contrib/autoboost/boost/test/utils/runtime/fwd.hpp
deleted file mode 100644
index 490a16853..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/fwd.hpp
+++ /dev/null
@@ -1,41 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : global framework level forward declaration
-// ***************************************************************************
-
-#ifndef BOOST_RT_FWD_HPP_062604GER
-#define BOOST_RT_FWD_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-// Boost
-#include <boost/shared_ptr.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-class parameter;
-
-class argument;
-typedef shared_ptr<argument> argument_ptr;
-typedef shared_ptr<argument const> const_argument_ptr;
-
-template<typename T> class value_interpreter;
-template<typename T> class typed_argument;
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_FWD_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/interpret_argument_value.hpp b/contrib/autoboost/boost/test/utils/runtime/interpret_argument_value.hpp
deleted file mode 100644
index f352135bc..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/interpret_argument_value.hpp
+++ /dev/null
@@ -1,163 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : default algorithms for string to specific type convertions
-// ***************************************************************************
-
-#ifndef BOOST_RT_INTERPRET_ARGUMENT_VALUE_HPP_062604GER
-#define BOOST_RT_INTERPRET_ARGUMENT_VALUE_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-#include <boost/test/utils/runtime/trace.hpp>
-
-// Boost.Test
-#include <boost/test/utils/basic_cstring/io.hpp>
-#include <boost/test/utils/basic_cstring/compare.hpp>
-
-// Boost
-#include <boost/optional.hpp>
-#include <boost/lexical_cast.hpp>
-
-// STL
-// !! could we eliminate these includes?
-#include <list>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-// ************************************************************************** //
-// **************       runtime::interpret_argument_value      ************** //
-// ************************************************************************** //
-// returns true if source is used false otherwise
-
-// generic case
-template<typename T>
-struct interpret_argument_value_impl {
-    static bool _( cstring source, autoboost::optional<T>& res )
-    {
-        BOOST_RT_PARAM_TRACE( "In interpret_argument_value_impl<" << typeid(T).name() << ">" );
-
-        res = lexical_cast<T>( source );
-
-        BOOST_RT_PARAM_TRACE( "String " << source << " is interpreted as " << *res );
-        return true;
-    }
-};
-
-
-//____________________________________________________________________________//
-
-// dstring case
-template<>
-struct interpret_argument_value_impl<dstring> {
-    static bool _( cstring source, autoboost::optional<dstring>& res )
-    {
-        BOOST_RT_PARAM_TRACE( "In interpret_argument_value_impl<dstring>" );
-
-        res = dstring();
-        assign_op( *res, source, 0 );
-
-        return true;
-    }
-};
-
-//____________________________________________________________________________//
-
-// cstring case
-template<>
-struct interpret_argument_value_impl<cstring> {
-    static bool _( cstring source, autoboost::optional<cstring>& res )
-    {
-        BOOST_RT_PARAM_TRACE( "In interpret_argument_value_impl<cstring>" );
-
-        res = source;
-
-        return true;
-    }
-};
-
-//____________________________________________________________________________//
-
-// specialization for type bool
-template<>
-struct interpret_argument_value_impl<bool> {
-    static bool _( cstring source, autoboost::optional<bool>& res )
-    {
-        BOOST_RT_PARAM_TRACE( "In interpret_argument_value_impl<bool>" );
-
-        static literal_cstring YES( BOOST_RT_PARAM_CSTRING_LITERAL( "YES" ) );
-        static literal_cstring Y( BOOST_RT_PARAM_CSTRING_LITERAL( "Y" ) );
-        static literal_cstring NO( BOOST_RT_PARAM_CSTRING_LITERAL( "NO" ) );
-        static literal_cstring N( BOOST_RT_PARAM_CSTRING_LITERAL( "N" ) );
-        static literal_cstring one( BOOST_RT_PARAM_CSTRING_LITERAL( "1" ) );
-        static literal_cstring zero( BOOST_RT_PARAM_CSTRING_LITERAL( "0" ) );
-
-        source.trim();
-
-        if( case_ins_eq( source, YES ) || case_ins_eq( source, Y ) || case_ins_eq( source, one ) ) {
-            res = true;
-            return true;
-        }
-        else if( case_ins_eq( source, NO ) || case_ins_eq( source, N ) || case_ins_eq( source, zero ) ) {
-            res = false;
-            return true;
-        }
-        else {
-            res = true;
-            return false;
-        }
-    }
-};
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline bool
-interpret_argument_value( cstring source, autoboost::optional<T>& res, long )
-{
-    return interpret_argument_value_impl<T>::_( source, res );
-}
-
-//____________________________________________________________________________//
-
-// specialization for list of values
-template<typename T>
-inline bool
-interpret_argument_value( cstring source, autoboost::optional<std::list<T> >& res, int )
-{
-    BOOST_RT_PARAM_TRACE( "In interpret_argument_value<std::list<T>>" );
-
-    res = std::list<T>();
-
-    while( !source.is_empty() ) {
-        // !! should we use token_iterator
-        cstring::iterator single_value_end = std::find( source.begin(), source.end(), BOOST_RT_PARAM_LITERAL( ',' ) );
-
-        autoboost::optional<T> value;
-        interpret_argument_value( cstring( source.begin(), single_value_end ), value, 0 );
-
-        res->push_back( *value );
-
-        source.trim_left( single_value_end + 1 );
-    }
-
-    return true;
-}
-
-//____________________________________________________________________________//
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_INTERPRET_ARGUMENT_VALUE_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/parameter.hpp b/contrib/autoboost/boost/test/utils/runtime/parameter.hpp
deleted file mode 100644
index 6881b945f..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/parameter.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : abstract interface for the formal parameter
-// ***************************************************************************
-
-#ifndef BOOST_RT_PARAMETER_HPP_062604GER
-#define BOOST_RT_PARAMETER_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-// ************************************************************************** //
-// **************              runtime::parameter              ************** //
-// ************************************************************************** //
-
-class parameter {
-public:
-    virtual ~parameter() {}
-};
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_PARAMETER_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/trace.hpp b/contrib/autoboost/boost/test/utils/runtime/trace.hpp
deleted file mode 100644
index 5c4e2a7c0..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/trace.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : optional internal tracing
-// ***************************************************************************
-
-#ifndef BOOST_RT_TRACE_HPP_062604GER
-#define BOOST_RT_TRACE_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-#ifdef BOOST_RT_PARAM_DEBUG
-
-#include <iostream>
-
-#  define BOOST_RT_PARAM_TRACE( str ) std::cerr << str << std::endl
-#else
-#  define BOOST_RT_PARAM_TRACE( str )
-#endif
-
-#endif // BOOST_RT_TRACE_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/runtime/validation.hpp b/contrib/autoboost/boost/test/utils/runtime/validation.hpp
deleted file mode 100644
index 4b92ae278..000000000
--- a/contrib/autoboost/boost/test/utils/runtime/validation.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines exceptions and validation tools
-// ***************************************************************************
-
-#ifndef BOOST_RT_VALIDATION_HPP_062604GER
-#define BOOST_RT_VALIDATION_HPP_062604GER
-
-// Boost.Runtime.Parameter
-#include <boost/test/utils/runtime/config.hpp>
-
-// Boost.Test
-#include <boost/test/utils/class_properties.hpp>
-
-// Boost
-#include <boost/shared_ptr.hpp>
-
-// STL
-#ifdef BOOST_RT_PARAM_EXCEPTION_INHERIT_STD
-#include <stdexcept>
-#endif
-
-namespace autoboost {
-
-namespace BOOST_RT_PARAM_NAMESPACE {
-
-// ************************************************************************** //
-// **************             runtime::logic_error             ************** //
-// ************************************************************************** //
-
-class logic_error 
-#ifdef BOOST_RT_PARAM_EXCEPTION_INHERIT_STD
-: public std::exception
-#endif
-{
-    typedef shared_ptr<dstring> dstring_ptr;
-public:
-    // Constructor // !! could we eliminate shared_ptr
-    explicit    logic_error( cstring msg ) : m_msg( new dstring( msg.begin(), msg.size() ) ) {}
-    ~logic_error() throw()                          {}
-
-    dstring const&   msg() const                    { return *m_msg; }
-    virtual char_type const* what() const throw()   { return m_msg->c_str(); }
-
-private:
-    dstring_ptr m_msg;
-};
-
-// ************************************************************************** //
-// **************          runtime::report_logic_error         ************** //
-// ************************************************************************** //
-
-inline void
-report_logic_error( format_stream& msg )
-{
-    throw BOOST_RT_PARAM_NAMESPACE::logic_error( msg.str() );
-}
-
-//____________________________________________________________________________//
-
-#define BOOST_RT_PARAM_REPORT_LOGIC_ERROR( msg ) \
-    autoboost::BOOST_RT_PARAM_NAMESPACE::report_logic_error( format_stream().ref() << msg )
-
-#define BOOST_RT_PARAM_VALIDATE_LOGIC( b, msg ) \
-    if( b ) {} else BOOST_RT_PARAM_REPORT_LOGIC_ERROR( msg )
-
-//____________________________________________________________________________//
-
-} // namespace BOOST_RT_PARAM_NAMESPACE
-
-} // namespace autoboost
-
-#endif // BOOST_RT_VALIDATION_HPP_062604GER
diff --git a/contrib/autoboost/boost/test/utils/trivial_singleton.hpp b/contrib/autoboost/boost/test/utils/trivial_singleton.hpp
deleted file mode 100644
index 4bfc40c98..000000000
--- a/contrib/autoboost/boost/test/utils/trivial_singleton.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : simple helpers for creating cusom output manipulators
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TRIVIAL_SIGNLETON_HPP_020505GER
-#define BOOST_TEST_TRIVIAL_SIGNLETON_HPP_020505GER
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/noncopyable.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                   singleton                  ************** //
-// ************************************************************************** //
-
-template<typename Derived>
-class singleton : private autoboost::noncopyable {
-public:
-    static Derived& instance() { static Derived the_inst; return the_inst; }    
-protected:
-    singleton()  {}
-    ~singleton() {}
-};
-
-} // namespace unit_test
-
-#define BOOST_TEST_SINGLETON_CONS( type )       \
-friend class autoboost::unit_test::singleton<type>; \
-type() {}                                       \
-/**/
-
-#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
-
-#define BOOST_TEST_SINGLETON_INST( inst ) \
-template class unit_test::singleton< BOOST_JOIN( inst, _t ) > ; \
-namespace { BOOST_JOIN( inst, _t)& inst = BOOST_JOIN( inst, _t)::instance(); }
-
-#elif defined(__APPLE_CC__) && defined(__GNUC__) && __GNUC__ < 4
-#define BOOST_TEST_SINGLETON_INST( inst ) \
-static BOOST_JOIN( inst, _t)& inst = BOOST_JOIN (inst, _t)::instance();
-
-#else
-
-#define BOOST_TEST_SINGLETON_INST( inst ) \
-namespace { BOOST_JOIN( inst, _t)& inst = BOOST_JOIN( inst, _t)::instance(); }
-
-#endif
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TRIVIAL_SIGNLETON_HPP_020505GER
diff --git a/contrib/autoboost/boost/test/utils/wrap_stringstream.hpp b/contrib/autoboost/boost/test/utils/wrap_stringstream.hpp
deleted file mode 100644
index 53fd07574..000000000
--- a/contrib/autoboost/boost/test/utils/wrap_stringstream.hpp
+++ /dev/null
@@ -1,164 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2002-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : wraps strstream and stringstream (depends with one is present)
-//                to provide the unified interface
-// ***************************************************************************
-
-#ifndef BOOST_WRAP_STRINGSTREAM_HPP_071894GER
-#define BOOST_WRAP_STRINGSTREAM_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-
-// STL
-#ifdef BOOST_NO_STRINGSTREAM
-#include <strstream>        // for std::ostrstream
-#else
-#include <sstream>          // for std::ostringstream
-#endif // BOOST_NO_STRINGSTREAM
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-// ************************************************************************** //
-// **************            basic_wrap_stringstream           ************** //
-// ************************************************************************** //
-
-template<typename CharT>
-class basic_wrap_stringstream {
-public:
-#if defined(BOOST_CLASSIC_IOSTREAMS)
-    typedef std::ostringstream               wrapped_stream;
-#elif defined(BOOST_NO_STRINGSTREAM)
-    typedef std::basic_ostrstream<CharT>     wrapped_stream;
-#else
-    typedef std::basic_ostringstream<CharT>  wrapped_stream;
-#endif // BOOST_NO_STRINGSTREAM
-    // Access methods
-    basic_wrap_stringstream&        ref();
-    wrapped_stream&                 stream();
-    std::basic_string<CharT> const& str();
-
-private:
-    // Data members
-    wrapped_stream                  m_stream;
-    std::basic_string<CharT>        m_str;
-};
-
-//____________________________________________________________________________//
-
-template <typename CharT, typename T>
-inline basic_wrap_stringstream<CharT>&
-operator<<( basic_wrap_stringstream<CharT>& targ, T const& t )
-{
-    targ.stream() << t;
-    return targ;
-}
-
-//____________________________________________________________________________//
-
-template <typename CharT>
-inline typename basic_wrap_stringstream<CharT>::wrapped_stream&
-basic_wrap_stringstream<CharT>::stream()
-{
-    return m_stream;
-}
-
-//____________________________________________________________________________//
-
-template <typename CharT>
-inline basic_wrap_stringstream<CharT>&
-basic_wrap_stringstream<CharT>::ref()
-{ 
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-template <typename CharT>
-inline std::basic_string<CharT> const&
-basic_wrap_stringstream<CharT>::str()
-{
-
-#ifdef BOOST_NO_STRINGSTREAM
-    m_str.assign( m_stream.str(), m_stream.pcount() );
-    m_stream.freeze( false );
-#else
-    m_str = m_stream.str();
-#endif
-
-    return m_str;
-}
-
-//____________________________________________________________________________//
-
-template <typename CharT>
-inline basic_wrap_stringstream<CharT>&
-operator<<( basic_wrap_stringstream<CharT>& targ, basic_wrap_stringstream<CharT>& src )
-{
-    targ << src.str();
-    return targ;
-}
-
-//____________________________________________________________________________//
-
-#if BOOST_TEST_USE_STD_LOCALE 
-
-template <typename CharT>
-inline basic_wrap_stringstream<CharT>&
-operator<<( basic_wrap_stringstream<CharT>& targ, std::ios_base& (BOOST_TEST_CALL_DECL *man)(std::ios_base&) )
-{
-    targ.stream() << man;
-    return targ;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT,typename Elem,typename Tr>
-inline basic_wrap_stringstream<CharT>&
-operator<<( basic_wrap_stringstream<CharT>& targ, std::basic_ostream<Elem,Tr>& (BOOST_TEST_CALL_DECL *man)(std::basic_ostream<Elem, Tr>&) )
-{
-    targ.stream() << man;
-    return targ;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT,typename Elem,typename Tr>
-inline basic_wrap_stringstream<CharT>&
-operator<<( basic_wrap_stringstream<CharT>& targ, std::basic_ios<Elem, Tr>& (BOOST_TEST_CALL_DECL *man)(std::basic_ios<Elem, Tr>&) )
-{
-    targ.stream() << man;
-    return targ;
-}
-
-//____________________________________________________________________________//
-
-#endif
-
-// ************************************************************************** //
-// **************               wrap_stringstream              ************** //
-// ************************************************************************** //
-
-typedef basic_wrap_stringstream<char>       wrap_stringstream;
-typedef basic_wrap_stringstream<wchar_t>    wrap_wstringstream;
-
-}  // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif  // BOOST_WRAP_STRINGSTREAM_HPP_071894GER
diff --git a/contrib/autoboost/boost/test/utils/xml_printer.hpp b/contrib/autoboost/boost/test/utils/xml_printer.hpp
deleted file mode 100644
index 27344e125..000000000
--- a/contrib/autoboost/boost/test/utils/xml_printer.hpp
+++ /dev/null
@@ -1,118 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2004-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : common code used by any agent serving as XML printer
-// ***************************************************************************
-
-#ifndef BOOST_TEST_XML_PRINTER_HPP_071894GER
-#define BOOST_TEST_XML_PRINTER_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-#include <boost/test/utils/fixed_mapping.hpp>
-#include <boost/test/utils/custom_manip.hpp>
-#include <boost/test/utils/foreach.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-
-// Boost
-#include <boost/config.hpp>
-
-// STL
-#include <iostream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace autoboost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************               xml print helpers              ************** //
-// ************************************************************************** //
-
-inline void
-print_escaped( std::ostream& where_to, const_string value )
-{
-    static fixed_mapping<char,char const*> char_type(
-        '<' , "lt",
-        '>' , "gt",
-        '&' , "amp",
-        '\'', "apos" ,
-        '"' , "quot",
-
-        0
-    );
-
-    BOOST_TEST_FOREACH( char, c, value ) {
-        char const* ref = char_type[c];
-
-        if( ref )
-            where_to << '&' << ref << ';';
-        else
-            where_to << c;
-    }
-}
-
-//____________________________________________________________________________//
-
-inline void
-print_escaped( std::ostream& where_to, std::string const& value )
-{
-    print_escaped( where_to, const_string( value ) );
-}
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline void
-print_escaped( std::ostream& where_to, T const& value )
-{
-    where_to << value;
-}
-
-//____________________________________________________________________________//
-
-typedef custom_manip<struct attr_value_t> attr_value;
-
-template<typename T>
-inline std::ostream&
-operator<<( custom_printer<attr_value> const& p, T const& value )
-{
-    *p << "=\"";
-    print_escaped( *p, value );
-    *p << '"';
-
-    return *p;
-}
-
-//____________________________________________________________________________//
-
-typedef custom_manip<struct cdata_t> cdata;
-
-inline std::ostream&
-operator<<( custom_printer<cdata> const& p, const_string value )
-{
-    return *p << BOOST_TEST_L( "<![CDATA[" ) << value << BOOST_TEST_L( "]]>" );
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-
-} // namespace autoboost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_XML_PRINTER_HPP_071894GER
diff --git a/contrib/autoboost/boost/thread/detail/config.hpp b/contrib/autoboost/boost/thread/detail/config.hpp
index ebc7a0a76..993cbcec5 100644
--- a/contrib/autoboost/boost/thread/detail/config.hpp
+++ b/contrib/autoboost/boost/thread/detail/config.hpp
@@ -428,38 +428,10 @@
 #   define BOOST_THREAD_DECL
 #endif // BOOST_HAS_DECLSPEC
 
-//
-// Automatically link to the correct build variant where possible.
-//
-#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_THREAD_NO_LIB) && !defined(BOOST_THREAD_BUILD_DLL) && !defined(BOOST_THREAD_BUILD_LIB)
-//
-// Tell the autolink to link dynamically, this will get undef'ed by auto_link.hpp
-// once it's done with it:
-//
-#if defined(BOOST_THREAD_USE_DLL)
-#   define BOOST_DYN_LINK
-#endif
-//
-// Set the name of our library, this will get undef'ed by auto_link.hpp
-// once it's done with it:
-//
-#if defined(BOOST_THREAD_LIB_NAME)
-#    define BOOST_LIB_NAME BOOST_THREAD_LIB_NAME
-#else
-#    define BOOST_LIB_NAME autoboost_thread
-#endif
-//
-// If we're importing code from a dll, then tell auto_link.hpp about it:
-//
-// And include the header that does the work:
-//
-#include <boost/config/auto_link.hpp>
-#endif  // auto-linking disabled
-
-#endif // BOOST_THREAD_CONFIG_WEK1032003_HPP
-
 // Change Log:
 //   22 Jan 05 Roland Schwarz (speedsnail)
 //      Usage of BOOST_HAS_DECLSPEC macro.
 //      Default again is static lib usage.
 //      BOOST_DYN_LINK only defined when autolink included.
+
+#endif // BOOST_THREAD_CONFIG_WEK1032003_HPP
\ No newline at end of file
diff --git a/contrib/autoboost/boost/thread/future.hpp b/contrib/autoboost/boost/thread/future.hpp
index ab826cffd..f4e7512f0 100644
--- a/contrib/autoboost/boost/thread/future.hpp
+++ b/contrib/autoboost/boost/thread/future.hpp
@@ -5,8 +5,8 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 
-#ifndef BOOST_THREAD_FUTURE_HPP
-#define BOOST_THREAD_FUTURE_HPP
+#ifndef AUTOBOOST_BOOST_THREAD_FUTURE_HPP
+#define AUTOBOOST_BOOST_THREAD_FUTURE_HPP
 
 #include <boost/thread/detail/config.hpp>
 
diff --git a/contrib/autoboost/boost/version.hpp b/contrib/autoboost/boost/version.hpp
index c156fd791..c13720d48 100644
--- a/contrib/autoboost/boost/version.hpp
+++ b/contrib/autoboost/boost/version.hpp
@@ -25,7 +25,6 @@
 //  BOOST_LIB_VERSION must be defined to be the same as BOOST_VERSION
 //  but as a *string* in the form "x_y[_z]" where x is the major version
 //  number, y is the minor version number, and z is the patch level if not 0.
-//  This is used by <config/auto_link.hpp> to select which library version to link to.
 
 #define BOOST_LIB_VERSION "1_57"
 
diff --git a/contrib/autoboost/libs/serialization/src/basic_iarchive.cpp b/contrib/autoboost/libs/serialization/src/basic_iarchive.cpp
index 3d853bb06..79f98c962 100644
--- a/contrib/autoboost/libs/serialization/src/basic_iarchive.cpp
+++ b/contrib/autoboost/libs/serialization/src/basic_iarchive.cpp
@@ -41,8 +41,6 @@ namespace std{
 #include <boost/archive/detail/basic_pointer_iserializer.hpp>
 #include <boost/archive/detail/basic_iarchive.hpp>
 
-#include <boost/archive/detail/auto_link_archive.hpp>
-
 using namespace autoboost::serialization;
 
 namespace autoboost {
diff --git a/contrib/autoboost/libs/serialization/src/basic_text_iprimitive.cpp b/contrib/autoboost/libs/serialization/src/basic_text_iprimitive.cpp
index 43dd66978..31ee4e92c 100644
--- a/contrib/autoboost/libs/serialization/src/basic_text_iprimitive.cpp
+++ b/contrib/autoboost/libs/serialization/src/basic_text_iprimitive.cpp
@@ -15,7 +15,6 @@
 #include <istream>
 
 #define BOOST_ARCHIVE_SOURCE
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/impl/basic_text_iprimitive.ipp>
 
 namespace autoboost {
diff --git a/contrib/autoboost/libs/serialization/src/basic_text_oprimitive.cpp b/contrib/autoboost/libs/serialization/src/basic_text_oprimitive.cpp
index 51fbb0177..6ea4ad03b 100644
--- a/contrib/autoboost/libs/serialization/src/basic_text_oprimitive.cpp
+++ b/contrib/autoboost/libs/serialization/src/basic_text_oprimitive.cpp
@@ -15,7 +15,6 @@
 #include <ostream>
 
 #define BOOST_ARCHIVE_SOURCE
-#include <boost/archive/detail/auto_link_archive.hpp>
 #include <boost/archive/impl/basic_text_oprimitive.ipp>
 
 namespace autoboost {
diff --git a/contrib/autoboost/libs/serialization/src/basic_text_wiprimitive.cpp b/contrib/autoboost/libs/serialization/src/basic_text_wiprimitive.cpp
index 15ccd13e0..d41c4ba53 100644
--- a/contrib/autoboost/libs/serialization/src/basic_text_wiprimitive.cpp
+++ b/contrib/autoboost/libs/serialization/src/basic_text_wiprimitive.cpp
@@ -21,7 +21,6 @@
 #include <istream>
 
 #define BOOST_WARCHIVE_SOURCE
-#include <boost/archive/detail/auto_link_warchive.hpp>
 #include <boost/archive/impl/basic_text_iprimitive.ipp>
 
 namespace autoboost {
diff --git a/contrib/autoboost/libs/serialization/src/basic_text_woprimitive.cpp b/contrib/autoboost/libs/serialization/src/basic_text_woprimitive.cpp
index cc04b6110..306376f68 100644
--- a/contrib/autoboost/libs/serialization/src/basic_text_woprimitive.cpp
+++ b/contrib/autoboost/libs/serialization/src/basic_text_woprimitive.cpp
@@ -21,7 +21,6 @@
 #include <ostream>
 
 #define BOOST_WARCHIVE_SOURCE
-#include <boost/archive/detail/auto_link_warchive.hpp>
 #include <boost/archive/impl/basic_text_oprimitive.ipp>
 
 namespace autoboost {
diff --git a/contrib/autoboost/libs/test/src/compiler_log_formatter.cpp b/contrib/autoboost/libs/test/src/compiler_log_formatter.cpp
deleted file mode 100644
index fa174fb2b..000000000
--- a/contrib/autoboost/libs/test/src/compiler_log_formatter.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/compiler_log_formatter.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/cpp_main.cpp b/contrib/autoboost/libs/test/src/cpp_main.cpp
deleted file mode 100644
index 805a27fd3..000000000
--- a/contrib/autoboost/libs/test/src/cpp_main.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/cpp_main.ipp>
-
-// EOF
-
diff --git a/contrib/autoboost/libs/test/src/debug.cpp b/contrib/autoboost/libs/test/src/debug.cpp
deleted file mode 100644
index 864d6f218..000000000
--- a/contrib/autoboost/libs/test/src/debug.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2006-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/debug.ipp>
-
-// ***************************************************************************
-//  Revision History :
-//  
-//  $Log$
-// ***************************************************************************
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/exception_safety.cpp b/contrib/autoboost/libs/test/src/exception_safety.cpp
deleted file mode 100644
index 6f0219636..000000000
--- a/contrib/autoboost/libs/test/src/exception_safety.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/exception_safety.ipp>
-
-// EOF
-
diff --git a/contrib/autoboost/libs/test/src/execution_monitor.cpp b/contrib/autoboost/libs/test/src/execution_monitor.cpp
deleted file mode 100644
index 9702ed976..000000000
--- a/contrib/autoboost/libs/test/src/execution_monitor.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/execution_monitor.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/framework.cpp b/contrib/autoboost/libs/test/src/framework.cpp
deleted file mode 100644
index 986f20b99..000000000
--- a/contrib/autoboost/libs/test/src/framework.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/framework.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/interaction_based.cpp b/contrib/autoboost/libs/test/src/interaction_based.cpp
deleted file mode 100644
index f3dc76ff3..000000000
--- a/contrib/autoboost/libs/test/src/interaction_based.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/interaction_based.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/logged_expectations.cpp b/contrib/autoboost/libs/test/src/logged_expectations.cpp
deleted file mode 100644
index c8f690f9c..000000000
--- a/contrib/autoboost/libs/test/src/logged_expectations.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/logged_expectations.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/plain_report_formatter.cpp b/contrib/autoboost/libs/test/src/plain_report_formatter.cpp
deleted file mode 100644
index 8ef03c361..000000000
--- a/contrib/autoboost/libs/test/src/plain_report_formatter.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/plain_report_formatter.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/progress_monitor.cpp b/contrib/autoboost/libs/test/src/progress_monitor.cpp
deleted file mode 100644
index 5ee24d5d3..000000000
--- a/contrib/autoboost/libs/test/src/progress_monitor.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/progress_monitor.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/results_collector.cpp b/contrib/autoboost/libs/test/src/results_collector.cpp
deleted file mode 100644
index e6be408e2..000000000
--- a/contrib/autoboost/libs/test/src/results_collector.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/results_collector.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/results_reporter.cpp b/contrib/autoboost/libs/test/src/results_reporter.cpp
deleted file mode 100644
index a1790923f..000000000
--- a/contrib/autoboost/libs/test/src/results_reporter.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/results_reporter.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/test_main.cpp b/contrib/autoboost/libs/test/src/test_main.cpp
deleted file mode 100644
index d12dee5db..000000000
--- a/contrib/autoboost/libs/test/src/test_main.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/test_main.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/test_tools.cpp b/contrib/autoboost/libs/test/src/test_tools.cpp
deleted file mode 100644
index 905e3514b..000000000
--- a/contrib/autoboost/libs/test/src/test_tools.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/test_tools.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/unit_test_log.cpp b/contrib/autoboost/libs/test/src/unit_test_log.cpp
deleted file mode 100644
index e1da09763..000000000
--- a/contrib/autoboost/libs/test/src/unit_test_log.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/unit_test_log.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/unit_test_main.cpp b/contrib/autoboost/libs/test/src/unit_test_main.cpp
deleted file mode 100644
index c031c584a..000000000
--- a/contrib/autoboost/libs/test/src/unit_test_main.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/unit_test_main.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/unit_test_monitor.cpp b/contrib/autoboost/libs/test/src/unit_test_monitor.cpp
deleted file mode 100644
index 6a94a4650..000000000
--- a/contrib/autoboost/libs/test/src/unit_test_monitor.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/unit_test_monitor.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/unit_test_parameters.cpp b/contrib/autoboost/libs/test/src/unit_test_parameters.cpp
deleted file mode 100644
index 419527b84..000000000
--- a/contrib/autoboost/libs/test/src/unit_test_parameters.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/unit_test_parameters.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/unit_test_suite.cpp b/contrib/autoboost/libs/test/src/unit_test_suite.cpp
deleted file mode 100644
index 6fe2f318b..000000000
--- a/contrib/autoboost/libs/test/src/unit_test_suite.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/unit_test_suite.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/xml_log_formatter.cpp b/contrib/autoboost/libs/test/src/xml_log_formatter.cpp
deleted file mode 100644
index e44f45888..000000000
--- a/contrib/autoboost/libs/test/src/xml_log_formatter.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/xml_log_formatter.ipp>
-
-// EOF
diff --git a/contrib/autoboost/libs/test/src/xml_report_formatter.cpp b/contrib/autoboost/libs/test/src/xml_report_formatter.cpp
deleted file mode 100644
index 4f0f59bfb..000000000
--- a/contrib/autoboost/libs/test/src/xml_report_formatter.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2008.
-//  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)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/xml_report_formatter.ipp>
-
-// EOF
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index c6b6d477f..718158e75 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -22,13 +22,6 @@ if(NOT autowiring_USE_LIBCXX)
   endif()
 endif()
 
-# Android also requires boost, but a more limited subset:
-if(BUILD_ANDROID)
-  find_package(Boost COMPONENTS thread REQUIRED)
-  include_directories(${Boost_INCLUDE_DIR})
-  message("Include dirs are ${Boost_INCLUDE_DIR}")
-endif()
-
 add_subdirectory(autonet)
 add_subdirectory(autowiring)
 add_subdirectory(autotesting)
diff --git a/src/autonet/CMakeLists.txt b/src/autonet/CMakeLists.txt
index 7f60eda8a..8c885d3dd 100644
--- a/src/autonet/CMakeLists.txt
+++ b/src/autonet/CMakeLists.txt
@@ -1,16 +1,7 @@
-option(AUTOWIRING_BUILD_AUTONET "Build Autonet debugging server" ${AUTOWIRING_BUILD_AUTONET_DEFAULT})
-if(NOT AUTOWIRING_BUILD_AUTONET)
-  return()
-endif()
-
 if(NOT WIN32 AND NOT autowiring_USE_LIBCXX)
   message("Cannot build Autonet, requires proper C++11 supprt")
 endif()
 
-if(autowiring_BUILD_ARM)
-  message(FATAL_ERROR "Cannot currently build Autonet for ARM processors")
-endif()
-
 add_googletest(test)
 include_directories(
   ${PROJECT_SOURCE_DIR}/contrib/autoboost
@@ -23,9 +14,26 @@ set(AutoNet_SRCS
   AutoNetServerImpl.hpp
   ${PROJECT_SOURCE_DIR}/contrib/json11/json11.cpp
   ${PROJECT_SOURCE_DIR}/contrib/json11/json11.hpp
+)
+
+add_conditional_sources(
+  AutoNet_SRCS
+  "ON"
+  GROUP_NAME "Autoboost"
+  FILES
   ${PROJECT_SOURCE_DIR}/contrib/autoboost/libs/system/src/error_code.cpp
 )
 
+add_conditional_sources(
+  AutoNet_SRCS
+  "NOT MSVC"
+  GROUP_NAME "Autoboost"
+  FILES
+  ${PROJECT_SOURCE_DIR}/contrib/autoboost/libs/thread/src/pthread/once_atomic.cpp
+  ${PROJECT_SOURCE_DIR}/contrib/autoboost/libs/thread/src/pthread/thread.cpp
+  ${PROJECT_SOURCE_DIR}/contrib/autoboost/libs/thread/src/future.cpp
+)
+
 # All include files are located in /autowiring from here, so prepend that to all sources
 rewrite_header_paths(AutoNet_SRCS)
 add_pch(AutoNet_SRCS "stdafx.h" "stdafx.cpp")
diff --git a/src/autonet/stdafx.h b/src/autonet/stdafx.h
index 87876241d..d84c2c638 100644
--- a/src/autonet/stdafx.h
+++ b/src/autonet/stdafx.h
@@ -7,8 +7,8 @@
   #define NOMINMAX
 #endif
 
-// Defined when we are exporting symbols
-#define AUTOWIRING_EXPORT_AUTONET
+// Defined when Autowiring is being built, as opposed to when it is being linked
+#define AUTOWIRING_IS_BEING_BUILT
 
 #ifndef _MSC_VER
   #include <stdlib.h>
diff --git a/src/autowiring/AutoPacket.cpp b/src/autowiring/AutoPacket.cpp
index 4b8d3e5eb..343b5befd 100644
--- a/src/autowiring/AutoPacket.cpp
+++ b/src/autowiring/AutoPacket.cpp
@@ -3,6 +3,7 @@
 #include "AutoPacket.h"
 #include "Autowired.h"
 #include "AutoPacketFactory.h"
+#include "AutoPacketInternal.hpp"
 #include "AutoPacketProfiler.h"
 #include "AutoFilterDescriptor.h"
 #include "ContextEnumerator.h"
@@ -13,33 +14,8 @@ using namespace autowiring;
 
 AutoPacket::AutoPacket(AutoPacketFactory& factory, std::shared_ptr<void>&& outstanding):
   m_parentFactory(std::static_pointer_cast<AutoPacketFactory>(factory.shared_from_this())),
-  m_initTime(std::chrono::high_resolution_clock::now()),
   m_outstanding(std::move(outstanding))
-{
-  // Traverse all contexts, adding their packet subscriber vectors one at a time:
-  for(const auto& curContext : ContextEnumerator(factory.GetContext())) {
-    AutowiredFast<AutoPacketFactory> curFactory(curContext);
-    if(curFactory)
-      // Only insert if this context actually has a packet factory
-      curFactory->AppendAutoFiltersTo(m_satCounters);
-  }
-
-  // Sort, eliminate duplicates
-  m_satCounters.sort();
-  m_satCounters.erase(std::unique(m_satCounters.begin(), m_satCounters.end()), m_satCounters.end());
-
-  // Prime the satisfaction graph for each element:
-  for(auto& satCounter : m_satCounters)
-    AddSatCounter(satCounter);
-
-  // Initialize all counters:
-  for (auto& satCounter : m_satCounters)
-    satCounter.Reset();
-
-  // Clear all references:
-  for (auto& decoration : m_decorations)
-    decoration.second.Reset();
-}
+{}
 
 AutoPacket::~AutoPacket(void) {
   m_parentFactory->RecordPacketDuration(
@@ -47,6 +23,23 @@ AutoPacket::~AutoPacket(void) {
       std::chrono::high_resolution_clock::now() - m_initTime
     )
   );
+  
+  // Create vector of all successor packets that will be destroyed
+  // This prevents recursive AutoPacket destructor calls
+  std::vector<std::shared_ptr<AutoPacket>> packets;  
+  
+  // Recurse through unique successors, storing them in our vector
+  for (AutoPacket* current = this; current->m_successor.unique();) {
+    packets.push_back(current->m_successor);
+    
+    // Reset and continue to next successor
+    AutoPacket* prev_current = current;
+    current = current->m_successor.get();
+    prev_current->m_successor.reset();
+  }
+  
+  // Needed for the AutoPacketGraph
+  NotifyTeardownListeners();
 }
 
 DecorationDisposition& AutoPacket::CheckoutImmediateUnsafe(const std::type_info& ti, const void* pvImmed)
@@ -379,3 +372,26 @@ void AutoPacket::RemoveRecipient(Recipient&& recipient) {
   RemoveSatCounter(*q);
   m_satCounters.erase(q);
 }
+
+std::list<DecorationDisposition> AutoPacket::GetDispositions() const {
+  std::lock_guard<std::mutex> lk(m_lock);
+  std::list<DecorationDisposition> dispositions;
+  for (auto& disposition : m_decorations)
+    dispositions.push_back(disposition.second);
+  return dispositions;
+}
+
+std::shared_ptr<AutoPacketInternal> AutoPacket::SuccessorInternal(void) {
+  std::lock_guard<std::mutex> lk(m_lock);
+  
+  // If successor doesn't already exists, create it
+  if (!m_successor){
+    m_successor = m_parentFactory->ConstructPacket();
+  }
+  
+  return m_successor;
+}
+
+std::shared_ptr<AutoPacket> AutoPacket::Successor(void) {
+  return SuccessorInternal();
+}
diff --git a/src/autowiring/AutoPacketFactory.cpp b/src/autowiring/AutoPacketFactory.cpp
index 1cc56337d..89feb3d1d 100644
--- a/src/autowiring/AutoPacketFactory.cpp
+++ b/src/autowiring/AutoPacketFactory.cpp
@@ -1,18 +1,14 @@
 // Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
 #include "stdafx.h"
 #include "AutoPacketFactory.h"
-#include "AutoPacketInternal.h"
+#include "AutoPacketInternal.hpp"
 #include "fast_pointer_cast.h"
 #include "thread_specific_ptr.h"
 #include <cmath>
 
-template class ObjectPool<AutoPacket>;
-
 AutoPacketFactory::AutoPacketFactory(void):
   ContextMember("AutoPacketFactory"),
   m_parent(GetContext()->GetParentContext()),
-  m_wasStopped(false),
-  m_outstanding(0),
   m_packetCount(0),
   m_packetDurationSum(0),
   m_packetDurationSqSum(0)
@@ -29,15 +25,26 @@ std::shared_ptr<AutoPacket> AutoPacketFactory::NewPacket(void) {
   if(!IsRunning())
     throw autowiring_error("Cannot create a packet until the AutoPacketFactory is started");
   
-  // Obtain a packet, initialize it, return it
-  auto retVal = std::make_shared<AutoPacketInternal>(
-    *this,
-    GetInternalOutstanding()
-  );
+  std::shared_ptr<AutoPacketInternal> retVal;
+  {
+    std::lock_guard<std::mutex> lk(m_lock);
+    
+    // New packet issued
+    ++m_packetCount;
+  
+    // Create a new next packet
+    retVal = m_nextPacket;
+    m_nextPacket = retVal->SuccessorInternal();
+  }
+  
   retVal->Initialize();
   return retVal;
 }
 
+std::shared_ptr<AutoPacketInternal> AutoPacketFactory::ConstructPacket(void) {
+  return std::make_shared<AutoPacketInternal>(*this, GetInternalOutstanding());
+}
+
 bool AutoPacketFactory::IsAutoPacketType(const std::type_info& dataType) {
   return
     dataType == typeid(AutoPacket) ||
@@ -45,23 +52,12 @@ bool AutoPacketFactory::IsAutoPacketType(const std::type_info& dataType) {
     dataType == typeid(auto_arg<const AutoPacket&>::id_type);
 }
 
-bool AutoPacketFactory::Start(std::shared_ptr<Object> outstanding) {
-  std::lock_guard<std::mutex> lk(m_lock);
-  if(m_wasStopped)
-    // Cannot start if already stopped
-    return false;
-    
-  m_outstanding = outstanding;
-  m_stateCondition.notify_all();
-  return true;
-}
-
 std::shared_ptr<void> AutoPacketFactory::GetInternalOutstanding(void) {
   auto retVal = m_outstandingInternal.lock();
   if (retVal)
     return retVal;
 
-  auto outstanding = m_outstanding;
+  std::shared_ptr<Object> outstanding = GetOutstanding();
   retVal = std::shared_ptr<void>(
     (void*)1,
     [this, outstanding] (void*) mutable {
@@ -77,38 +73,36 @@ std::shared_ptr<void> AutoPacketFactory::GetInternalOutstanding(void) {
   return retVal;
 }
 
-void AutoPacketFactory::Stop(bool graceful) {
-  // Return optimization
-  if(m_wasStopped)
-    return;
+bool AutoPacketFactory::OnStart(void) {
+  // Initialize first packet
+  m_nextPacket = ConstructPacket();
+  
+  // Wake us up. We're starting now
+  m_stateCondition.notify_all();
+  return true;
+}
 
+void AutoPacketFactory::OnStop(bool graceful) {
   // Kill the object pool
   Invalidate();
 
   // Queue of local variables to be destroyed when leaving scope
-  std::shared_ptr<Object> outstanding;
   t_autoFilterSet autoFilters;
+  
+  // Reset next packet, it will never be issued
+  m_nextPacket.reset();
 
   // Lock destruction precedes local variables
   std::lock_guard<std::mutex> lk(m_lock);
 
-  // Swap outstanding count into a local var, so we can reset outside of a lock
-  outstanding.swap(m_outstanding);
-
   // Same story with the AutoFilters
   autoFilters.swap(m_autoFilters);
 
   // Now we can lock, update state, and notify any listeners
-  m_wasStopped = true;
   m_stateCondition.notify_all();
 }
 
-void AutoPacketFactory::Clear(void) {
-  // Simple handoff to Stop is sufficient
-  Stop(false);
-}
-
-void AutoPacketFactory::Wait(void) {
+void AutoPacketFactory::DoAdditionalWait(void) {
   std::unique_lock<std::mutex> lk(m_lock);
   m_stateCondition.wait(
     lk,
@@ -118,6 +112,11 @@ void AutoPacketFactory::Wait(void) {
   );
 }
 
+void AutoPacketFactory::Clear(void) {
+  // Simple handoff to Stop is sufficient
+  Stop(false);
+}
+
 void AutoPacketFactory::Invalidate(void) {
   if(m_parent)
     m_parent->Invalidate();
@@ -154,13 +153,13 @@ AutoFilterDescriptor AutoPacketFactory::GetTypeDescriptorUnsafe(const std::type_
   return AutoFilterDescriptor();
 }
 
-size_t AutoPacketFactory::GetOutstanding(void) const {
-  return m_outstandingInternal.use_count();
+size_t AutoPacketFactory::GetOutstandingPacketCount(void) const {
+  // Next packet is stored internally, don't count that packet
+  return m_outstandingInternal.use_count() - 1;
 }
 
 void AutoPacketFactory::RecordPacketDuration(std::chrono::nanoseconds duration) {
   std::unique_lock<std::mutex> lk(m_lock);
-  ++m_packetCount;
   m_packetDurationSum += duration.count();
   m_packetDurationSqSum += duration.count() * duration.count();
 }
diff --git a/src/autowiring/AutoPacketGraph.cpp b/src/autowiring/AutoPacketGraph.cpp
new file mode 100644
index 000000000..e92ed348e
--- /dev/null
+++ b/src/autowiring/AutoPacketGraph.cpp
@@ -0,0 +1,172 @@
+// Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
+#include "stdafx.h"
+#include "AutoPacketGraph.h"
+#include "CoreContext.h"
+#include "DecorationDisposition.h"
+#include "demangle.h"
+#include "SatCounter.h"
+#include <algorithm>
+#include <fstream>
+#include <string>
+#include FUNCTIONAL_HEADER
+
+AutoPacketGraph::AutoPacketGraph() {
+}
+
+std::string AutoPacketGraph::DemangleTypeName(const std::type_info* type_info) const {
+  std::string demangled = autowiring::demangle(type_info);
+  
+  size_t demangledLength = demangled.length();
+  size_t newLength =
+    demangled[demangledLength - 2] == ' ' ?
+    demangledLength - 10 :
+    demangledLength - 9;
+  
+  return demangled.substr(demangled.find("<") + 1, newLength);
+}
+
+void AutoPacketGraph::LoadEdges() {
+  std::lock_guard<std::mutex> lk(m_lock);
+  
+  std::list<AutoFilterDescriptor> descriptors;
+  m_factory->AppendAutoFiltersTo(descriptors);
+  
+  // Sort, eliminate duplicates
+  descriptors.sort();
+  descriptors.erase(std::unique(descriptors.begin(), descriptors.end()), descriptors.end());
+  
+  for (auto& descriptor : descriptors) {
+    for(auto pCur = descriptor.GetAutoFilterInput(); *pCur; pCur++) {
+      const std::type_info& type_info = *pCur->ti;
+      
+      // Skip the AutoPacketGraph
+      const std::type_info& descType = m_factory->GetContext()->GetAutoTypeId(descriptor.GetAutoFilter());
+      if (descType == typeid(AutoPacketGraph)) {
+        continue;
+      }
+      
+      if (pCur->is_input) {
+        DeliveryEdge edge { &type_info, descriptor, true };
+        if (m_deliveryGraph.find(edge) == m_deliveryGraph.end()) {
+          m_deliveryGraph[edge] = 0;
+        }
+      }
+      
+      if (pCur->is_output) {
+        DeliveryEdge edge { &type_info, descriptor, false };
+        if (m_deliveryGraph.find(edge) == m_deliveryGraph.end()) {
+          m_deliveryGraph[edge] = 0;
+        }
+      }
+    }
+  }
+}
+
+void AutoPacketGraph::RecordDelivery(const std::type_info* ti, const AutoFilterDescriptor& descriptor, bool input) {
+  DeliveryEdge edge { ti, descriptor, input };
+  
+  auto itr = m_deliveryGraph.find(edge);
+  assert(itr != m_deliveryGraph.end());
+  itr->second++;
+}
+
+void AutoPacketGraph::NewObject(CoreContext&, const ObjectTraits&) {
+  LoadEdges();
+}
+
+bool AutoPacketGraph::OnStart(void) {
+  LoadEdges();
+  
+  return false;
+}
+
+void AutoPacketGraph::AutoFilter(AutoPacket& packet) {
+  packet.AddTeardownListener([this, &packet] () {
+    for (auto& decoration : packet.GetDispositions()) {
+      auto publisher = decoration.m_publisher;
+      auto type = decoration.m_type;
+      
+      if (publisher && publisher->called) {
+        RecordDelivery(type, *publisher, false);
+      }
+      
+      for (auto& subscriber : decoration.m_subscribers) {
+        // Skip the AutoPacketGraph
+        const std::type_info& descType = m_factory->GetContext()->GetAutoTypeId(subscriber->GetAutoFilter());
+        if (descType == typeid(AutoPacketGraph)) {
+          continue;
+        }
+        
+        if (subscriber->called) {
+          RecordDelivery(type, *subscriber, true);
+        }
+      }
+    }
+  });
+}
+
+bool AutoPacketGraph::WriteGV(const std::string& filename, bool numPackets) const {
+  std::ofstream file(filename);
+  if (!file && !file.good()) {
+    return false;
+  }
+  
+  file << "digraph \"" << autowiring::demangle(CoreContext::CurrentContext()->GetSigilType()) << " context\" {" << std::endl;
+  
+  std::lock_guard<std::mutex> lk(m_lock);
+  
+  // Containers for the unique types and descriptors
+  std::unordered_set<std::string> typeNames;
+  std::unordered_set<std::string> descriptorNames;
+  
+  for (auto& itr : m_deliveryGraph) {
+    auto& edge = itr.first;
+    auto type = edge.type_info;
+    auto& descriptor = edge.descriptor;
+    auto count = itr.second;
+    
+    // Skip the AutoPacketGraph
+    const std::type_info& descType = m_factory->GetContext()->GetAutoTypeId(descriptor.GetAutoFilter());
+    if (descType == typeid(AutoPacketGraph)) {
+      continue;
+    }
+    
+    std::string typeName = DemangleTypeName(type);
+    std::string descriptorName = autowiring::demangle(descType);
+    
+    // Get a unique set of types/descriptors
+    if (typeNames.find(typeName) == typeNames.end())
+      typeNames.insert(typeName);
+    
+    if (descriptorNames.find(descriptorName) == descriptorNames.end())
+      descriptorNames.insert(descriptorName);
+    
+    // string format: "type" -> "AutoFilter" (or vice versa)
+    std::stringstream ss;
+    ss << "  \"";
+    if (edge.input) {
+      ss << typeName << "\" -> \"" << descriptorName << "\"";
+    } else {
+      ss << descriptorName << "\" -> \"" << typeName << "\"";
+    }
+    
+    if (numPackets)
+      ss << "[label=\"" << count << "\"];";
+    
+    ss << std::endl;
+    
+    file << ss.str();
+  }
+  file << std::endl;
+  
+  // Setup the shapes for the types and descriptors
+  for (auto& typeName : typeNames)
+    file << "  \"" << typeName << "\" [shape=box];" << std::endl;
+  
+  for (auto& descriptorName : descriptorNames)
+    file << "  \"" << descriptorName << "\" [shape=ellipse];" << std::endl;
+  
+  file << "}\n";
+  
+  return true;
+}
diff --git a/src/autowiring/AutoPacketInternal.cpp b/src/autowiring/AutoPacketInternal.cpp
index e0c1be75f..28aa7cc03 100644
--- a/src/autowiring/AutoPacketInternal.cpp
+++ b/src/autowiring/AutoPacketInternal.cpp
@@ -1,19 +1,44 @@
 // Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
 #include "stdafx.h"
-#include "AutoPacketInternal.h"
+#include "AutoPacketInternal.hpp"
 #include "AutoPacketFactory.h"
 #include "SatCounter.h"
+#include <algorithm>
 
 AutoPacketInternal::AutoPacketInternal(AutoPacketFactory& factory, std::shared_ptr<void>&& outstanding) :
   AutoPacket(factory, std::move(outstanding))
-{
-}
+{}
 
-AutoPacketInternal::~AutoPacketInternal(void)
-{
-}
+AutoPacketInternal::~AutoPacketInternal(void) {}
 
 void AutoPacketInternal::Initialize(void) {
+  // Mark init time of packet
+  this->m_initTime = std::chrono::high_resolution_clock::now();
+
+  // Traverse all descendant contexts, adding their packet subscriber vectors one at a time:
+  for(const auto& curContext : ContextEnumerator(m_parentFactory->GetContext())) {
+    AutowiredFast<AutoPacketFactory> curFactory(curContext);
+    if(curFactory)
+      // Only insert if this context actually has a packet factory
+      curFactory->AppendAutoFiltersTo(m_satCounters);
+  }
+  
+  // Sort, eliminate duplicates
+  m_satCounters.sort();
+  m_satCounters.erase(std::unique(m_satCounters.begin(), m_satCounters.end()), m_satCounters.end());
+  
+  // Prime the satisfaction graph for each element:
+  for(auto& satCounter : m_satCounters)
+    AddSatCounter(satCounter);
+  
+  // Initialize all counters:
+  for (auto& satCounter : m_satCounters)
+    satCounter.Reset();
+  
+  // Clear all references:
+  for (auto& decoration : m_decorations)
+    decoration.second.Reset();
+  
   // Find all subscribers with no required or optional arguments:
   std::list<SatCounter*> callCounters;
   for (auto& satCounter : m_satCounters)
diff --git a/autowiring/AutoPacketInternal.h b/src/autowiring/AutoPacketInternal.hpp
similarity index 92%
rename from autowiring/AutoPacketInternal.h
rename to src/autowiring/AutoPacketInternal.hpp
index dd3807e1d..d9302b1e4 100644
--- a/autowiring/AutoPacketInternal.h
+++ b/src/autowiring/AutoPacketInternal.hpp
@@ -9,6 +9,7 @@ class AutoPacketInternal:
   public AutoPacket
 {
 public:
+  // Must hold the lock to 'factory' when calling this constructor
   AutoPacketInternal(AutoPacketFactory& factory, std::shared_ptr<void>&& outstanding);
   ~AutoPacketInternal(void);
 
diff --git a/src/autowiring/BasicThread.cpp b/src/autowiring/BasicThread.cpp
index 13b79caee..95ee85699 100644
--- a/src/autowiring/BasicThread.cpp
+++ b/src/autowiring/BasicThread.cpp
@@ -6,10 +6,6 @@
 #include "ContextEnumerator.h"
 #include "fast_pointer_cast.h"
 
-// Explicit instantiation of supported time point types:
-template<> bool BasicThread::WaitUntil(std::chrono::steady_clock::time_point);
-template<> bool BasicThread::WaitUntil(std::chrono::system_clock::time_point);
-
 BasicThread::BasicThread(const char* pName):
   ContextMember(pName),
   m_state(std::make_shared<BasicThreadStateBlock>()),
@@ -75,10 +71,12 @@ void BasicThread::DoRunLoopCleanup(std::shared_ptr<CoreContext>&& ctxt, std::sha
   m_completed = true;
   m_running = false;
 
-
   // No longer running, we MUST release the thread pointer to ensure proper teardown order
   state->m_thisThread.detach();
 
+  // Tell our CoreRunnable parent that we're done to ensure that our reference count will be cleared.
+  Stop(false);
+
   // Release our hold on the context.  After this point, we have to be VERY CAREFUL that we
   // don't try to refer to any of our own member variables, because our own object may have
   // already gone out of scope.  [this] is potentially dangling.
@@ -111,43 +109,22 @@ void BasicThread::PerformStatusUpdate(const std::function<void()>& fn) {
   m_state->m_stateCondition.notify_all();
 }
 
-bool BasicThread::ShouldStop(void) const {
-  auto context = ContextMember::GetContext();
-  return m_stop || !context || context->IsShutdown();
-}
-
-bool BasicThread::IsRunning(void) const {
-  std::lock_guard<std::mutex> lk(m_state->m_lock);
-  return m_running;
-}
-
 bool BasicThread::ThreadSleep(std::chrono::nanoseconds timeout) {
   std::unique_lock<std::mutex> lk(m_state->m_lock);
   return m_state->m_stateCondition.wait_for(lk, timeout, [this] { return ShouldStop(); });
 }
 
-bool BasicThread::Start(std::shared_ptr<Object> outstanding) {
+bool BasicThread::OnStart(void) {
   std::shared_ptr<CoreContext> context = m_context.lock();
   if(!context)
     return false;
 
-  {
-    std::lock_guard<std::mutex> lk(m_state->m_lock);
-    if(m_running)
-      // Already running, short-circuit
-      return true;
-
-    if(m_completed)
-      // Already completed (perhaps cancelled), short-circuit
-      return false;
-
-    // Currently running:
-    m_running = true;
-    m_state->m_stateCondition.notify_all();
-  }
+  // Currently running:
+  m_running = true;
 
   // Place the new thread entity directly in the space where it goes to avoid
   // any kind of races arising from asynchronous access to this space
+  auto outstanding = GetOutstanding();
   m_state->m_thisThread.~thread();
   new (&m_state->m_thisThread) std::thread(
     [this, outstanding] () mutable {
@@ -157,54 +134,25 @@ bool BasicThread::Start(std::shared_ptr<Object> outstanding) {
   return true;
 }
 
-void BasicThread::Wait(void) {
-  std::unique_lock<std::mutex> lk(m_state->m_lock);
-  m_state->m_stateCondition.wait(
-    lk,
-    [this] {return this->m_completed; }
-  );
-}
+void BasicThread::OnStop(bool graceful) {
+  // If we were never started, we need to set our completed flag to true
+  if (!m_running) {
+    m_completed = true;
+  }
 
-bool BasicThread::WaitFor(std::chrono::nanoseconds duration) {
-  std::unique_lock<std::mutex> lk(m_state->m_lock);
-  return m_state->m_stateCondition.wait_for(
-    lk,
-    duration,
-    [this] {return this->m_completed; }
-  );
+  // Always invoke stop handler:
+  OnStop();
 }
 
-template<class TimeType>
-bool BasicThread::WaitUntil(TimeType timepoint) {
+void BasicThread::DoAdditionalWait(void) {
+  // Wait for the run loop cleanup to happen in DoRunLoopCleanup
   std::unique_lock<std::mutex> lk(m_state->m_lock);
-  return m_state->m_stateCondition.wait_until(
+  m_state->m_stateCondition.wait(
     lk,
-    timepoint,
     [this] {return this->m_completed; }
   );
 }
 
-void BasicThread::Stop(bool graceful) {
-  {
-    std::lock_guard<std::mutex> lk(m_state->m_lock);
-
-    // Trivial return check:
-    if(m_stop)
-      return;
-
-    // If we're not running, mark ourselves complete
-    if(!m_running)
-      m_completed = true;
-
-    // Now we send the appropriate trigger:
-    m_stop = true;
-    m_state->m_stateCondition.notify_all();
-  }
-
-  // Event notification takes place outside of the context of a lock
-  OnStop();
-}
-
 void BasicThread::ForceCoreThreadReidentify(void) {
   for(const auto& ctxt : ContextEnumerator(AutoGlobalContext())) {
     for(const auto& thread : ctxt->CopyBasicThreadList())
diff --git a/src/autowiring/CMakeLists.txt b/src/autowiring/CMakeLists.txt
index 7b4913311..b5142671b 100644
--- a/src/autowiring/CMakeLists.txt
+++ b/src/autowiring/CMakeLists.txt
@@ -32,9 +32,11 @@ set(Autowiring_SRCS
   AutoPacket.cpp
   AutoPacket.h
   AutoPacketInternal.cpp
-  AutoPacketInternal.h
+  AutoPacketInternal.hpp
   AutoPacketFactory.cpp
   AutoPacketFactory.h
+  AutoPacketGraph.cpp
+  AutoPacketGraph.h
   AutoPacketProfiler.cpp
   AutoPacketProfiler.h
   AutoParameter.h
@@ -209,6 +211,7 @@ add_pch(Autowiring_SRCS "stdafx.h" "stdafx.cpp")
 
 add_library(Autowiring STATIC ${Autowiring_SRCS})
 
+target_include_directories(Autowiring PRIVATE "${CMAKE_SOURCE_DIR}/contrib/autoboost")
 target_include_directories(Autowiring INTERFACE
   "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>"
   "$<INSTALL_INTERFACE:$<INSTALL_PREFIX>/include>"
diff --git a/src/autowiring/CoreContext.cpp b/src/autowiring/CoreContext.cpp
index 173b0140c..19feab5a5 100644
--- a/src/autowiring/CoreContext.cpp
+++ b/src/autowiring/CoreContext.cpp
@@ -31,6 +31,7 @@ CoreContext::CoreContext(std::shared_ptr<CoreContext> pParent, t_childList::iter
   m_pParent(pParent),
   m_backReference(backReference),
   m_stateBlock(new CoreContextStateBlock),
+  m_beforeRunning(false),
   m_initiated(false),
   m_isShutdown(false),
   m_junctionBoxManager(
@@ -156,6 +157,18 @@ std::shared_ptr<CoreContext> CoreContext::NextSibling(void) const {
   return std::shared_ptr<CoreContext>();
 }
 
+const std::type_info& CoreContext::GetAutoTypeId(const AnySharedPointer& ptr) const {
+  std::lock_guard<std::mutex> lk(m_stateBlock->m_lock);
+
+  const std::type_info& ti = ptr->type();
+  auto q = m_typeMemos.find(ti);
+  if (q == m_typeMemos.end() || !q->second.pObjTraits)
+    throw autowiring_error("Attempted to obtain the true type of a shared pointer that was not a member of this context");
+
+  const ObjectTraits* pObjTraits = q->second.pObjTraits;
+  return pObjTraits->type;
+}
+
 std::shared_ptr<Object> CoreContext::IncrementOutstandingThreadCount(void) {
   std::shared_ptr<Object> retVal = m_outstanding.lock();
   if(retVal)
@@ -213,9 +226,6 @@ void CoreContext::AddInternal(const ObjectTraits& traits) {
     if(traits.pContextMember)
       AddContextMember(traits.pContextMember);
 
-    if(traits.pCoreRunnable)
-      AddCoreRunnable(traits.pCoreRunnable);
-
     if(traits.pFilter)
       m_filters.push_back(traits.pFilter.get());
 
@@ -224,8 +234,12 @@ void CoreContext::AddInternal(const ObjectTraits& traits) {
 
     // Notify any autowiring field that is currently waiting that we have a new member
     // to be considered.
-    UpdateDeferredElements(std::move(lk), traits.pObject);
+    UpdateDeferredElements(std::move(lk), m_concreteTypes.back());
   }
+  
+  // Moving this outside the lock because AddCoreRunnable will perform the checks inside its function
+  if(traits.pCoreRunnable)
+    AddCoreRunnable(traits.pCoreRunnable);
 
   // Event receivers:
   if(traits.receivesEvents) {
@@ -274,23 +288,24 @@ CoreContext::MemoEntry& CoreContext::FindByTypeUnsafe(AnySharedPointer& referenc
   }
 
   // Resolve based on iterated dynamic casts for each concrete type:
-  bool assigned = false;
+  const ObjectTraits* pObjTraits = nullptr;
   for(const auto& type : m_concreteTypes) {
     if(!reference->try_assign(*type.value))
       // No match, try the next entry
       continue;
 
-    if(assigned)
+    if (pObjTraits)
       // Resolution ambiguity, cannot proceed
       throw autowiring_error("An attempt was made to resolve a type which has multiple possible clients");
 
-    // Update the found-flag:
-    assigned = true;
+    // Update the object traits reference:
+    pObjTraits = &type;
   }
 
   // This entry was not formerly memoized.  Memoize unconditionally.
   MemoEntry& retVal = m_typeMemos[type];
   retVal.m_value = reference;
+  retVal.pObjTraits = pObjTraits;
   return retVal;
 }
 
@@ -358,13 +373,20 @@ void CoreContext::Initiate(void) {
 
   // Reacquire the lock to prevent m_threads from being modified while we sit on it
   auto outstanding = IncrementOutstandingThreadCount();
-  std::lock_guard<std::mutex> lk(m_stateBlock->m_lock);
-
-  // Signal our condition variable
-  m_stateBlock->m_stateChanged.notify_all();
+  
+  // Get the beginning of the thread list that we have at the time of lock acquisition
+  t_threadList::iterator beginning;
+  
+  {
+    std::lock_guard<std::mutex> lk(m_stateBlock->m_lock);
+    beginning = m_threads.begin();
+    
+    // Signal our condition variable
+    m_stateBlock->m_stateChanged.notify_all();
+  }
 
-  for(CoreRunnable* q : m_threads)
-    q->Start(outstanding);
+  for (auto q = beginning; q != m_threads.end(); ++q)
+    (*q)->Start(outstanding);
 }
 
 void CoreContext::InitiateCoreThreads(void) {
@@ -372,11 +394,20 @@ void CoreContext::InitiateCoreThreads(void) {
 }
 
 void CoreContext::SignalShutdown(bool wait, ShutdownMode shutdownMode) {
+  // As we signal shutdown, there may be a CoreRunnable that is in the "running" state.  If so,
+  // then we will skip that thread as we signal the list of threads to shutdown.
+  t_threadList::iterator firstThreadToStop;
+  
   // Wipe out the junction box manager, notify anyone waiting on the state condition:
   {
     std::lock_guard<std::mutex> lk(m_stateBlock->m_lock);
     UnregisterEventReceiversUnsafe();
     m_isShutdown = true;
+    
+    firstThreadToStop = m_threads.begin();
+    if (m_beforeRunning)
+      ++firstThreadToStop;
+    
     m_stateBlock->m_stateChanged.notify_all();
   }
 
@@ -418,8 +449,8 @@ void CoreContext::SignalShutdown(bool wait, ShutdownMode shutdownMode) {
 
   // Pass notice to all child threads:
   bool graceful = (shutdownMode == ShutdownMode::Graceful);
-  for(CoreRunnable* runnable : m_threads)
-    runnable->Stop(graceful);
+  for (auto itr = firstThreadToStop; itr != m_threads.end(); ++itr)
+    (*itr)->Stop(graceful);
 
   // Signal our condition variable
   m_stateBlock->m_stateChanged.notify_all();
@@ -460,16 +491,40 @@ std::shared_ptr<CoreContext> CoreContext::CurrentContext(void) {
 }
 
 void CoreContext::AddCoreRunnable(const std::shared_ptr<CoreRunnable>& ptr) {
-  // Insert into the linked list of threads first:
-  m_threads.push_front(ptr.get());
+  // Performing a double check.
+  bool shouldRun;
+  {
+    std::unique_lock<std::mutex> lk(m_stateBlock->m_lock);
+    
+    // Insert into the linked list of threads first:
+    m_threads.push_front(ptr.get());
+    
+    // Check if we're already running, this means we're late to the party and need to start _now_.
+    shouldRun = m_initiated;
+    
+    // Signal that we are in the "running"
+    m_beforeRunning = true;
+  }
 
-  if(m_initiated)
-    // We're already running, this means we're late to the party and need to start _now_.
+  // Run this thread without the lock
+  if(shouldRun)
     ptr->Start(IncrementOutstandingThreadCount());
+  
 
-  if(m_isShutdown)
-    // We're really late to the party, it's already over.  Make sure the thread's stop
-    // overrides are called and that it transitions to a stopped state.
+  // Check if the stop signal was sent between the time we started running until now.  If so, then
+  // we will stop the thread manually here.
+  bool shouldStopHere;
+  {
+    std::unique_lock<std::mutex> lk(m_stateBlock->m_lock);
+    
+    // Signal that we have stopped "running"
+    m_beforeRunning = false;
+    
+    // If SignalShutdown() was invoked while we were "running", then we will need to stop this thread ourselves
+    shouldStopHere = m_isShutdown;
+  }
+
+  if(shouldStopHere)
     ptr->Stop(false);
 }
 
@@ -601,7 +656,7 @@ void CoreContext::BroadcastContextCreationNotice(const std::type_info& sigil) co
     m_pParent->BroadcastContextCreationNotice(sigil);
 }
 
-void CoreContext::UpdateDeferredElements(std::unique_lock<std::mutex>&& lk, const std::shared_ptr<Object>& entry) {
+void CoreContext::UpdateDeferredElements(std::unique_lock<std::mutex>&& lk, const ObjectTraits& entry) {
   // Collection of satisfiable lists:
   std::vector<std::pair<const DeferrableUnsynchronizedStrategy*, DeferrableAutowiring*>> satisfiable;
 
@@ -620,7 +675,7 @@ void CoreContext::UpdateDeferredElements(std::unique_lock<std::mutex>&& lk, cons
   // Each connected nonroot deferrable autowiring is referred to as a "dependant chain".
   std::stack<DeferrableAutowiring*> stk;
   for(auto& cur : m_typeMemos) {
-    auto& value = cur.second;
+    MemoEntry& value = cur.second;
 
     if(value.m_value)
       // This entry is already satisfied, no need to process it
@@ -629,9 +684,12 @@ void CoreContext::UpdateDeferredElements(std::unique_lock<std::mutex>&& lk, cons
     // Determine whether the current candidate element satisfies the autowiring we are considering.
     // This is done internally via a dynamic cast on the interface type for which this polymorphic
     // base type was constructed.
-    if(!value.m_value->try_assign(entry))
+    if(!value.m_value->try_assign(entry.pObject))
       continue;
 
+    // Success, assign the traits
+    value.pObjTraits = &entry;
+
     // Now we need to take on the responsibility of satisfying this deferral.  We will do this by
     // nullifying the flink, and by ensuring that the memo is satisfied at the point where we
     // release the lock.
diff --git a/src/autowiring/CoreJob.cpp b/src/autowiring/CoreJob.cpp
index 327760691..5c7979c01 100644
--- a/src/autowiring/CoreJob.cpp
+++ b/src/autowiring/CoreJob.cpp
@@ -2,44 +2,55 @@
 #include "stdafx.h"
 #include "CoreJob.h"
 #include "CoreContext.h"
+#include FUTURE_HEADER
 
 CoreJob::CoreJob(const char* name) :
   ContextMember(name),
   m_running(false),
-  m_shouldStop(false),
+  m_curEvent(nullptr),
   m_curEventInTeardown(true)
 {}
 
+CoreJob::~CoreJob(void)
+{}
+
 void CoreJob::OnPended(std::unique_lock<std::mutex>&& lk){
-  if(!m_curEventInTeardown)
+  if(!m_curEventInTeardown) {
     // Something is already outstanding, it will handle dispatching for us.
     return;
+  }
 
-  if(!m_running)
+  if(!m_running) {
     // Nothing to do, we aren't running yet--just hold on to this entry until we are
     // ready to initiate it.
     return;
+  }
 
   // Increment outstanding count because we now have an entry out in a thread pool
-  auto outstanding = m_outstanding;
+  auto outstanding = GetOutstanding();
 
-  if(!outstanding)
+  if(!outstanding) {
     // We're currently signalled to stop, we must empty the queue and then
     // return here--we can't accept dispatch delivery on a stopped queue.
     while(!m_dispatchQueue.empty()) {
       delete m_dispatchQueue.front();
       m_dispatchQueue.pop_front();
     }
-  else {
+  } else {
     // Need to ask the thread pool to handle our events again:
     m_curEventInTeardown = false;
-    m_curEvent = std::async(
-      std::launch::async,
-      [this, outstanding] () mutable {
-        this->DispatchAllAndClearCurrent();
-        outstanding.reset();
-      }
-    );
+    
+    if (m_curEvent)
+      delete static_cast<std::future<void>*>(m_curEvent);
+    
+    m_curEvent = new std::future<void>(
+      std::async(
+        std::launch::async,
+        [this, outstanding] () mutable {
+          this->DispatchAllAndClearCurrent();
+          outstanding.reset();
+        }
+      ));
   }
 }
 
@@ -65,18 +76,19 @@ void CoreJob::DispatchAllAndClearCurrent(void) {
   }
 }
 
-bool CoreJob::Start(std::shared_ptr<Object> outstanding) {
+bool CoreJob::OnStart(void) {
   std::shared_ptr<CoreContext> context = m_context.lock();
-  if(!context)
+  if(!context) {
     return false;
+  }
 
-  m_outstanding = outstanding;
   m_running = true;
 
   std::unique_lock<std::mutex> lk;
-  if(!m_dispatchQueue.empty())
+  if(!m_dispatchQueue.empty()) {
     // Simulate a pending event, because we need to set up our async:
     OnPended(std::move(lk));
+  }
 
   return true;
 }
@@ -86,56 +98,23 @@ void CoreJob::Abort(void) {
   m_running = false;
 }
 
-void CoreJob::Stop(bool graceful) {
-  if(graceful)
+void CoreJob::OnStop(bool graceful) {
+  if(graceful) {
     // Pend a call which will invoke Abort once the dispatch queue is done:
     DispatchQueue::Pend(
       [this] {this->Abort();}
     );
-  else
+  } else {
     // Abort the dispatch queue so anyone waiting will wake up
     Abort();
-
-  // Reset the outstanding pointer, we don't intend to hold it anymore:
-  m_outstanding.reset();
-
-  // Hit our condition variable to wake up any listeners:
-  std::lock_guard<std::mutex> lk(m_dispatchLock);
-  m_shouldStop = true;
-  m_queueUpdated.notify_all();
-}
-
-void CoreJob::Wait() {
-  {
-    std::unique_lock<std::mutex> lk(m_dispatchLock);
-    m_queueUpdated.wait(
-      lk,
-      [this] {
-        return ShouldStop() && m_curEventInTeardown;
-      }
-    );
   }
-
-  // If the current event is valid, we can block on it until it becomes valid:
-  if(m_curEvent.valid())
-    m_curEvent.wait();
 }
 
-bool CoreJob::WaitFor(std::chrono::nanoseconds duration) {
-  {
-    std::unique_lock<std::mutex> lk(m_dispatchLock);
-    if(!m_queueUpdated.wait_for(
-      lk,
-      duration,
-      [this] {
-        return ShouldStop() && m_curEventInTeardown;
-      }
-    ))
-      return false;
+void CoreJob::DoAdditionalWait(void) {
+  if (m_curEvent) {
+    std::future<void>* ptr = static_cast<std::future<void>*>(m_curEvent);
+    ptr->wait();
+    delete ptr;
+    m_curEvent = nullptr;
   }
-
-  // If the current event is valid, we can block on it until it becomes valid:
-  if(m_curEvent.valid())
-    m_curEvent.wait();
-  return true;
-}
\ No newline at end of file
+}
diff --git a/src/autowiring/CoreRunnable.cpp b/src/autowiring/CoreRunnable.cpp
index a66c19abf..deaadd8b4 100644
--- a/src/autowiring/CoreRunnable.cpp
+++ b/src/autowiring/CoreRunnable.cpp
@@ -2,6 +2,82 @@
 #include "stdafx.h"
 #include "CoreRunnable.h"
 
-CoreRunnable::CoreRunnable(void){}
+// Explicit instantiation of supported time point types:
+template<> bool CoreRunnable::WaitUntil(std::chrono::steady_clock::time_point);
+template<> bool CoreRunnable::WaitUntil(std::chrono::system_clock::time_point);
 
-CoreRunnable::~CoreRunnable(void){}
+CoreRunnable::CoreRunnable(void):
+  m_wasStarted(false),
+  m_shouldStop(false)
+{}
+
+CoreRunnable::~CoreRunnable(void) {}
+
+const std::shared_ptr<Object>& CoreRunnable::GetOutstanding(void) const {
+  return m_outstanding;
+}
+
+bool CoreRunnable::Start(std::shared_ptr<Object> outstanding) {
+  std::lock_guard<std::mutex> lk(m_lock);
+  if(m_wasStarted || m_outstanding || m_shouldStop)
+    // We have already been started or stopped, end here
+    return true;
+
+  m_wasStarted = true;
+  m_outstanding = outstanding;
+  if(!OnStart()) {
+    m_shouldStop = true;
+    m_outstanding.reset();
+
+    // Immediately invoke a graceless stop in response
+    OnStop(false);
+  }
+
+  return true;
+}
+
+void CoreRunnable::Stop(bool graceful) {
+  if (!m_shouldStop) {
+    // Stop flag should be pulled high
+    m_shouldStop = true;
+
+    // Do not call this method more than once:
+    OnStop(graceful);
+  }
+
+  if (m_outstanding) {
+    std::shared_ptr<Object> outstanding;
+    std::lock_guard<std::mutex> lk(m_lock);
+
+    // Ensure we do not invoke the outstanding count dtor while holding a lock
+    outstanding.swap(m_outstanding);
+
+    // Everything looks good now
+    m_cv.notify_all();
+  }
+}
+
+void CoreRunnable::Wait(void) {
+  std::unique_lock<std::mutex> lk(m_lock);
+  m_cv.wait(lk, [this](){ return ShouldStop() && !IsRunning(); });
+  DoAdditionalWait();
+}
+
+bool CoreRunnable::WaitFor(std::chrono::nanoseconds timeout) {
+  std::unique_lock<std::mutex> lk(m_lock);
+  if (m_cv.wait_for(lk, timeout, [this](){ return ShouldStop() && !IsRunning(); })) {
+    DoAdditionalWait();
+    return true;
+  }
+  return false;
+}
+
+template<typename TimeType>
+bool CoreRunnable::WaitUntil(TimeType timepoint) {
+  std::unique_lock<std::mutex> lk(m_lock);
+  if (m_cv.wait_until(lk, timepoint, [this](){ return ShouldStop() && !IsRunning(); })) {
+    DoAdditionalWait();
+    return true;
+  }
+  return false;
+}
diff --git a/src/autowiring/CoreThread.cpp b/src/autowiring/CoreThread.cpp
index 3ccb54529..a8f8b2615 100644
--- a/src/autowiring/CoreThread.cpp
+++ b/src/autowiring/CoreThread.cpp
@@ -44,13 +44,14 @@ void CoreThread::WaitForEvent(void) {
     !this->m_dispatchQueue.empty();
   });
 
-  if(m_dispatchQueue.empty())
+  if(m_dispatchQueue.empty()) {
     // The delay queue has items but the dispatch queue does not, we need to switch
     // to the suggested sleep timeout variant:
     WaitForEventUnsafe(lk, m_delayedQueue.top().GetReadyTime());
-  else
+  } else {
     // We have an event, we can just hop over to this variant:
     DispatchEventUnsafe(lk);
+  }
 }
 
 bool CoreThread::WaitForEvent(std::chrono::milliseconds milliseconds) {
@@ -58,9 +59,10 @@ bool CoreThread::WaitForEvent(std::chrono::milliseconds milliseconds) {
 }
 
 bool CoreThread::WaitForEvent(std::chrono::steady_clock::time_point wakeTime) {
-  if(wakeTime == std::chrono::steady_clock::time_point::max())
+  if(wakeTime == std::chrono::steady_clock::time_point::max()) {
     // Maximal wait--we can optimize by using the zero-arguments version
     return WaitForEvent(), true;
+  }
 
   std::unique_lock<std::mutex> lk(m_dispatchLock);
   return WaitForEventUnsafe(lk, wakeTime);
@@ -103,7 +105,10 @@ void CoreThread::Run() {
     WaitForEvent();
 }
 
-void CoreThread::Stop(bool graceful) {
+void CoreThread::OnStop(bool graceful) {
+  // Base class handling first:
+  BasicThread::OnStop(graceful);
+
   if(graceful) {
     // Pend a call which will invoke Abort once the dispatch queue is done:
     DispatchQueue::Pend([this] {
@@ -115,7 +120,4 @@ void CoreThread::Stop(bool graceful) {
   } else
     // Abort the dispatch queue so anyone waiting will wake up
     DispatchQueue::Abort();
-
-  // Pass off to base class handling:
-  BasicThread::Stop(graceful);
 }
diff --git a/src/autowiring/stdafx.h b/src/autowiring/stdafx.h
index 4ac8da63e..adacb1a4f 100644
--- a/src/autowiring/stdafx.h
+++ b/src/autowiring/stdafx.h
@@ -1,6 +1,9 @@
 // Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
 #pragma once
 
+// Internal build flag for namespace discrimination
+#define AUTOWIRING_IS_BEING_BUILT
+
 // Only include these headers in cases where a pch can be generated
 // Currently this is only supported on MSVC
 #ifdef _MSC_VER
diff --git a/src/autowiring/test/AutoFilterDiagnosticsTest.cpp b/src/autowiring/test/AutoFilterDiagnosticsTest.cpp
new file mode 100644
index 000000000..e4e190656
--- /dev/null
+++ b/src/autowiring/test/AutoFilterDiagnosticsTest.cpp
@@ -0,0 +1,39 @@
+// Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
+#include "stdafx.h"
+#include <autowiring/autowiring.h>
+#include <autowiring/SatCounter.h>
+
+class AutoFilterDiagnosticsTest:
+  public testing::Test
+{
+public:
+  AutoFilterDiagnosticsTest(void) {
+    AutoCurrentContext()->Initiate();
+  }
+};
+
+class FilterMemberNotInheritingObject {
+public:
+  void AutoFilter(const int&) {}
+};
+
+TEST_F(AutoFilterDiagnosticsTest, CanGetExpectedTrueType) {
+  AutoRequired<FilterMemberNotInheritingObject> mnio;
+  AutoRequired<AutoPacketFactory> factory;
+
+  auto packet = factory->NewPacket();
+  auto dispositions = packet->GetDispositions();
+  ASSERT_EQ(1UL, dispositions.size()) << "Dispositions collection contained an unexpected AutoFilter";
+
+  auto& disposition = dispositions.front();
+  ASSERT_EQ(1UL, disposition.m_subscribers.size()) << "Expected exactly one subscriber for the sole present type";
+
+  const SatCounter* descriptor = disposition.m_subscribers.front();
+  AnySharedPointer asp(descriptor->GetAutoFilter());
+
+  // Get more information about this object from the enclosing context:
+  AutoCurrentContext ctxt;
+  const std::type_info* ti;
+  ASSERT_NO_THROW(ti = &ctxt->GetAutoTypeId(asp)) << "Exception thrown while attempting to get true type information";
+  ASSERT_EQ(typeid(FilterMemberNotInheritingObject), *ti) << "True type not correctly reported, got " << autowiring::demangle(*ti) << ", expected FilterMemberNotInheritingObject";
+}
\ No newline at end of file
diff --git a/src/autowiring/test/AutoFilterSequencing.cpp b/src/autowiring/test/AutoFilterSequencing.cpp
index d66fb3d9f..c92b3a5ea 100644
--- a/src/autowiring/test/AutoFilterSequencing.cpp
+++ b/src/autowiring/test/AutoFilterSequencing.cpp
@@ -62,3 +62,69 @@ class FilterOutDeferred:
     return Deferred(this);
   }
 };
+
+TEST_F(AutoFilterSequencing, SuccessorAliasRules) {
+  AutoRequired<AutoPacketFactory> factory;
+  auto packet1 = factory->NewPacket();
+  auto packet2 = packet1->Successor();
+  ASSERT_TRUE(!!packet2) << "Returned successor packet was null";
+
+  auto expected = factory->NewPacket();
+
+  ASSERT_EQ(expected, packet2) << "Expected that the successor packet would match the next packet returned by the factory";
+}
+
+TEST_F(AutoFilterSequencing, SuccessorHoldViolationCheck) {
+  AutoRequired<AutoPacketFactory> factory;
+  auto packet1 = factory->NewPacket();
+  auto packet2 = packet1->Successor();
+
+  ASSERT_TRUE(packet1.unique()) << "Expected that the first issued packet shared pointer not to be aliased anywhere";
+
+  packet1.reset();
+  factory->NewPacket();
+
+  ASSERT_TRUE(packet2.unique()) << "Expected that a successor packet would be unique when the principal was destroyed";
+}
+
+TEST_F(AutoFilterSequencing, PacketReverseSuccessor) {
+  AutoRequired<AutoPacketFactory> factory;
+
+  auto packet1 = factory->NewPacket();
+  auto packet2 = factory->NewPacket();
+
+  ASSERT_EQ(packet2, packet1->Successor()) << "Successor packet obtained after generation from the factory did not match as expected";
+}
+
+TEST_F(AutoFilterSequencing, ManySuccessors) {
+  AutoRequired<AutoPacketFactory> factory;
+  {
+    auto packetA = factory->NewPacket();
+    auto packet5 = packetA->Successor()->Successor()->Successor()->Successor();
+
+    factory->NewPacket();
+    factory->NewPacket();
+    factory->NewPacket();
+    auto packetE = factory->NewPacket();
+  
+    ASSERT_EQ(packet5, packetE) << "Successor packet obtained after generation from the factory did not match as expected";
+  }
+  
+  AutoRequired<FilterFirst> first;
+  {
+    auto packetA = factory->NewPacket();
+    packetA->Successor()->Successor()->Successor()->Successor();
+    ASSERT_EQ(1, first->m_called) << "AutoFilter triggered from successor";
+
+    factory->NewPacket();
+    ASSERT_EQ(2, first->m_called) << "AutoFilter not triggered from new packet";
+    factory->NewPacket();
+    ASSERT_EQ(3, first->m_called) << "AutoFilter not triggered from new packet";
+    factory->NewPacket();
+    ASSERT_EQ(4, first->m_called) << "AutoFilter not triggered from new packet";
+    factory->NewPacket();
+    ASSERT_EQ(5, first->m_called) << "AutoFilter not triggered from new packet";
+    factory->NewPacket();
+    ASSERT_EQ(6, first->m_called) << "AutoFilter not triggered from new packet";
+  }
+}
diff --git a/src/autowiring/test/AutoFilterTest.cpp b/src/autowiring/test/AutoFilterTest.cpp
index 9aaf70e57..269c4287f 100644
--- a/src/autowiring/test/AutoFilterTest.cpp
+++ b/src/autowiring/test/AutoFilterTest.cpp
@@ -26,10 +26,10 @@ TEST_F(AutoFilterTest, GetOutstandingTest) {
 
   {
     auto packet = factory->NewPacket();
-    ASSERT_EQ(1UL, factory->GetOutstanding()) << "Factory outstanding count mismatch";
+    ASSERT_EQ(1UL, factory->GetOutstandingPacketCount()) << "Factory outstanding count mismatch";
   }
 
-  ASSERT_EQ(0UL, factory->GetOutstanding()) << "Factory outstanding did not go to zero after releasing the only outstanding packet";
+  ASSERT_EQ(0UL, factory->GetOutstandingPacketCount()) << "Factory outstanding did not go to zero after releasing the only outstanding packet";
 }
 
 TEST_F(AutoFilterTest, VerifyDescendentAwareness) {
@@ -63,7 +63,6 @@ TEST_F(AutoFilterTest, VerifyDescendentAwareness) {
     EXPECT_TRUE(strongPacket->HasSubscribers<Decoration<0>>()) << "Packet lacked expected subscription from subcontext";
     EXPECT_TRUE(weakPacket.lock()->HasSubscribers<Decoration<0>>()) << "Packet lacked expected subscription from subcontext";
   }
-  EXPECT_TRUE(weakPacket.expired()) << "Packet was not destroyed when it's subscribers were removed";
   EXPECT_FALSE(filterChecker.expired()) << "Packet keeping subcontext member alive";
 
   // Verify the second packet will no longer have subscriptions  -
@@ -83,10 +82,6 @@ TEST_F(AutoFilterTest, VerifyDescendentAwareness) {
   // Create a packet after the subcontext has been destroyed
   auto lastPacket = parentFactory->NewPacket();
   EXPECT_FALSE(lastPacket->HasSubscribers<Decoration<0>>()) << "Subscription was incorrectly, retroactively added to a packet";
-
-  // Verify that strongPacket was responsible for keeping subFilter alive
-  strongPacket.reset();
-  EXPECT_TRUE(filterChecker.expired()) << "Subscriber from destroyed subcontext didn't expire after packet was reset.";
 }
 
 TEST_F(AutoFilterTest, VerifySimpleFilter) {
@@ -673,11 +668,11 @@ TEST_F(AutoFilterTest, SingleImmediate) {
     // Verify we can't decorate this value a second time:
     ASSERT_ANY_THROW(packet->DecorateImmediate(val)) << "Expected an exception when a second attempt was made to attach a decoration";
   }
-  ASSERT_EQ(0, factory->GetOutstanding()) << "Destroyed packet remains outstanding";
+  ASSERT_EQ(0, factory->GetOutstandingPacketCount()) << "Destroyed packet remains outstanding";
 
   static const int pattern = 1365; //1365 ~ 10101010101
   AutoRequired<FilterGen<Decoration<pattern>>> fgp;
-  ASSERT_EQ(0, factory->GetOutstanding()) << "Outstanding packet count is correct after incrementing m_poolVersion due to AutoFilter addition";
+  ASSERT_EQ(0, factory->GetOutstandingPacketCount()) << "Outstanding packet count is correct after incrementing m_poolVersion due to AutoFilter addition";
   {
     auto packet = factory->NewPacket();
     Decoration<pattern> dec;
@@ -686,7 +681,7 @@ TEST_F(AutoFilterTest, SingleImmediate) {
     ASSERT_TRUE(fgp->m_called == 1) << "Filter should called " << fgp->m_called << " times, expected 1";
     ASSERT_TRUE(std::get<0>(fgp->m_args).i == pattern) << "Filter argument yielded " << std::get<0>(fgp->m_args).i << "expected " << pattern;
   }
-  ASSERT_EQ(0, factory->GetOutstanding()) << "Destroyed packet remains outstanding";
+  ASSERT_EQ(0, factory->GetOutstandingPacketCount()) << "Destroyed packet remains outstanding";
 
   // Terminate enclosing context
   AutoCurrentContext()->SignalShutdown(true);
diff --git a/src/autowiring/test/AutowiringTest.cpp b/src/autowiring/test/AutowiringTest.cpp
index 02df626ea..5d5b1e47a 100644
--- a/src/autowiring/test/AutowiringTest.cpp
+++ b/src/autowiring/test/AutowiringTest.cpp
@@ -106,4 +106,29 @@ TEST_F(AutowiringTest, AUTOTHROW_CanSeeThrownAutoDesiredExceptions) {
   AutoRequired<ChecksForExceptions> cfe;
   AutoDesired<ThrowsExceptionInCtor>();
   ASSERT_TRUE(cfe->m_called) << "Exception was not caught by exception filter in Autowiring context";
-}
\ No newline at end of file
+}
+
+class PublicBase {
+public:
+  PublicBase(void) {}
+  virtual ~PublicBase(void) {}
+};
+
+class PrivateBase {
+public:
+  PrivateBase(void) {}
+  virtual ~PrivateBase(void) {}
+};
+
+class Derived : public PublicBase, private PrivateBase {
+public:
+  Derived(void) {}
+  ~Derived(void) {}
+};
+
+TEST_F(AutowiringTest, TestFailureOfDynamicCast) {
+  Derived d;
+  PublicBase *pub = static_cast<PublicBase*>(&d);
+  ASSERT_EQ(dynamic_cast<PrivateBase*>(pub), nullptr) << "Dynamic cast failed to give nullptr when cross casting to a private base class";
+  static_assert(!std::is_base_of<Derived, PrivateBase>::value, "is_base_of said a private base was a base");
+}
diff --git a/src/autowiring/test/CMakeLists.txt b/src/autowiring/test/CMakeLists.txt
index 7d4c9fd1b..d7223e1eb 100644
--- a/src/autowiring/test/CMakeLists.txt
+++ b/src/autowiring/test/CMakeLists.txt
@@ -4,6 +4,7 @@ set(AutowiringTest_SRCS
   AutoConfigTest.cpp
   AutoConstructTest.cpp
   AutoFilterCollapseRulesTest.cpp
+  AutoFilterDiagnosticsTest.cpp
   AutoInjectableTest.cpp
   AutoPacketFactoryTest.cpp
   AutoParameterTest.cpp
@@ -87,6 +88,7 @@ endif()
 add_pch(AutowiringTest_SRCS "stdafx.h" "stdafx.cpp")
 add_executable(AutowiringTest ${AutowiringTest_SRCS})
 target_link_libraries(AutowiringTest Autowiring AutowiringFixture AutoTesting)
+target_include_directories(AutowiringTest PRIVATE "${CMAKE_SOURCE_DIR}/contrib/autoboost")
 
 # Need boost thread on android, because of our use of std::async
 if(BUILD_ANDROID)
diff --git a/src/autowiring/test/CoreContextTest.cpp b/src/autowiring/test/CoreContextTest.cpp
index 3e61a8dbb..63dc2cce7 100644
--- a/src/autowiring/test/CoreContextTest.cpp
+++ b/src/autowiring/test/CoreContextTest.cpp
@@ -214,4 +214,4 @@ TEST_F(CoreContextTest, NoEnumerateBeforeBoltReturn) {
 
   // Need to block until this thread is done
   t.join();
-}
\ No newline at end of file
+}
diff --git a/src/autowiring/test/CoreRunnableTest.cpp b/src/autowiring/test/CoreRunnableTest.cpp
index dea9650cf..74c53aa10 100644
--- a/src/autowiring/test/CoreRunnableTest.cpp
+++ b/src/autowiring/test/CoreRunnableTest.cpp
@@ -13,15 +13,10 @@ class StartsSubcontextWhileStarting:
 public:
   AutoCreateContext m_myContext;
 
-  bool Start(std::shared_ptr<Object> outstanding) override {
+  bool OnStart(void) override {
     m_myContext->Initiate();
-    return true;
+    return false;
   }
-
-  void Stop(bool graceful) override {}
-  bool IsRunning(void) const override { return false; }
-  bool ShouldStop(void) const override { return true; }
-  void Wait(void) override {}
 };
 
 TEST_F(CoreRunnableTest, CanStartSubcontextWhileInitiating) {
diff --git a/src/autowiring/test/CoreThreadTest.cpp b/src/autowiring/test/CoreThreadTest.cpp
index 2135a147e..bb55bbf08 100644
--- a/src/autowiring/test/CoreThreadTest.cpp
+++ b/src/autowiring/test/CoreThreadTest.cpp
@@ -443,3 +443,37 @@ TEST_F(CoreThreadTest, PendAfterShutdown) {
   // Verify that the lambda was destroyed more or less right away
   ASSERT_TRUE(v.unique()) << "Shared pointer in a lambda closure appears to have been leaked";
 }
+
+class BTOverridesOnStopHandler:
+  public BasicThread
+{
+public:
+  BTOverridesOnStopHandler(void) : got_stopped(false) {}
+  bool got_stopped;
+
+  void Run(void) override {}
+
+  void OnStop(void) override { got_stopped = true; }
+};
+
+class CTOverridesOnStopHandler:
+  public CoreThread
+{
+public:
+  CTOverridesOnStopHandler(void) : got_stopped(false) {}
+  bool got_stopped;
+  void OnStop(void) override { got_stopped = true; }
+};
+
+TEST_F(CoreThreadTest, VerifyThreadGetsOnStop) {
+  AutoRequired<BTOverridesOnStopHandler> bsoosh;
+  AutoRequired<CTOverridesOnStopHandler> ctoosh;
+
+  AutoCurrentContext ctxt;
+  ctxt->Initiate();
+  ctxt->SignalShutdown();
+  ctxt->Wait();
+
+  EXPECT_TRUE(bsoosh->got_stopped) << "BasicThread instance did not receive an OnStop notification as expected";
+  EXPECT_TRUE(ctoosh->got_stopped) << "CoreThread instance did not receive an OnStop notification as expected";
+}
\ No newline at end of file
diff --git a/src/autowiring/test/MultiInheritTest.cpp b/src/autowiring/test/MultiInheritTest.cpp
index 04e04874a..38b8ecc1c 100644
--- a/src/autowiring/test/MultiInheritTest.cpp
+++ b/src/autowiring/test/MultiInheritTest.cpp
@@ -23,11 +23,11 @@ class Base {
   AutoRequired<Shared> m_member;
 };
 
-class Derived:
+class MultiInheritDerived:
   public Base
 {
 public:
-  Derived(void) {
+  MultiInheritDerived(void) {
     EXPECT_TRUE(Base::m_member.IsAutowired()) << "Base AutoRequired member was not initialized properly";
     EXPECT_EQ(100, Base::m_member->m_i) << "Autowired instance was not properly constructed";
     EXPECT_TRUE(m_secondMember.IsAutowired()) << "Failed to autowire a type which should have been injected in this context";
@@ -57,7 +57,7 @@ TEST_F(MultiInheritTest, VerifyBaseInitializer) {
   AutoCreateContext ctxt;
   CurrentContextPusher pshr(ctxt);
 
-  Derived derived;
+  MultiInheritDerived derived;
 
   // Expect that something autowires when we're done at least:
   EXPECT_TRUE(derived.m_member.IsAutowired());
diff --git a/src/autowiring/test/TeardownNotifierTest.cpp b/src/autowiring/test/TeardownNotifierTest.cpp
index a009304e6..827a9521f 100644
--- a/src/autowiring/test/TeardownNotifierTest.cpp
+++ b/src/autowiring/test/TeardownNotifierTest.cpp
@@ -1,6 +1,6 @@
 // Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
 #include "stdafx.h"
-#include <autowiring/Autowired.h>
+#include <autowiring/autowiring.h>
 
 class TeardownNotifierTest:
   public testing::Test
@@ -45,4 +45,20 @@ TEST_F(TeardownNotifierTest, ReferenceMemberInTeardown) {
   }
 
   EXPECT_TRUE(hit) << "Failed to reference a member of a context in it's teardown listener";
-}
\ No newline at end of file
+}
+
+TEST_F(TeardownNotifierTest, CanAutowireInTeardown) {
+  bool foundSimpleMember = false;
+  bool calledNotifier = false;
+  {
+    AutoCreateContext ctxt;
+    AutoRequired<SimpleMember> sm(ctxt);
+    ctxt->AddTeardownListener([&foundSimpleMember, &calledNotifier](const CoreContext& ctxt) {
+      foundSimpleMember = AutowiredFast<SimpleMember>(&ctxt).IsAutowired();
+      calledNotifier = true;
+    });
+  }
+
+  ASSERT_TRUE(foundSimpleMember) << "Failed to find a context member in teardown with AutowiredFast";
+  ASSERT_TRUE(calledNotifier) << "Teardown notifier not called as expected";
+}
diff --git a/src/autowiring/test/TestFixtures/SimpleReceiver.hpp b/src/autowiring/test/TestFixtures/SimpleReceiver.hpp
index a482b2e10..0089ed519 100644
--- a/src/autowiring/test/TestFixtures/SimpleReceiver.hpp
+++ b/src/autowiring/test/TestFixtures/SimpleReceiver.hpp
@@ -193,7 +193,7 @@ class SimpleReceiver:
   }
 
   // Overridden here so we can hit the barrier if we're still waiting on it
-  void OnStop() override {
+  void OnStop(void) override {
     Proceed();
   }
 
diff --git a/src/autowiring/test/stdafx.h b/src/autowiring/test/stdafx.h
index 0bf9972e9..a5e3db79f 100644
--- a/src/autowiring/test/stdafx.h
+++ b/src/autowiring/test/stdafx.h
@@ -1,6 +1,9 @@
 // Copyright (C) 2012-2014 Leap Motion, Inc. All rights reserved.
 #pragma once
 
+// Internal build flag for namespace discrimination
+#define AUTOWIRING_IS_BEING_BUILT
+
 #include <C++11/cpp11.h>
 #include <gtest/gtest.h>
 #include <autowiring/autowiring.h>
diff --git a/version.cmake b/version.cmake
index cbd770303..466dac296 100644
--- a/version.cmake
+++ b/version.cmake
@@ -1 +1 @@
-set(autowiring_VERSION 0.3.0)
+set(autowiring_VERSION 0.3.1)