NTL 8.x introduces a new class, NTL::WrappedPtr<T>.  Unfortunately, Cython
does not add a namespace identifier to the name of the existing WrappedPtr
class, generated from the patched files below, resulting in ambiguous
references to that name.  This patch simply changes the name of the existing
class to avoid the name collision.

diff -up src/sage/libs/polybori/decl.pxd.orig src/sage/libs/polybori/decl.pxd
--- src/sage/libs/polybori/decl.pxd.orig	2014-11-23 07:58:14.000000000 -0700
+++ src/sage/libs/polybori/decl.pxd	2015-01-13 20:00:00.000000000 -0700
@@ -291,10 +291,10 @@ cdef extern from "pb_wrap.h":
         int (* size)()
         PBPolyEntry (* get "operator[]")(int)
 
-    ctypedef struct PBFglmStrategy "WrappedPtr<FGLMStrategy>":
+    ctypedef struct PBFglmStrategy "WrappedPointer<FGLMStrategy>":
         PBPolyVector (* main "operator->()->main")()
 
-    PBFglmStrategy PBFglmStrategy_Constructor "WrappedPtr<FGLMStrategy>" \
+    PBFglmStrategy PBFglmStrategy_Constructor "WrappedPointer<FGLMStrategy>" \
         (PBRing from_ring, PBRing to_ring, PBPolyVector vec)
 
     cdef cppclass PBGBStrategy "GroebnerStrategy":
@@ -349,7 +349,7 @@ cdef extern from "pb_wrap.h":
         PBPolyVector (* faugereStepDense)(PBPolyVector v)
         bint (* generators_leadingTerms_owns  "generators.leadingTerms.owns")(PBMonom term)
 
-    PBGBStrategy PBGBStrategy_Constructor "WrappedPtr<GroebnerStrategy>" \
+    PBGBStrategy PBGBStrategy_Constructor "WrappedPointer<GroebnerStrategy>" \
         (PBRing r)
 
 
diff -up src/sage/libs/polybori/pb_wrap.h.orig src/sage/libs/polybori/pb_wrap.h
--- src/sage/libs/polybori/pb_wrap.h.orig	2014-11-23 07:58:14.000000000 -0700
+++ src/sage/libs/polybori/pb_wrap.h	2015-01-13 20:00:00.000000000 -0700
@@ -177,23 +177,23 @@ PyObject* preallocated_to_PyString(const
 
 
 template <class Type>
-class WrappedPtr:
+class WrappedPointer:
   public boost::shared_ptr<Type> {
-    typedef WrappedPtr self;
+    typedef WrappedPointer self;
     typedef boost::shared_ptr<Type> base;
 
  public:
-    WrappedPtr(): base() {}
-    WrappedPtr(const self& rhs): base(rhs) {}
+    WrappedPointer(): base() {}
+    WrappedPointer(const self& rhs): base(rhs) {}
 
     template <class T1>
-    WrappedPtr(const T1& arg): base(new Type(arg)) {}
+    WrappedPointer(const T1& arg): base(new Type(arg)) {}
 
     template <class T1, class T2>
-    WrappedPtr(const T1& arg1, const T2& arg2): base(new Type(arg1, arg2)) {}
+    WrappedPointer(const T1& arg1, const T2& arg2): base(new Type(arg1, arg2)) {}
 
       template <class T1, class T2, class T3>
-        WrappedPtr(const T1& arg1, const T2& arg2, const T3& arg3):
+        WrappedPointer(const T1& arg1, const T2& arg2, const T3& arg3):
         base(new Type(arg1, arg2, arg3)) {}
 
     operator Type&() { return base::operator*();}