@@ -774,10 +791,10 @@ KeyError: 2
to provide functional access to the attribute <name>. This
facility can be used from C++ or entirely from Python. For example, the
- following shows how we can implement a “computed attribute” in Python:
+ following shows how we can implement a ``computed attribute'' in Python:
->>> class Range(AnyPy_cppExtensionClass):
+>>> class Range(AnyBPLExtensionClass):
... def __init__(self, start, end):
... self.start = start
... self.end = end
@@ -793,7 +810,7 @@ KeyError: 2
Direct Access to Data Members
- Py_cpp uses the special
+ BPL uses the special
__xxxattr__<name>__ functionality described above
to allow direct access to data members through the following special
functions on class_builder<> and
@@ -873,14 +890,14 @@ if (PyInstance_Check(r)) { ...
- Previous: Inheritance Next: A Peek Under the Hood Up: Top
+Next: A Peek Under the Hood
+Previous: Inheritance
+Up: Top
© Copyright David Abrahams and Ullrich Köthe 2000.
Permission to copy, use, modify, sell and distribute this document is
granted provided this copyright notice appears in all copies. This
- document is provided “as is” without express or implied
+ document is provided ``as is'' without express or implied
warranty, and with no claim as to its suitability for any purpose.
Updated: Nov 26, 2000
diff --git a/doc/under-the-hood.html b/doc/under-the-hood.html
index 288021cf..902804d3 100644
--- a/doc/under-the-hood.html
+++ b/doc/under-the-hood.html
@@ -22,7 +22,7 @@
"example1.html#add_world_class">add it to the module it goes into the
module's dictionary to be looked up under the name "world".
- Py_cpp uses C++'s template argument deduction mechanism to determine the
+ BPL uses C++'s template argument deduction mechanism to determine the
types of arguments to functions (except constructors, for which we must
provide an argument list
because they can't be named in C++). Then, it calls the appropriate
@@ -48,8 +48,8 @@
the top of your module's init function, then def the member
functions later to avoid problems with inter-class dependencies.
- Previous: Function Overloading
- Next: Building a Module with Py_cpp
+ Next: Building a Module with BPL
+ Previous: Special Method and Operator Support
Up: Top
© Copyright David Abrahams 2000. Permission to copy, use, modify,
diff --git a/example/rwgk1.cpp b/example/rwgk1.cpp
new file mode 100644
index 00000000..b21ae4d1
--- /dev/null
+++ b/example/rwgk1.cpp
@@ -0,0 +1,41 @@
+#include
+
+namespace { // Avoid cluttering the global namespace.
+
+ // A couple of simple C++ functions that we want to expose to Python.
+ std::string greet() { return "hello, world"; }
+ int square(int number) { return number * number; }
+}
+
+#include
+
+namespace python = boost::python;
+
+// Python requires an exported function called init in every
+// extension module. This is where we build the module contents.
+extern "C"
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
+void initrwgk1()
+{
+ try
+ {
+ // Create an object representing this extension module.
+ python::module_builder this_module("rwgk1");
+
+ // Add regular functions to the module.
+ this_module.def(greet, "greet");
+ this_module.def(square, "square");
+ }
+ catch(...)
+ {
+ python::handle_exception(); // Deal with the exception for Python
+ }
+}
+
+// Win32 DLL boilerplate
+#if defined(_WIN32)
+#include
+extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID) { return 1; }
+#endif // _WIN32
diff --git a/example/example1.py b/example/test_example1.py
similarity index 100%
rename from example/example1.py
rename to example/test_example1.py
diff --git a/example/test_rwgk1.py b/example/test_rwgk1.py
new file mode 100644
index 00000000..87298875
--- /dev/null
+++ b/example/test_rwgk1.py
@@ -0,0 +1,17 @@
+r'''>>> import rwgk1
+ >>> print rwgk1.greet()
+ hello, world
+ >>> number = 11
+ >>> print number, '*', number, '=', rwgk1.square(number)
+ 11 * 11 = 121
+'''
+
+def run(args = None):
+ if args is not None:
+ import sys
+ sys.argv = args
+ import doctest, test_rwgk1
+ doctest.testmod(test_rwgk1)
+
+if __name__ == '__main__':
+ run()
diff --git a/include/boost/python/class_builder.hpp b/include/boost/python/class_builder.hpp
index 9e88f049..7ef843c4 100644
--- a/include/boost/python/class_builder.hpp
+++ b/include/boost/python/class_builder.hpp
@@ -27,8 +27,8 @@ class class_builder
// define constructors
template
- void def(const signature& signature)
- { m_class->def(signature); }
+ void def(const signature& s)
+ { m_class->def(s); }
// export heterogeneous reverse-argument operators
// (type of lhs: 'left', of rhs: 'right')
diff --git a/include/boost/python/detail/config.hpp b/include/boost/python/detail/config.hpp
index 2488bd8e..faf52ee4 100644
--- a/include/boost/python/detail/config.hpp
+++ b/include/boost/python/detail/config.hpp
@@ -21,7 +21,7 @@
# else
# define BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE namespace boost { namespace python {
# define BOOST_PYTHON_END_CONVERSION_NAMESPACE }} // namespace boost::python
-# define BOOST_PYTHON_CONVERSION python
+# define BOOST_PYTHON_CONVERSION boost::python
# define BOOST_PYTHON_IMPORT_CONVERSION(x) void never_defined() // so we can follow the macro with a ';'
# endif
diff --git a/include/boost/python/detail/extension_class.hpp b/include/boost/python/detail/extension_class.hpp
index 20d48796..0e2e3427 100644
--- a/include/boost/python/detail/extension_class.hpp
+++ b/include/boost/python/detail/extension_class.hpp
@@ -721,8 +721,6 @@ class extension_instance : public instance
// Template function implementations
//
-tuple extension_class_coerce(ref l, ref r);
-
template
extension_class::extension_class()
: extension_class_base(typeid(T).name())
@@ -743,7 +741,7 @@ void extension_class::def_standard_coerce()
ref coerce_fct = dict().get_item(string("__coerce__"));
if(coerce_fct.get() == 0) // not yet defined
- this->def(&extension_class_coerce, "__coerce__");
+ this->def(&standard_coerce, "__coerce__");
}
template
diff --git a/include/boost/python/detail/wrap_python.hpp b/include/boost/python/detail/wrap_python.hpp
index 7c6dd5be..eb831b68 100644
--- a/include/boost/python/detail/wrap_python.hpp
+++ b/include/boost/python/detail/wrap_python.hpp
@@ -1,5 +1,22 @@
+// (C) Copyright David Abrahams 2000. 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.
+//
+// The author gratefully acknowleges the support of Dragon Systems, Inc., in
+// producing this work.
+
+// This file serves as a wrapper around which allows it to be
+// compiled with GCC 2.95.2 under Win32 and which disables the default MSVC
+// behavior so that a program may be compiled in debug mode without requiring a
+// special debugging build of the Python library.
+
+
+// To use the Python debugging library, #define BOOST_DEBUG_PYTHON on the
+// compiler command-line.
+
#ifdef _DEBUG
-# ifndef DEBUG_PYTHON
+# ifndef BOOST_DEBUG_PYTHON
# undef _DEBUG // Don't let Python force the debug library just because we're debugging.
# define DEBUG_UNDEFINED_FROM_WRAP_PYTHON_H
# endif
diff --git a/include/boost/python/module_builder.hpp b/include/boost/python/module_builder.hpp
index 57507e59..6a8a9b4b 100644
--- a/include/boost/python/module_builder.hpp
+++ b/include/boost/python/module_builder.hpp
@@ -18,11 +18,10 @@ namespace boost { namespace python {
class module_builder
{
- typedef PyObject * (*raw_function_ptr)(boost::python::tuple const &, boost::python::dictionary const &);
-
public:
// Create a module. REQUIRES: only one module_builder is created per module.
module_builder(const char* name);
+ ~module_builder();
// Add elements to the module
void add(detail::function* x, const char* name);
@@ -41,13 +40,29 @@ class module_builder
add(detail::new_wrapped_function(fn), name);
}
- static string name();
+ // Return true iff a module is currently being built.
+ static bool initializing();
+ // Return the name of the module currently being built.
+ // REQUIRES: initializing() == true
+ static string name();
+
+ // Return a pointer to the Python module object being built
+ PyObject* module() const;
+
private:
PyObject* m_module;
static PyMethodDef initial_methods[1];
};
+//
+// inline implementations
+//
+inline PyObject* module_builder::module() const
+{
+ return m_module;
+}
+
}} // namespace boost::python
#endif
diff --git a/include/boost/python/operators.hpp b/include/boost/python/operators.hpp
index d0c06895..40400f47 100644
--- a/include/boost/python/operators.hpp
+++ b/include/boost/python/operators.hpp
@@ -1,15 +1,22 @@
#ifndef OPERATORS_UK112000_H_
#define OPERATORS_UK112000_H_
-#include
-#if !defined(__GNUC__) || defined(__SGI_STL_PORT)
-# include
-#else
-# include
-#endif
+# include
+# include
+
+// When STLport is used with native streams, _STL::ostringstream().str() is not
+// _STL::string, but std::string. This confuses to_python(), so we'll use
+// strstream instead. Also, GCC 2.95.2 doesn't have sstream.
+# if defined(__SGI_STL_PORT) ? __SGI_STL_OWN_IOSTREAMS : !defined(__GNUC__) || __GNUC__ > 2
+# include
+# else
+# include
+# endif
namespace boost { namespace python {
+tuple standard_coerce(ref l, ref r);
+
namespace detail {
// helper class for automatic operand type detection
@@ -473,17 +480,15 @@ namespace detail
{
tuple args(ref(arguments, ref::increment_count));
-#if !defined(__GNUC__) || defined(__SGI_STL_PORT)
+// When STLport is used with native streams, _STL::ostringstream().str() is not
+// _STL::string, but std::string.
+#if defined(__SGI_STL_PORT) ? __SGI_STL_OWN_IOSTREAMS : !defined(__GNUC__)
std::ostringstream s;
s << BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type());
+ return BOOST_PYTHON_CONVERSION::to_python(s.str());
#else
std::ostrstream s;
s << BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type()) << char();
-#endif
-
-#if !defined(__GNUC__) || defined(__SGI_STL_PORT)
- return BOOST_PYTHON_CONVERSION::to_python(s.str());
-#else
return BOOST_PYTHON_CONVERSION::to_python(const_cast(s.str()));
#endif
}
diff --git a/release_notes.txt b/release_notes.txt
new file mode 100644
index 00000000..8932a0aa
--- /dev/null
+++ b/release_notes.txt
@@ -0,0 +1,217 @@
+2000-11-22 10:00
+ Ullrich fixed bug in operator_dispatcher.
+
+2000-11-21 10:00
+ Changed all class and function names into lower_case.
+
+ Ullrich updated documentation for operator wrapping.
+
+2000-11-20 10:00
+ Ullrich renamed ExtensionClass:register_coerce() into
+ ExtensionClass:def_standard_coerce() and made it public
+
+ Ullrich improved shared_pod_manager.
+
+2000-11-17 15:04
+ Changed allocation strategy of shared_pod_manager to make it portable.
+
+ Added pickling support + tests thanks to "Ralf W. Grosse-Kunstleve"
+
+
+ Added a specialization of Callback to prevent unsafe usage.
+
+ Fixed Ullrich's operator_dispatcher refcount bug
+
+ Removed const char* return values from virtual functions in tests; that
+ usage was unsafe.
+
+ Ullrich changed Module::add() so that it steals a reference (fix of refcount bug)
+
+ Ullrich added operator_dispatcher::create() optimization
+
+ Ullrich changed design and implementation of TypeObjectBase::enable() (to eliminate low-level
+ code) and added shared_pod_manager optimization.
+
+
+2000-11-15 12:01
+ Fixed refcount bugs in operator calls.
+
+ Added callback_adjust_refcount(PyObject*, Type) to account for different ownership
+ semantics of Callback's return types and Caller's arguments (which both use from_python())
+ This bug caused refcount errors during operator calls.
+
+ Moved operator_dispatcher into extclass.cpp
+ Gave it shared ownership of the objects it wraps
+
+ Introduced sequence points in extension_class_coerce for exception-safety
+
+ UPPER_CASE_MACRO_NAMES
+
+ MixedCase template type argument names
+
+ Changed internal error reporting to use Python exceptions so we don't force the
+ user to link in iostreams code
+
+ Changed error return value of call_cmp to -1
+
+ Moved unwrap_* functions out of operator_dispatcher. This was transitional: when
+ I realized they didn't need to be declared in extclass.h I moved them out, but
+ now that operator_dispatcher itself is in extclass.cpp they could go back in.
+
+ Numerous formatting tweaks
+
+ Updated the BoundFunction::create() optimization and enabled it so it could actually be used!
+
+2000-11-15 00:26
+
+ Made Ullrich's operators support work with MSVC
+
+ Cleaned up operators.h such that invalid define_operator<0> is no longer needed.
+
+ Ullrich created operators.h to support wrapping of C++ operators (including the "__r*__" forms).
+ He added several auxiliary classes to extclass.h and extclass.cpp (most importantly,
+ py::detail::operator_dispatcher and py::operators)
+
+2000-11-13 22:29
+
+ removed obsolete ExtensionClassFromPython for good.
+
+ removed unused class ExtensionType forward declaration
+
+2000-11-12 13:08
+
+ Added enum_as_int_converters for easier enum wrapping
+
+ Introduced new conversion namespace macros:
+ PY_BEGIN_CONVERSION_NAMESPACE,
+ PY_END_CONVERSION_NAMESPACE,
+ PY_CONVERSION
+
+ callback.h, gen_callback.py:
+ Added call() function so that a regular python function (as opposed to
+ method or other function-as-attribute) can be called.
+
+ Added newlines for readability.
+
+ class_wrapper.h:
+ Fixed a bug in add(), which allows non-method class attributes
+
+ Ullrich has added def_raw for simple varargs and keyword support.
+
+ Fixed version number check for __MWERKS__
+
+ Added tests for enums and non-method class attributes
+
+ objects.h/objects.cpp:
+ Added py::String operator*= and operator* for repetition
+
+ Change Dict::items(), keys(), and values() to return a List
+
+ Added template versions of set_item, etc., methods so that users can optionally
+ use C++ types that have to_python() functions as parameters.
+
+ Changed various Ptr by-value parameters to const Ptr&
+
+
+======= Release =======
+2000-11-06 0:22
+ Lots of documentation updates
+
+ added 4-argument template constructor to py::Tuple
+
+ added "add" member function to ClassWrapper<> to allow arbitrary Python
+ objects to be added to an extension class.
+
+ gen_all.py now generates support for n argument member functions and n+1
+ argument member functions at the suggestion of "Ralf W. Grosse-Kunstleve"
+
+
+ Added regression tests and re-ordered declare_base calls to verify that the
+ phantom base class issue is resolved.
+
+2000-11-04 17:35
+
+ Integrated Ullrich Koethe's brilliant from_python_experiment for better
+ error-reporting in many cases.
+
+ extclass.h, gen_extclass.py:
+ removed special-case MSVC code
+ added much commentary
+ removed unused py_copy_to_new_value_holder
+
+ init_function.h, gen_init_function.py:
+ added missing 'template' keyword on type-dependent template member usage
+ removed special-case MSVC code
+ added much commentary
+
+2000-11-04 0:36
+
+ Removed the need for the phantom base class that screwed up inheritance
+ hierarchies, introduced error-prone ordering dependencies, and complexified
+ logic in many places!
+
+ extclass.h: Added some explanatory comments, removed wasteful m_self member
+ of HeldInstance
+
+ extclass_demo.cpp: Added #pragmas which allow compilation in ansi strict
+ mode under Metrowerks
+
+ functions.h: Added virtual_function as part of phantom base class removal;
+ expanded commentary
+
+ pyptr.h: Added some missing 'typename's and a GCC workaround fix
+
+ subclass.cpp: Added missing string literal const_cast<>s.
+
+2000-11-03 10:58
+
+ Fix friend function instantiation bug caught by Metrowerks (thanks
+ Metrowerks!)
+
+ Add proof-of-concept for one technique of wrapping function that return a
+ pointer
+
+ Worked around MSVC optimizer bug by writing to_python(double) and
+ to_python(float) out-of-line
+
+2000-11-02 23:25
+
+ Add /Zm200 option to vc6_prj to deal with MSVC resource limitations
+
+ Remove conflicting /Ot option from vc6_prj release build
+
+======= Release =======
+2000-11-02 17:42
+
+ Added a fix for interactions between default virtual function
+ implementations and declare_base(). You still need to write your
+ declare_base() /after/ all member functions have been def()d for the two
+ classes concerned. Many, many thanks to Ullrich Koethe
+ for all his work on this.
+
+ Added missing conversions:
+ to_python(float)
+ from_python(const char* const&)
+ from_python(const double&)
+ from_python(const float&)
+
+ Added a Regression test for a reference-counting bug thanks to Mark Evans
+ ()
+
+ const-ify ClassBase::getattr()
+
+ Add repr() function to Class
+
+ Add to_python/from_python conversions for PyPtr
+
+ Standardize set_item/get_item interfaces (instead of proxies) for Dict and List
+
+ Add Reprable<> template to newtypes.h
+
+ Fix a bug wherein the __module__ attribute would be lost for classes that have a
+ default virtual function implementation.
+
+ Remove extra ';' in module.cpp thanks to "Ralf W. Grosse-Kunstleve"
+
+
+ Fix a bug in the code of example1.html
diff --git a/src/classes.cpp b/src/classes.cpp
index 34b42c22..2901aa81 100644
--- a/src/classes.cpp
+++ b/src/classes.cpp
@@ -840,7 +840,27 @@ namespace {
void add_current_module_name(dictionary& name_space)
{
static string module_key("__module__", string::interned);
- name_space.set_item(module_key, module_builder::name());
+
+ // If the user didn't specify a __module__ attribute already
+ if (name_space.get_item(module_key).get() == 0)
+ {
+ if (module_builder::initializing())
+ {
+ // The global __name__ is not properly set in this case
+ name_space.set_item(module_key, module_builder::name());
+ }
+ else
+ {
+ // Get the module name from the global __name__
+ PyObject *globals = PyEval_GetGlobals();
+ if (globals != NULL)
+ {
+ PyObject *module_name = PyDict_GetItemString(globals, "__name__");
+ if (module_name != NULL)
+ name_space.set_item(module_key, module_name);
+ }
+ }
+ }
}
}
diff --git a/src/extension_class.cpp b/src/extension_class.cpp
index cde3d836..c15e538b 100644
--- a/src/extension_class.cpp
+++ b/src/extension_class.cpp
@@ -46,24 +46,19 @@ BOOST_PYTHON_END_CONVERSION_NAMESPACE
namespace boost { namespace python {
-namespace detail {
+tuple standard_coerce(ref l, ref r)
+{
+ // Introduced sequence points for exception-safety.
+ ref first(detail::operator_dispatcher::create(l, l));
+
+ ref second(r->ob_type == &detail::operator_dispatcher::type_obj
+ ? r
+ : ref(detail::operator_dispatcher::create(r, ref())));
- tuple extension_class_coerce(ref l, ref r)
- {
- // Introduced sequence points for exception-safety.
- ref first(operator_dispatcher::create(l, l));
- ref second;
-
- if(r->ob_type == &operator_dispatcher::type_obj)
- {
- second = r;
- }
- else
- {
- second = ref(operator_dispatcher::create(r, ref()));
- }
- return boost::python::tuple(first, second);
- }
+ return tuple(first, second);
+}
+
+namespace detail {
enum { unwrap_exception_code = -1000 };
diff --git a/src/gen_extclass.py b/src/gen_extclass.py
index 5180a3de..f8906970 100644
--- a/src/gen_extclass.py
+++ b/src/gen_extclass.py
@@ -707,8 +707,6 @@ class extension_instance : public instance
// Template function implementations
//
-tuple extension_class_coerce(ref l, ref r);
-
template
extension_class::extension_class()
: extension_class_base(typeid(T).name())
@@ -729,7 +727,7 @@ void extension_class::def_standard_coerce()
ref coerce_fct = dict().get_item(string("__coerce__"));
if(coerce_fct.get() == 0) // not yet defined
- this->def(&extension_class_coerce, "__coerce__");
+ this->def(&standard_coerce, "__coerce__");
}
template
diff --git a/src/module_builder.cpp b/src/module_builder.cpp
index ea00b71c..57eec75f 100644
--- a/src/module_builder.cpp
+++ b/src/module_builder.cpp
@@ -14,10 +14,15 @@ namespace {
ref name_holder;
}
+bool module_builder::initializing()
+{
+ return name_holder.get() != 0;
+}
+
string module_builder::name()
{
// If this fails, you haven't created a module_builder object
- assert(name_holder.get() != 0);
+ assert(initializing());
return string(name_holder);
}
@@ -29,6 +34,11 @@ module_builder::module_builder(const char* name)
name_holder = ref(PyObject_GetAttrString(m_module, const_cast("__name__")));
}
+module_builder::~module_builder()
+{
+ name_holder.reset();
+}
+
void
module_builder::add(detail::function* x, const char* name)
{
diff --git a/test/comprehensive.cpp b/test/comprehensive.cpp
index cae924e6..7fad74bb 100644
--- a/test/comprehensive.cpp
+++ b/test/comprehensive.cpp
@@ -11,7 +11,7 @@
#include // for pow()
#include
-namespace extclass_demo {
+namespace bpl_test {
FooCallback::FooCallback(PyObject* self, int x)
: Foo(x), m_self(self)
@@ -714,12 +714,14 @@ const Record* get_record()
return &v;
}
-template class boost::python::class_builder; // explicitly instantiate
+} // namespace bpl_test
-} // namespace extclass_demo
+namespace boost { namespace python {
+ template class class_builder; // explicitly instantiate
+}} // namespace boost::python
BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-inline PyObject* to_python(const extclass_demo::Record* p)
+inline PyObject* to_python(const bpl_test::Record* p)
{
return to_python(*p);
}
@@ -731,7 +733,7 @@ BOOST_PYTHON_END_CONVERSION_NAMESPACE
/* */
/************************************************************/
-namespace extclass_demo {
+namespace bpl_test {
struct EnumOwner
{
@@ -753,8 +755,8 @@ struct EnumOwner
}
namespace boost { namespace python {
- template class enum_as_int_converters;
- using extclass_demo::pow;
+ template class enum_as_int_converters;
+ using bpl_test::pow;
}} // namespace boost::python
// This is just a way of getting the converters instantiated
@@ -763,7 +765,7 @@ namespace boost { namespace python {
//{
//};
-namespace extclass_demo {
+namespace bpl_test {
/************************************************************/
/* */
@@ -1036,7 +1038,7 @@ void init_module(boost::python::module_builder& m)
world_class.def(world_setstate, "__setstate__");
}
-PyObject* raw(boost::python::tuple const& args, boost::python::dictionary const& keywords)
+PyObject* raw(const boost::python::tuple& args, const boost::python::dictionary& keywords)
{
if(args.size() != 2 || keywords.size() != 2)
{
@@ -1055,21 +1057,21 @@ PyObject* raw(boost::python::tuple const& args, boost::python::dictionary const&
void init_module()
{
- boost::python::module_builder demo("demo");
- init_module(demo);
+ boost::python::module_builder test("test");
+ init_module(test);
// Just for giggles, add a raw metaclass.
- demo.add(new boost::python::meta_class);
+ test.add(new boost::python::meta_class);
}
extern "C"
#ifdef _WIN32
__declspec(dllexport)
#endif
-void initdemo()
+void inittest()
{
try {
- extclass_demo::init_module();
+ bpl_test::init_module();
}
catch(...) {
boost::python::handle_exception();
@@ -1083,7 +1085,7 @@ CompareIntPairPythonClass::CompareIntPairPythonClass(boost::python::module_build
def(&CompareIntPair::operator(), "__call__");
}
-} // namespace extclass_demo
+} // namespace bpl_test
#if defined(_WIN32)
@@ -1124,7 +1126,7 @@ BOOL WINAPI DllMain(
switch(fdwReason)
{
case DLL_PROCESS_DETACH:
- assert(extclass_demo::total_Ints == 0);
+ assert(bpl_test::total_Ints == 0);
}
#endif
diff --git a/test/comprehensive.hpp b/test/comprehensive.hpp
index d8a8e8ea..ed90f061 100644
--- a/test/comprehensive.hpp
+++ b/test/comprehensive.hpp
@@ -6,8 +6,8 @@
// The author gratefully acknowleges the support of Dragon Systems, Inc., in
// producing this work.
-#ifndef EXTCLASS_DEMO_DWA052200_H_
-# define EXTCLASS_DEMO_DWA052200_H_
+#ifndef BPL_TEST_DWA052200_H_
+# define BPL_TEST_DWA052200_H_
//
// Example code demonstrating extension class usage
//
@@ -21,7 +21,7 @@
# include
# include
py_cpp*
-