This commit was manufactured by cvs2svn to create tag

'version_0-9-26'.

[SVN r20128]

build/bpl_static.dsp

@@ -1,216 +0,0 @@
-# Microsoft Developer Studio Project File - Name="bpl_static" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Static Library" 0x0104
-
-CFG=bpl_static - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE 
-!MESSAGE NMAKE /f "bpl_static.mak".
-!MESSAGE 
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "bpl_static.mak" CFG="bpl_static - Win32 Debug"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "bpl_static - Win32 Release" (based on "Win32 (x86) Static Library")
-!MESSAGE "bpl_static - Win32 Debug" (based on "Win32 (x86) Static Library")
-!MESSAGE 
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "bpl_static - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /MD /W4 /WX /GR /GX /O2 /I "..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /FR /YX /FD /c
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-
-!ELSEIF  "$(CFG)" == "bpl_static - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ  /c
-# ADD CPP /nologo /MDd /W4 /WX /Gm /GR /GX /ZI /Od /I "..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /FR /YX /FD /GZ  /c
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LIB32=link.exe -lib
-# ADD BASE LIB32 /nologo
-# ADD LIB32 /nologo
-
-!ENDIF 
-
-# Begin Target
-
-# Name "bpl_static - Win32 Release"
-# Name "bpl_static - Win32 Debug"
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=..\src\classes.cpp
-# ADD CPP /W3
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\conversions.cpp
-# ADD CPP /W3
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\extension_class.cpp
-# ADD CPP /W3
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\functions.cpp
-# ADD CPP /W3
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\init_function.cpp
-# ADD CPP /W3
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\module_builder.cpp
-# ADD CPP /W3
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\objects.cpp
-# ADD CPP /W3
-# End Source File
-# Begin Source File
-
-SOURCE=..\src\types.cpp
-# ADD CPP /W3
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx;hm;inl"
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\detail\base_object.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\callback.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\caller.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\detail\cast.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\class_builder.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\classes.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\detail\config.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\conversions.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\errors.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\detail\extension_class.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\detail\functions.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\detail\init_function.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\module_builder.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\detail\none.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\objects.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\operators.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\reference.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\detail\signatures.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\detail\singleton.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\detail\types.hpp
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\..\boost\python\detail\wrap_python.hpp
-# End Source File
-# End Group
-# End Target
-# End Project

build/build.dsw

@@ -1,74 +0,0 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "bpl_static"=.\bpl_static.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Project: "example1"=.\example1\example1.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-    Begin Project Dependency
-    Project_Dep_Name bpl_static
-    End Project Dependency
-}}}
-
-###############################################################################
-
-Project: "rwgk1"=.\rwgk1\rwgk1.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-    Begin Project Dependency
-    Project_Dep_Name bpl_static
-    End Project Dependency
-}}}
-
-###############################################################################
-
-Project: "test"=.\test\test.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-    Begin Project Dependency
-    Project_Dep_Name bpl_static
-    End Project Dependency
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-

build/como.mak

@@ -1,51 +0,0 @@
-LIBSRC = \
-    classes.cpp \
-    conversions.cpp \
-    extension_class.cpp \
-    functions.cpp \
-    init_function.cpp \
-    module_builder.cpp \
-    objects.cpp \
-    types.cpp
-        
-LIBOBJ = $(LIBSRC:.cpp=.o)
-OBJ = $(LIBOBJ)
-
-
-ifeq "$(OS)" "Windows_NT"
-PYTHON_LIB=c:/tools/python/libs/python15.lib
-INC = -Ic:/cygnus/usr/include/g++-3 -Ic:/cygnus/usr/include -Ic:/boost -Ic:/tools/python/include
-MODULE_EXTENSION=dll
-else
-INC = -I/usr/local/include/python1.5
-MODULE_EXTENSION=so
-endif
-
-%.o: ../src/%.cpp
-	como --pic $(INC) -o $*.o -c $<
-
-%.d: ../src/%.cpp
-	@echo creating $@
-	@set -e; como -M $(INC) -c $< \
-            | sed 's/\($*\)\.o[ :]*/\1.o $@ : /g' > $@; \
-                [ -s $@ ] || rm -f $@
-
-example1: example1.o libpycpp.a
-	como-dyn-link -o ../example/hellomodule.$(MODULE_EXTENSION) $(PYHTON_LIB) example1.o -L. -lpycpp
-	python ../example/test_example1.py
-
-example1.o: ../example/example1.cpp
-	como --pic $(INC) -o $*.o -c $<
-
-clean:
-	rm -rf *.o *.$(MODULE_EXTENSION) *.a *.d *.pyc *.bak a.out
-
-libpycpp.a: $(LIBOBJ)
-	rm -f libpycpp.a
-	ar cq libpycpp.a $(LIBOBJ)
-
-DEP = $(OBJ:.o=.d)
-
-ifneq "$(MAKECMDGOALS)" "clean"
-include $(DEP)
-endif

build/example1/example1.dsp

@@ -1,107 +0,0 @@
-# Microsoft Developer Studio Project File - Name="example1" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
-
-CFG=example1 - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE 
-!MESSAGE NMAKE /f "example1.mak".
-!MESSAGE 
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "example1.mak" CFG="example1 - Win32 Debug"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "example1 - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "example1 - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE 
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-MTL=midl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "example1 - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /YX /FD /c
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /out:"Release/hello.dll" /libpath:"c:\tools\python\libs"
-
-!ELSEIF  "$(CFG)" == "example1 - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /YX /FD /GZ  /c
-# ADD CPP /nologo /MDd /W3 /Gm /GR /GX /ZI /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "EXAMPLE1_EXPORTS" /YX /FD /GZ  /c
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /out:"Debug/hello.dll" /pdbtype:sept /libpath:"c:\tools\python\libs"
-
-!ENDIF 
-
-# Begin Target
-
-# Name "example1 - Win32 Release"
-# Name "example1 - Win32 Debug"
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=..\..\example\example1.cpp
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx;hm;inl"
-# End Group
-# Begin Group "Resource Files"
-
-# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
-# End Group
-# End Target
-# End Project

build/gcc.mak

@@ -1,53 +0,0 @@
-LIBSRC = \
-    classes.cpp \
-    conversions.cpp \
-    extension_class.cpp \
-    functions.cpp \
-    init_function.cpp \
-    module_builder.cpp \
-    objects.cpp \
-    types.cpp
-
-LIBOBJ = $(LIBSRC:.cpp=.o)
-OBJ = $(LIBOBJ)
-
-
-ifeq "$(OS)" "Windows_NT"
-PYTHON_LIB=c:/tools/python/libs/python15.lib
-INC = -Ic:/cygnus/usr/include/g++-3 -Ic:/cygnus/usr/include -Ic:/boost -Ic:/tools/python/include
-MODULE_EXTENSION=dll
-else
-INC = -I/usr/local/include/python1.5
-MODULE_EXTENSION=so
-endif
-
-%.o: ../src/%.cpp
-	g++ -fPIC -Wall -W $(INC) -o $*.o -c $<
-
-%.d: ../src/%.cpp
-	@echo creating $@
-	@set -e; g++ -M $(INC) -c $< \
-            | sed 's/\($*\)\.o[ :]*/\1.o $@ : /g' > $@; \
-                [ -s $@ ] || rm -f $@
-
-
-example1: example1.o libpycpp.a
-	g++ -shared -o ../example/hellomodule.$(MODULE_EXTENSION) $(PYHTON_LIB) example1.o -L. -lpycpp
-	python ../example/test_example1.py
-
-example1.o: ../example/example1.cpp
-	g++ -fPIC -Wall -W $(INC) -o $*.o -c $<
-
-
-clean:
-	rm -rf *.o *.$(MODULE_EXTENSION) *.a *.d *.pyc *.bak a.out
-
-libpycpp.a: $(LIBOBJ)
-	rm -f libpycpp.a
-	ar cq libpycpp.a $(LIBOBJ)
-
-DEP = $(OBJ:.o=.d)
-
-ifneq "$(MAKECMDGOALS)" "clean"
-include $(DEP)
-endif

build/rwgk1/rwgk1.dsp

@@ -1,105 +0,0 @@
-# Microsoft Developer Studio Project File - Name="rwgk1" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
-
-CFG=rwgk1 - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE 
-!MESSAGE NMAKE /f "rwgk1.mak".
-!MESSAGE 
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "rwgk1.mak" CFG="rwgk1 - Win32 Debug"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "rwgk1 - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "rwgk1 - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE 
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-MTL=midl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "rwgk1 - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "RWGK1_EXPORTS" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "RWGK1_EXPORTS" /YX /FD /c
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /libpath:"c:\tools\python\libs"
-
-!ELSEIF  "$(CFG)" == "rwgk1 - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "RWGK1_EXPORTS" /YX /FD /GZ /c
-# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "RWGK1_EXPORTS" /YX /FD /GZ /c
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept /libpath:"c:\tools\python\libs"
-
-!ENDIF 
-
-# Begin Target
-
-# Name "rwgk1 - Win32 Release"
-# Name "rwgk1 - Win32 Debug"
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=..\..\example\rwgk1.cpp
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx;hm;inl"
-# End Group
-# Begin Group "Resource Files"
-
-# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
-# End Group
-# End Target
-# End Project

build/test/test.dsp

@@ -1,112 +0,0 @@
-# Microsoft Developer Studio Project File - Name="test" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
-
-CFG=test - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE 
-!MESSAGE NMAKE /f "test.mak".
-!MESSAGE 
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "test.mak" CFG="test - Win32 Debug"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "test - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "test - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE 
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-MTL=midl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "test - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /YX /FD /c
-# ADD CPP /nologo /MD /W3 /GR /GX /O2 /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /YX /FD /Zm200 /c
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "NDEBUG"
-# ADD RSC /l 0x409 /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386 /libpath:"c:\tools\python\libs"
-
-!ELSEIF  "$(CFG)" == "test - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /YX /FD /GZ  /c
-# ADD CPP /nologo /MDd /W3 /Gm /GR /GX /ZI /Od /I "..\..\..\.." /I "c:\tools\python\include" /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "TEST_EXPORTS" /YX /FD /GZ /Zm200 /c
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x409 /d "_DEBUG"
-# ADD RSC /l 0x409 /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept /libpath:"c:\tools\python\libs"
-# SUBTRACT LINK32 /pdb:none
-
-!ENDIF 
-
-# Begin Target
-
-# Name "test - Win32 Release"
-# Name "test - Win32 Debug"
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=..\..\test\comprehensive.cpp
-# End Source File
-# End Group
-# Begin Group "Header Files"
-
-# PROP Default_Filter "h;hpp;hxx;hm;inl"
-# Begin Source File
-
-SOURCE=..\..\test\comprehensive.hpp
-# End Source File
-# End Group
-# Begin Group "Resource Files"
-
-# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
-# End Group
-# End Target
-# End Project

build/tru64.mak

@@ -1,51 +0,0 @@
-#
-# Tested with:
-# Compaq C++ V6.2-024 for Digital UNIX V5.0 (Rev. 910)
-#
-# Python 1.5.2 was installed without any customizations.
-# boost_all.zip vers. 1.18.1 was unpacked using unzip -aa and not modified.
-# STLport-4.1b3 was unpacked using unzip -aa and not modified.
-#
-# Initial version 2000-10-20: Ralf W. Grosse-Kunstleve, rwgk@cci.lbl.gov
-#
-
-PYINC= /usr/local/include/python1.5
-BOOSTINC= /usr/local/boost_1_18_1
-STLPORTINC= /usr/local/STLport-4.1b3/stlport
-STLPORTOPTS= \
- -D__USE_STD_IOSTREAM \
- -D__STL_NO_SGI_IOSTREAMS \
- -D__STL_NO_NEW_C_HEADERS \
- -D_RWSTD_COMPILE_INSTANTIATE=1
-
-STDOPTS= -std strict_ansi
-WARNOPTS= -msg_disable 186,450,1115
-# use -msg_display_number to obtain integer tags for -msg_disable
-
-CPP= cxx
-CPPOPTS= -I$(STLPORTINC) $(STLPORTOPTS) -I$(BOOSTINC) -I$(PYINC) \
-         $(STDOPTS) $(WARNOPTS)
-
-LD= cxx
-LDOPTS= -shared -expect_unresolved '*'
-
-OBJ = extclass.o functions.o init_function.o module.o newtypes.o \
-      objects.o py.o subclass.o
-
-.SUFFIXES: .o .cpp
-
-all: demo.so hello.so
-
-demo.so: $(OBJ) extclass_demo.o
-	$(LD) $(LDOPTS) $(OBJ) extclass_demo.o -o demo.so
-
-hello.so: $(OBJ) example1.o
-	$(LD) $(LDOPTS) $(OBJ) example1.o -o hello.so
-
-.cpp.o:
-	-$(CPP) $(CPPOPTS) $(INC) -c $*.cpp
-
-clean:
-	rm -f $(OBJ) extclass_demo.o example1.o demo.so hello.so so_locations
-	rm -rf cxx_repository
-	rm -f *.pyc

doc/building.html

@@ -1,44 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
-"http://www.w3.org/TR/REC-html40/strict.dtd">
-    <title>
-      Building an Extension Module
-    </title>
-    <div>
-      <h1>
-         <img width="277" height="86" id="_x0000_i1025" align="center"
-        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)">Building an Extension Module
-      </h1>
-      <p>
-         Right now, the only supported configuration is one in which the BPL
-         source files are statically linked with the source for your extension
-         module. You may first build them into a library and link it with your
-         extension module source, but the effect is the same as compiling all
-         the source files together. Some users have successfully built the
-         sources into a shared library, and support for a shared library
-         build is planned, but not yet implemented. The BPL source files are:
-<blockquote>
-<pre>
-<a href="../../../libs/python/src/extension_class.cpp">extclass.cpp</a>
-<a href="../../../libs/python/src/functions.cpp">functions.cpp</a>
-<a href="../../../libs/python/src/init_function.cpp">init_function.cpp</a>
-<a href="../../../libs/python/src/module_builder.cpp">module.cpp</a>
-<a href="../../../libs/python/src/types.cpp">newtypes.cpp</a>
-<a href="../../../libs/python/src/objects.cpp">objects.cpp</a>
-<a href="../../../libs/python/src/conversions.cpp">py.cpp</a>
-<a href="../../../libs/python/src/classes.cpp">subclass.cpp</a>
-         </pre>
-         </blockquote>
-               <p>
-         Next: <a href="enums.html">Enums</a>
-         Previous: <a href="under-the-hood.html">A Peek Under the Hood</a>
-         Up: <a href="index.html">Top</a>
-      <p>
-         &copy; Copyright David Abrahams 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 warranty, and with no claim as to
-        its suitability for any purpose.
-      <p>
-         Updated: Nov 26, 2000
-    </div>
-

doc/comparisons.html

@@ -1,220 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
-"http://www.w3.org/TR/REC-html40/strict.dtd">
-    <title>
-      Comparisons with Other Systems
-    </title>
-    <div>
-      <h1>
-         <img width="277" height="86" id="_x0000_i1025" align="center"
-        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)">Comparisons with
-        Other Systems
-      </h1>
-      
-      <h2>CXX</h2>
-      <p>
-        Like BPL, <a href="http://cxx.sourceforge.net/">CXX</a> attempts to
-        provide a C++-oriented interface to Python. In most cases, as with the
-        boost library, it relieves the user from worrying about
-        reference-counts. Both libraries automatically convert thrown C++
-        exceptions into Python exceptions. As far as I can tell, CXX has no
-        support for subclassing C++ extension types in Python. An even
-        more significant difference is that a user's C++ code is still basically
-        ``dealing with Python objects'', though they are wrapped in
-        C++ classes. This means such jobs as argument parsing and conversion are
-        still left to be done explicitly by the user.
-
-     <p>
-        CXX claims to interoperate well with the C++ Standard Library
-        (a.k.a. STL) by providing iterators into Python Lists and Dictionaries,
-        but the claim is unfortunately unsupportable. The problem is that in
-        general, access to Python sequence and mapping elements through
-        iterators requires the use of proxy objects as the return value of
-        iterator dereference operations. This usage conflicts with the basic
-        ForwardIterator requirements in <a
-        href="http://anubis.dkuug.dk/jtc1/sc22/open/n2356/lib-iterators.html#lib.forward.iterators">
-        section 24.1.3 of the standard</a> (dereferencing must produce a
-        reference). Although you may be able to use these iterators with some
-        operations in some standard library implementations, it is neither
-        guaranteed to work nor portable.
-
-      <p>
-        As far as I can tell, CXX enables one to write what is essentially
-        idiomatic Python code in C++, manipulating Python objects through the
-        same fully-generic interfaces we use in Python. While you're hardly programming directly to the ``bare
-        metal'' with CXX, it basically presents a ``C++-ized''
-        version of the Python 'C' API.
-
-      <p>
-        <a href="mailto:dubois1@llnl.gov">Paul F. Dubois</a>, the original
-        author of CXX, has told me that what I've described is only half of the
-        picture with CXX, but I never understood his explanation well-enough to
-        fill in the other half. Here is his response to the commentary above:
-
-<blockquote>
-``My intention with CXX was not to do what you are doing. It was to enable a
-person to write an extension directly in C++ rather than C. I figured others had
-the wrapping business covered. I thought maybe CXX would provide an easier
-target language for those making wrappers, but I never explored
-that.''<br><i>-<a href="mailto:dubois1@llnl.gov">Paul Dubois</a></i>
-</blockquote>
-
-      <h2>SWIG</h2>
-      <p>
-        <a href= "http://www.swig.org/">SWIG</a> is an impressively mature tool
-        for exporting an existing ANSI 'C' interface into various scripting
-        languages. Swig relies on a parser to read your source code and produce
-        additional source code files which can be compiled into a Python (or
-        Perl or Tcl) extension module. It has been successfully used to create
-        many Python extension modules. Like BPL, SWIG is trying to allow an
-        existing interface to be wrapped with little or no change to the
-        existing code. The documentation says ``SWIG parses a form of ANSI C
-        syntax that has been extended with a number of special directives. As a
-        result, interfaces are usually built by grabbing a header file and
-        tweaking it a little bit.'' For C++ interfaces, the tweaking has often
-        proven to amount to more than just a little bit. One user
-        writes:
-
-        <blockquote> ``The problem with swig (when I used it) is that it
-        couldnt handle templates, didnt do func overloading properly etc.  For
-        ANSI C libraries this was fine.  But for usual C++ code this was a
-        problem.  Simple things work.  But for anything very complicated (or
-        realistic), one had to write code by hand.  I believe BPL doesn't have
-        this problem[<a href="#sic">sic</a>]...  IMHO overloaded functions are very important to
-        wrap correctly.''<br><i>-Prabhu Ramachandran</i>
-        </blockquote>
-        
-      <p>
-        By contrast, BPL doesn't attempt to parse C++ - the problem is simply
-        too complex to do correctly. <a name="sic">Technically</a>, one does
-        write code by hand to use BPL. The goal, however, has been to make
-        that code nearly as simple as listing the names of the classes and
-        member functions you want to expose in Python.
-
-      <h2>SIP</h2> 
-      <p>
-        <a
-        href="http://www.thekompany.com/projects/pykde/background.php3?dhtml_ok=1">SIP</a>
-        is a system similar to SWIG, though seemingly more
-        C++-oriented. The author says that like BPL, SIP supports overriding
-        extension class member functions in Python subclasses. It appears to
-        have been designed specifically to directly support some features of
-        PyQt/PyKDE, which is its primary client. Documentation is almost
-        entirely missing at the time of this writing, so a detailed comparison
-        is difficult.
-
-      <h2>ILU</h2>
-      <p>
-        <a
-        href="http://www.cl.cam.ac.uk/Research/Rainbow/projects/origami/ilu-1.8-manual">ILU</a>
-        is a very ambitious project which tries to describe a module's interface
-        (types and functions) in terms of an <a
-        href="http://www.cl.cam.ac.uk/Research/Rainbow/projects/origami/ilu-1.8-manual/manual_2.html">Interface
-        Specification Language</a> (ISL) so that it can be uniformly interfaced
-        to a wide range of computer languages, including Common Lisp, C++, C,
-        Modula-3, and Python. ILU can parse the ISL to generate a C++ language
-        header file describing the interface, of which the user is expected to
-        provide an implementation. Unlike BPL, this means that the system
-        imposes implementation details on your C++ code at the deepest level. It
-        is worth noting that some of the C++ names generated by ILU are supposed
-        to be reserved to the C++ implementation. It is unclear from the
-        documentation whether ILU supports overriding C++ virtual functions in Python.
-        
-      <h2>GRAD</h2>
-      <p>
-      <a
-      href="http://www.python.org/workshops/1996-11/papers/GRAD/html/GRADcover.html">GRAD</a>
-      is another very ambitious project aimed at generating Python wrappers for
-      interfaces written in ``legacy languages'', among which C++ is the first one
-      implemented. Like SWIG, it aims to parse source code and automatically
-      generate wrappers, though it appears to take a more sophisticated approach
-      to parsing in general and C++ in particular, so it should do a much better
-      job with C++. It appears to support function overloading. The
-      documentation is missing a lot of information I'd like to see, so it is
-      difficult to give an accurate and fair assessment. I am left with the
-      following questions:
-<ul>
-<li>Does it support overriding of virtual functions?
-<li>What about overriding private or protected virtual functions (the documentation indicates
-that only public interfaces are supported)?
-<li>Which C++ language constructs are supportd?
-<li>Does it support implicit conversions between wrapped C++ classes that have
-an inheritance relationship?
-<li>Does it support smart pointers?
-</ul>
-      <p>
-        Anyone in the possession of the answers to these questions will earn my
-        gratitude for a write-up <code>;-)</code>
-
-      <h2>Zope ExtensionClasses</h2>
-      <p>
-         <a href="http:http://www.digicool.com/releases/ExtensionClass">
-        ExtensionClasses in Zope</a> use the same underlying mechanism as BPL
-        to support subclassing of extension types in Python, including
-        multiple-inheritance. Both systems support pickling/unpickling of
-        extension class instances in very similar ways. Both systems rely on the
-        same ``<a
-        href="http://www.python.org/workshops/1994-11/BuiltInClasses/Welcome.html">Don
-        Beaudry Hack</a>'' that also inspired Don's MESS System.
-      <p>
-        The major differences are:
-      <ul>
-        <li>
-          BPL lifts the burden on the user to parse and convert function
-          argument types. Zope provides no such facility.
-        <li>
-          BPL lifts the burden on the user to maintain Python
-          reference-counts.
-        <li>
-          BPL supports function overloading; Zope does not.
-        <li>
-          BPL supplies a simple mechanism for exposing read-only and
-          read/write access to data members of the wrapped C++ type as Python
-          attributes.
-        <li>
-          Writing a Zope ExtensionClass is significantly more complex than
-          exposing a C++ class to python using BPL (mostly a summary of the
-          previous 4 items). <a href= 
-          "http://www.digicool.com/releases/ExtensionClass/MultiMapping.html">A
-          Zope Example</a> illustrates the differences.
-        <li>
-          Zope's ExtensionClasses are specifically motivated by ``the need for a
-          C-based persistence mechanism''. BPL's are motivated by the desire
-          to simply reflect a C++ API into Python with as little modification as
-          possible.
-        <li>
-          The following Zope restriction does not apply to BPL: ``At most one
-          base extension direct or indirect super class may define C data
-          members. If an extension subclass inherits from multiple base
-          extension classes, then all but one must be mix-in classes that
-          provide extension methods but no data.''
-        <li>
-          Zope requires use of the somewhat funky inheritedAttribute (search for
-          ``inheritedAttribute'' on <a
-          href="http://www.digicool.com/releases/ExtensionClass">this page</a>)
-          method to access base class methods. In BPL, base class methods can
-          be accessed in the usual way by writing
-          ``<code>BaseClass.method</code>''.
-        <li>
-          Zope supplies some creative but esoteric idioms such as <a href= 
-          "http://www.digicool.com/releases/ExtensionClass/Acquisition.html">
-          Acquisition</a>. No specific support for this is built into BPL.
-        <li>
-          Zope's ComputedAttribute support is designed to be used from Python.
-          <a href="special.html#getter_setter">The analogous feature of
-          BPL</a> can be used from C++ or Python. The feature is arguably
-          easier to use in BPL.
-      </ul>
-      <p>
-        Next: <a href="example1.html">A Simple Example Using BPL</a>
-        Previous: <a href="extending.html">A Brief Introduction to writing Python Extension Modules</a>
-        Up: <a href="index.html">Top</a>
-      <p>
-         &copy; Copyright David Abrahams 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 warranty, and with no claim as to its suitability
-        for any purpose.
-      <p>
-         Updated: Nov 26, 2000
-    </div>
-

doc/data_structures.txt

@@ -1,192 +0,0 @@
-Given a real Python class 'A', a wrapped C++ class 'B', and this definition:
-
-    class C(A, B):
-        def __init__(self):
-            B.__init__(self)
-            self.x = 1
-        ...
-
-    c = C()
-
-this diagram describes the internal structure of an instance of 'C', including
-its inheritance relationships. Note that ExtensionClass<B> is derived from
-Class<ExtensionInstance>, and is in fact identical for all intents and purposes.
-
-                                           MetaClass<ExtensionInstance>
-                 +---------+              +---------+                  
-types.ClassType: |         |              |         |                  
-                 |         |              |         |                  
-                 |         |              |         |                  
-                 +---------+              +---------+                    
-                   ^                         ^   ^
-     PyClassObject |       ExtensionClass<B> |   |
- A: +------------+ |   B: +------------+     |   |
-    |  ob_type  -+-+      |   ob_type -+-----+   |
-    |            |   ()<--+- __bases__ |         |
-    |            |        |  __dict__ -+->{...}  |
-    |            |   'B'<-+- __name__  |         |
-    +------------+        +------------+         |
-         ^                      ^                |
-         |                      |                |
-         +-----+  +-------------+                |
-               |  |                              |
-               |  |     Class<ExtensionInstance> |
-               |  | C: +------------+            |
-               |  |    |   ob_type -+------------+
-        tuple:(*, *)<--+- __bases__ |           
-                       |  __dict__ -+->{__module__, <methods, etc.>}
-                 'C' <-+- __name__  |
-                       +------------+        
-                             ^           (in case of inheritance from more than one   
-                             |            extension class, this vector would contain  
-             +---------------+            a pointer to an instance holder for the data
-             |                            of each corresponding C++ class)            
-             |     ExtensionInstance                
-             | c: +---------------------+   std::vector<InstanceHolderBase> 
-             +----+- __class__          |  +---+--  
-                  |  m_wrapped_objects -+->| * | ...
-        {'x': 1}<-+- __dict__           |  +-|-+--   
-                  +---------------------+    |    InstanceValueHolder<B>                  
-                                             |   +--------------------------------+
-                                             +-->| (contains a C++ instance of B) |
-                                                 +--------------------------------+
-
-
-
-
-
-
-In our inheritance test cases in extclass_demo.cpp/test_extclass.py, we have the
-following C++ inheritance hierarchy:
-
-               +-----+          +----+
-               |  A1 |          | A2 |
-               +-----+          +----+
-                ^ ^ ^            ^  ^  
-                | | |            |  |
-          +-----+ | +---------+-----+
-          |       |           |  |
-          |       +---+----------+
-   .......!......     |       |
-   : A_callback :   +-+--+  +-+--+
-   :............:   | B1 |  | B2 |
-                    +----+  +----+
-                      ^
-                      |
-              +-------+---------+
-              |                 |
-            +-+-+         ......!.......
-            | C |         : B_callback :
-            +---+         :............:
-
-
-A_callback and B_callback are used as part of the wrapping mechanism but not
-represented in Python. C is also not represented in Python but is delivered
-there polymorphically through a smart pointer.
-
-This is the data structure in Python.
-
-       ExtensionClass<A1>
-  A1: +------------+                
- ()<--+- __bases__ |                                                
-      |  __dict__ -+->{...}                                         
-      +------------+                                                
-        ^                 
-        |          ExtensionInstance                                              
-        |     a1: +---------------------+   vec     InstanceValueHolder<A1,A_callback> 
-        +---------+- __class__          |  +---+   +---------------------+ 
-        |         |  m_wrapped_objects -+->| *-+-->| contains A_callback | 
-        |         +---------------------+  +---+   +---------------------+              
-        |   
-        |          ExtensionInstance                                              
-        | pa1_a1: +---------------------+   vec     InstancePtrHolder<auto_ptr<A1>,A1>
-        +---------+- __class__          |  +---+   +---+ 
-        |         |  m_wrapped_objects -+->| *-+-->| *-+-+   A1    
-        |         +---------------------+  +---+   +---+ |  +---+
-        |                                                +->|   |
-        |          ExtensionInstance                        +---+ 
-        | pb1_a1: +---------------------+   vec     InstancePtrHolder<auto_ptr<A1>,A1>
-        +---------+- __class__          |  +---+   +---+                 
-        |         |  m_wrapped_objects -+->| *-+-->| *-+-+   B1           
-        |         +---------------------+  +---+   +---+ |  +---+        
-        |                                                +->|   |                            
-        |          ExtensionInstance                        +---+                       
-        | pb2_a1: +---------------------+   vec     InstancePtrHolder<auto_ptr<A1>,A1>
-        +---------+- __class__          |  +---+   +---+                 
-        |         |  m_wrapped_objects -+->| *-+-->| *-+-+   B2                   
-        |         +---------------------+  +---+   +---+ |  +---+        
-        |                                                +->|   | 
-        |                                                   +---+                       
-        |       ExtensionClass<A1>                                                          
-        |  A2: +------------+                                                               
-        | ()<--+- __bases__ |                                                               
-        |      |  __dict__ -+->{...}                                                        
-        |      +------------+                                                               
-        |           ^                                                                       
-        |           |  ExtensionInstance                                                    
-        |       a2: | +---------------------+   vec     InstanceValueHolder<A2>             
-        |           +-+- __class__          |  +---+   +-------------+                      
-        |           | |  m_wrapped_objects -+->| *-+-->| contains A2 |                      
-        |           | +---------------------+  +---+   +-------------+                      
-        |           |                                                                       
-        |           |  ExtensionInstance                                                    
-        |   pa2_a2: | +---------------------+   vec     InstancePtrHolder<auto_ptr<A2>,A2>  
-        |           +-+- __class__          |  +---+   +---+                                
-        |           | |  m_wrapped_objects -+->| *-+-->| *-+-+   A2                         
-        |           | +---------------------+  +---+   +---+ |  +---+                       
-        |           |                                        +->|   |                       
-        |           |  ExtensionInstance                        +---+                       
-        |   pb1_a2: | +---------------------+   vec     InstancePtrHolder<auto_ptr<A2>,A2>  
-        |           +-+- __class__          |  +---+   +---+                                
-        |           | |  m_wrapped_objects -+->| *-+-->| *-+-+   B1                         
-        |           | +---------------------+  +---+   +---+ |  +---+                       
-        |           |                                        +->|   |                       
-        |           |                                           +---+                       
-        |           |                                                                       
-        |           +---------------+------------------------------+                             
-        |                           |                              |                             
- +------+-------------------------+-|----------------------------+ |                             
- |                                | |                            | |                             
- |       Class<ExtensionInstance> | |      ExtensionClass<B1>    | |      ExtensionClass<B1>     
- | DA1: +------------+            | | B1: +------------+         | | B2: +------------+          
-(*,)<---+- __bases__ |           (*,*)<---+- __bases__ |        (*,*)<---+- __bases__ |          
-        |  __dict__ -+->{...}             |  __dict__ -+->{...}          |  __dict__ -+->{...}   
-        +------------+                    +------------+                 +------------+          
-              ^                                ^                                    ^ 
-              |        ExtensionInstance       |                                    |       
-              |  da1: +---------------------+  |    vec     InstanceValueHolder<A1,A_callback>  
-              +-------+- __class__          |  |   +---+   +---------------------+  |          
-                      |  m_wrapped_objects -+--|-->| *-+-->| contains A_callback |  |          
-                      +---------------------+  |   +---+   +---------------------+  |          
-        +--------------------------------------+                                    |
-        |  ExtensionInstance                                                        |
-    b1: | +---------------------+   vec     InstanceValueHolder<B1,B_callback>      |
-        +-+- __class__          |  +---+   +---------------------+                  |
-        | |  m_wrapped_objects -+->| *-+-->| contains B_callback |                  |
-        | +---------------------+  +---+   +---------------------+                  |
-        |                                                                           |
-        |  ExtensionInstance                                                        |
-pb1_b1: | +---------------------+   vec     InstancePtrHolder<auto_ptr<B1>,B1>      |
-        +-+- __class__          |  +---+   +---+                                    |
-        | |  m_wrapped_objects -+->| *-+-->| *-+-+   B1                             |
-        | +---------------------+  +---+   +---+ |  +---+                           |
-        |                                        +->|   |                           |
-        |  ExtensionInstance                        +---+                           |
- pc_b1: | +---------------------+   vec     InstancePtrHolder<auto_ptr<B1>,B1>      |
-        +-+- __class__          |  +---+   +---+                                    |
-        | |  m_wrapped_objects -+->| *-+-->| *-+-+   C                              |
-        | +---------------------+  +---+   +---+ |  +---+                           |
-        |                                        +->|   |                           |
-        |                                           +---+                           |
-        |                                                                           |
-        |       Class<ExtensionInstance>    +---------------------------------------+
-        | DB1: +------------+               |  ExtensionInstance                                                    
-       (*,)<---+- __bases__ |           a2: | +---------------------+   vec     InstanceValueHolder<A2> 
-               |  __dict__ -+->{...}        +-+- __class__          |  +---+   +-------------+                      
-               +------------+                 |  m_wrapped_objects -+->| *-+-->| contains A2 |                      
-                     ^                        +---------------------+  +---+   +-------------+                      
-                     |  ExtensionInstance      
-                db1: | +---------------------+    vec     InstanceValueHolder<B1,B_callback>  
-                     +-+- __class__          |   +---+   +----------------------+ 
-                       |  m_wrapped_objects -+-->| *-+-->| contains B1_callback |              
-                       +---------------------+   +---+   +----------------------+              

doc/enums.html

@@ -1,103 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
-"http://www.w3.org/TR/REC-html40/strict.dtd">
-    <title>
-      Wrapping enums
-    </title>
-    <div>
-      <h1>
-         <img width="277" height="86" id="_x0000_i1025" align="center"
-        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)">Wrapping enums
-      </h1>
-
-<p>Because there is in general no way to deduce that a value of arbitrary type T
-is an enumeration constant, the Boost Python Library cannot automatically
-convert enum values to and from Python. To handle this case, you need to decide
-how you want the enum to show up in Python (since Python doesn't have
-enums). Once you have done that, you can write some simple
-<code>from_python()</code> and <code>to_python()</code> functions.
-
-<p>If you are satisfied with a Python int as a way to represent your enum
-values, we provide a shorthand for these functions. You just need to
-instantiate <code>boost::python::enum_as_int_converters&lt;EnumType&gt;</code> where
-<code>EnumType</code> is your enumerated type. There are two convenient ways to do this:
-
-<ol>
-<li><blockquote>
-<pre>
-   ...
-} // close my_namespace
-// drop into namespace python and explicitly instantiate
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
-  template class enum_as_int_converters<extclass_demo::EnumOwner::enum_type>;
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-namespace my_namespace { // re-open my_namespace
-   ...
-</pre>
-</blockquote>
-<li><blockquote><pre>
-// instantiate as base class in any namespace
-struct EnumTypeConverters
-    : boost::python::enum_as_int_converters&lt;EnumType&gt;
-{
-};
-</blockquote></pre>
-</ol>
-
-<p>Either of the above is equivalent to the following declarations:
-<blockquote><pre>
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
-
-  MyEnumType from_python(PyObject* x, boost::python::type&lt;MyEnumType&gt;)
-  {
-      return static_cast&lt;MyEnum&gt;(
-        from_python(x, boost::python::type&lt;long&gt;()));
-  }
-
-  MyEnumType from_python(PyObject* x, boost::python::type&lt;const MyEnumType&amp;&gt;)
-  {
-      return static_cast&lt;MyEnum&gt;(
-        from_python(x, boost::python::type&lt;long&gt;()));
-  }
-
-  PyObject* to_python(MyEnumType x)
-  {
-      return to_python(static_cast&lt;long&gt;(x));
-  }
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-</pre></blockquote>
-
-<p>This technique defines the conversions of
-<code>MyEnumType</code> in terms of the conversions for the built-in
- <code>long</code> type.
-
-You may also want to add a bunch of lines like this to your module
-initialization:
-
-<blockquote><pre>
-mymodule.add(boost::python::to_python(enum_value_1), "enum_value_1");
-mymodule.add(boost::python::to_python(enum_value_2), "enum_value_2");
-...
-</pre></blockquote>
-
-You can also add these to an extension class definition, if your enum happens to
-be local to a class and you want the analogous interface in Python:
-
-<blockquote><pre>
-my_class.add(boost::python::to_python(enum_value_1), "enum_value_1");
-my_class.add(boost::python::to_python(enum_value_2), "enum_value_2");
-...
-</pre></blockquote>
-               <p>
-         Next: <a href="pointers.html">Pointers</a>
-         Previous: <a href="building.html">Building an Extension Module</a>
-         Up: <a href="index.html">Top</a>
-      <p>
-         &copy; Copyright David Abrahams 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 warranty, and with no claim as to
-        its suitability for any purpose.
-      <p>
-         Updated: Nov 26, 2000
-    </div>
-

doc/example1.html

@@ -1,130 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
-"http://www.w3.org/TR/REC-html40/strict.dtd">
-    <title>
-      A Simple Example
-    </title>
-    <div>
-      <h1>
-         <img width="277" height="86" id="_x0000_i1025" src="../../../c++boost.gif" alt=
-        "c++boost.gif (8819 bytes)">
-      </h1>
-      <h1>
-         A Simple Example
-      </h1>
-      <p>
-         Suppose we have the following C++ API which we want to expose in
-        Python:
-      <blockquote>
-<pre>
-#include &lt;string&gt;
-
-namespace hello {
-  class world
-  {
-   public:
-      world(int);
-      ~world();
-      std::string greet() const { return "hi, world"; }
-    ...
-  };
-  std::size_t length(const world&amp; x) { return std::strlen(x.greet()); }
-}
-
-</pre>
-      </blockquote>
-      <p>
-         Here is the C++ code for a python module called <code>hello</code>
-        which exposes the API using:
-      <blockquote>
-<pre>
-#include &lt;boost/python/class_builder.hpp&gt;
-// Python requires an exported function called init&lt;module-name&gt; in every
-// extension module. This is where we build the module contents.
-extern "C"
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-void inithello()
-{
-    try
-    {
-       // create an object representing this extension module
-       boost::python::module_builder m("hello");
-       // Create the Python type object for our extension class
-       boost::python::class_builder&lt;hello::world&gt; world_class(m, "world");
-       // Add the __init__ function
-       world_class.def(boost::python::constructor&lt;int&gt;());
-       // Add a regular member function
-       world_class.def(&amp;hello::world::get, "get");
-       // Add a regular function to the module
-       m.def(hello::length, "length");
-    }
-    catch(...)
-    {
-       boost::python::handle_exception();    // Deal with the exception for Python
-    }
-}
-// Win32 DLL boilerplate
-#if defined(_WIN32)
-#include &lt;windows.h&gt;
-extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID)
-{
-    return 1;
-}
-#endif // _WIN32
-</pre>
-      </blockquote>
-      <p>
-         That's it! If we build this shared library and put it on our <code>
-        PYTHONPATH</code> we can now access our C++ class and function from
-        Python.
-      <blockquote>
-<pre>
-&gt;&gt;&gt; import hello
-&gt;&gt;&gt; hi_world = hello.world(3)
-&gt;&gt;&gt; hi_world.greet()
-'hi, world'
-&gt;&gt;&gt; hello.length(hi_world)
-9
-</pre>
-      </blockquote>
-      <p>
-         We can even make a subclass of <code>hello.world</code>:
-      <blockquote>
-<pre>
-&gt;&gt;&gt; class my_subclass(hello.world):
-...     def greet(self):
-...         return 'hello, world'
-...
-&gt;&gt;&gt; y = my_subclass(4)
-&gt;&gt;&gt; y.greet()
-'hello, world'
-</pre>
-      </blockquote>
-      <p>
-         Pretty cool! You can't do that with an ordinary Python extension type!
-      <blockquote>
-<pre>
-&gt;&gt;&gt; hello.length(y)
-9
-</pre>
-      </blockquote>
-      <p>
-         Of course, you may now have a slightly empty feeling in the pit of
-        your little pythonic stomach. Perhaps you feel your subclass deserves
-        to have a <code>length()</code> of <code>12</code>? If so, <a href= 
-        "overriding.html">read on</a>...
-      <p>
-        Next: <a href="overriding.html">Overridable virtual functions</a>
-         Previous: <a href="comparisons.html">Comparisons with other systems</a>  Up:
-        <a href="index.html">Top</a>
-      <p>
-         &copy; Copyright David Abrahams 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 warranty, and with no claim as to its suitability
-        for any purpose.
-      <p>
-         Updated: Nov 26, 2000
-    </div>
-

doc/extending.html

@@ -1,73 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
-    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-    <title>
-      A Brief Introduction to writing Python extension modules
-    </title>
-    <h1>
-      <img src="../../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center"
-      width="277" height="86">
-    </h1>
-    <h1>
-      A Brief Introduction to writing Python extension modules
-    </h1>
-    <p>
-      Interfacing any language to Python involves building a module which can
-      be loaded by the Python interpreter, but which isn't written in Python.
-      This is known as an <em>extension module</em>. Many of the <a href= 
-      "http://www.python.org/doc/current/lib/lib.html">built-in Python
-      libraries</a> are constructed in 'C' this way; Python even supplies its
-      <a href="http://www.python.org/doc/current/lib/types.html">fundamental
-      types</a> using the same mechanism. An extension module can be statically
-      linked with the Python interpreter, but it more commonly resides in a
-      shared library or DLL.
-    <p>
-      As you can see from <a href= 
-      "http://www.python.org/doc/current/ext/ext.html"> The Python Extending
-      and Embedding Tutorial</a>, writing an extension module normally means
-      worrying about
-    <ul>
-      <li>
-        <a href="http://www.python.org/doc/current/ext/refcounts.html">
-        maintaining reference counts</a>
-      <li>
-        <a href="http://www.python.org/doc/current/ext/callingPython.html"> how
-        to call back into Python</a>
-      <li>
-        <a href="http://www.python.org/doc/current/ext/parseTuple.html">
-        function argument parsing and typechecking</a>
-    </ul>
-    This last item typically occupies a great deal of code in an extension
-    module. Remember that Python is a completely dynamic language. A callable
-    object receives its arguments in a tuple; it is up to that object to extract
-    those arguments from the tuple, check their types, and raise appropriate
-    exceptions. There are numerous other tedious details that need to be
-    managed; too many to mention here. The Boost Python Library is designed to
-    lift most of that burden.<br>
-    <br>
-     
-    <p>
-      Another obstacle that most people run into eventually when extending
-      Python is that there's no way to make a true Python class in an extension
-      module. The typical solution is to create a new Python type in the
-      extension module, and then write an additional module in 100% Python. The
-      Python module defines a Python class which dispatches to an instance of
-      the extension type, which it contains. This allows users to write
-      subclasses of the class in the Python module, almost as though they were
-      sublcassing the extension type. Aside from being tedious, it's not really
-      the same as having a true class, because there's no way for the user to
-      override a method of the extension type which is called from the
-      extension module. BPL solves this problem by taking advantage of <a
-      href="http://www.python.org/doc/essays/metaclasses/">Python's metaclass
-      feature</a> to provide objects which look, walk, and hiss almost exactly
-      like regular Python classes. BPL classes are actually cleaner than
-      Python classes in some subtle ways; a more detailed discussion will
-      follow (someday).</p>
-    <p>Next: <a href="comparisons.html">Comparisons with Other Systems</a> Up: <a
-    href="index.html">Top</a> </p>
-    <p>
-      &copy; Copyright David Abrahams 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 warranty, and with no claim as to its suitability for
-      any purpose.</p>
-

doc/index.html

@@ -1,160 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
-"http://www.w3.org/TR/REC-html40/strict.dtd">
-    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-    <title>
-      The Boost Python Library (BPL)
-    </title>
-    <h1>
-       <img src="../../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277"
-      align="center" height="86">The Boost Python Library (BPL)
-    </h1>
-
-<h2>Synopsis</h2>
-    <p>
-      Use the Boost Python Library to quickly and easily export a C++ library to <a
-      href="http://www.pythonlabs.com/pub/www.python.org">Python</a> such that the Python interface is
-      very similar to the C++ interface. It is designed to be minimally
-      intrusive on your C++ design. In most cases, you should not have to alter
-      your C++ classes in any way in order to use them with BPL. The system
-      <em>should</em> simply ``reflect'' your C++ classes and functions into
-      Python. The major features of BPL include support for:
-<ul>
-<li><a href="inheritance.html">Subclassing extension types in Python</a>
-<li><a href="overriding.html">Overriding virtual functions in Python</a>
-<li><a href="overloading.html">[Member] function Overloading</a>
-<li><a href="special.html#numeric_auto">Automatic wrapping of numeric operators</a>
-</ul>
-among others.
-
-
-<h2>Supported Platforms</h2>
-<p>BPL has been tested in the following configurations:
-
-<ul>
-<li>Against Python 1.5.2 using the following compiler/library: 
-
-  <ul>
-  <li><a
-  href="http://msdn.microsoft.com/vstudio/sp/vs6sp4/dnldoverview.asp">MSVC++6sp4</a> 
-
-  <li><a
-  href="http://msdn.microsoft.com/vstudio/sp/vs6sp4/dnldoverview.asp">MSVC++6sp4</a>/<a
-  href="http://www.stlport.org">STLport 4.0</a> 
-
-  <li><a href="http://gcc.gnu.org/">GCC 2.95.2</a> [by <a href="mailto:koethe@informatik.uni-hamburg.de">Ullrich
-  Koethe</a>]
-
-  <li><a href="http://gcc.gnu.org/">GCC 2.95.2</a>/<a href="http://www.stlport.org">STLport 4.0</a>
-
-  <li>Compaq C++ V6.2-024 for Digital UNIX V5.0 Rev. 910 (an <a
-  href="http://www.edg.com/">EDG</a>-based compiler) with <a
-  href="http://www.stlport.org/beta.html">STLport-4.1b3</a> [by <a
-  href="mailto:rwgk@cci.lbl.gov">Ralf W. Grosse-Kunstleve</a>] 
-
-  <li>An upcoming release of <a href="http://www.metrowerks.com/products/windows/">Metrowerks CodeWarrior
-        Pro6 for Windows</a> (the first release has a bug that's fatal to BPL)
-  </ul>
-<br>
-<li>Against Python 2.0 using the following compiler/library combinations:
-<ul>
-  <li><a
-  href="http://msdn.microsoft.com/vstudio/sp/vs6sp4/dnldoverview.asp">MSVC++6sp4</a> [by
-  <a href="mailto:aleaxit@yahoo.com">Alex Martelli</a>]
-</ul>
-</ul>
-
-<h2>Credits</h2>
-<ul>
-      <li><a href="../../../people/dave_abrahams.htm">David Abrahams</a> originated
-      and wrote the library.
-
-      <li><a href="mailto:koethe@informatik.uni-hamburg.de">Ullrich Koethe</a>
-      had independently developed a similar system. When he discovered BPL,
-      he generously contributed countless hours of coding and much insight into
-      improving it. He is responsible for an early version of the support for <a
-      href="overloading.html">function overloading</a> and wrote the support for
-      <a href="inheritance.html#implicit_conversion">reflecting C++ inheritance
-      relationships</a>. He has helped to improve error-reporting from both
-      Python and C++, and has designed an extremely easy-to-use way of 
-      exposing <a href="special.html#numeric">numeric operators</a>, including
-      a way to avoid explicit coercion by means of overloading.
-
-      <li>The members of the boost mailing list and the Python community
-      supplied invaluable early feedback. In particular, Ron Clarke, Mark Evans,
-      Anton Gluck, Ralf W. Grosse-Kunstleve, Chuck Ingold, Prabhu Ramachandran,
-      and Barry Scott took the brave step of trying to use BPL while it was
-      still in early stages of development.
-
-      <li>The development of BPL wouldn't have been
-      possible without the generous support of <a href="http://www.dragonsys.com/">Dragon Systems/Lernout and
-      Hauspie, Inc</a> who supported its development as an open-source project.
-</ul>
-
-    <h2>Table of Contents</h2>
-
-    <ol>
-      <li><a href="extending.html">A Brief Introduction to writing Python
-        extension modules</a>
-
-      <li><a href="comparisons.html">Comparisons between BPL and other
-        systems for extending Python</a>
-
-      <li><a href="example1.html">A Simple Example</a>
-
-      <li><a href="overriding.html">Overridable Virtual Functions</a>
-
-      <li><a href="overloading.html">Function Overloading</a>
-
-      <li><a href="inheritance.html">Inheritance</a>
-
-      <li><a href="special.html">Special Method and Operator Support</a>
-
-      <li><a href="under-the-hood.html">A Peek Under the Hood</a>
-
-      <li><a href="building.html">Building an Extension Module</a>
-
-      <li>Advanced Topics
-
-        <ol>
-          <li>Pickling
-
-          <li>class_builder&lt;&gt;
-
-          <li><a href="enums.html">enums</a>
-
-          <li>References
-
-          <li><a href="pointers.html">Pointers and Smart Pointers</a>
-
-          <li>Built-in Python Types
-
-          <li>Other Extension Types
-
-          <li>Templates
-          
-          <li><a href="data_structures.txt">Internal Data Structures</a>
-        </ol>
-          
-</ol>  
- 
-    <p>
-      Documentation is a major ongoing project; assistance is greatly
-      appreciated! In the meantime, useful examples of every BPL feature should
-      be evident in the regression test files <code>test/comprehensive.[<a
-      href="../test/comprehensive.py">py</a>/<a
-      href="../test/comprehensive.hpp">hpp</a>/<a
-      href="../test/comprehensive.cpp">cpp</a>]</code>
-
-    <p>
-       Questions should be directed to <a href= 
-      "http://www.egroups.com/list/boost">the boost mailing list</a>.
-
-    <p>
-       &copy; Copyright David Abrahams 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 warranty, and with no claim as to its suitability for
-      any purpose.
-    <p>
-       Updated: Nov 26, 2000
-

doc/inheritance.html

@@ -1,169 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
-"http://www.w3.org/TR/REC-html40/strict.dtd">
-    <title>
-      Inheritance
-    </title>
-    <div>
-      <h1>
-         <img width="277" height="86" id="_x0000_i1025" align="center"
-        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)">Inheritance
-      </h1>
-
-<h2>Inheritance in Python</h2>
-
-      <p>
-         BPL extension classes support single and multiple-inheritance in
-         Python, just like regular Python classes. You can arbitrarily mix
-         built-in Python classes with extension classes in a derived class'
-         tuple of bases. Whenever a BPL extension class is among the bases for a
-         new class in Python, the result is an extension class:
-<blockquote>
-<pre>
-&gt;&gt;&gt; class MyPythonClass:
-...     def f(): return 'MyPythonClass.f()'
-...
-&gt;&gt;&gt; import my_extension_module
-&gt;&gt;&gt; class Derived(my_extension_module.MyExtensionClass, MyPythonClass):
-...     '''This is an extension class'''
-...     pass
-...
-&gt;&gt;&gt; x = Derived()
-&gt;&gt;&gt; x.f()
-'MyPythonClass.f()'
-&gt;&gt;&gt; x.g()
-'MyExtensionClass.g()'
-</pre>
-</blockquote>
-
-<h2><a name="implicit_conversion">Reflecting C++ Inheritance Relationships</a></h2>
-      <p>
-        BPL also allows us to represent C++ inheritance relationships so that
-        wrapped derived classes may be passed where values, pointers, or
-        references to a base class are expected as arguments. The
-        <code>declare_base</code> member function of
-        <code>class_builder&lt;&gt;</code> is used to establish the relationship
-        between base and derived classes:
-
-<blockquote>
-<pre>
-#include &lt;memory&gt; // for std::auto_ptr&lt;&gt;
-
-struct Base {
-    virtual ~Base() {}
-    virtual const char* name() const { return "Base"; }
-};
-
-struct Derived : Base {
-    Derived() : x(-1) {}
-    virtual const char* name() const { return "Derived"; }
-    int x;
-};
-
-std::auto_ptr&lt;Base&gt; derived_as_base() {
-    return std::auto_ptr&lt;Base&gt;(new Derived);
-}
-
-const char* get_name(const Base& b) {
-    return b.name();
-}
-
-int get_derived_x(const Derived& d) {
-    return d.x;
-}
-    <hr>
-#include &lt;boost/python/class_builder.hpp&gt;
-
-// namespace alias for code brevity
-namespace python = boost::python;
-
-extern "C"
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-void initmy_module()
-{
-    try
-    {
-       python::module_builder my_module("my_module");
-
-       python::class_builder&lt;Base&gt; base_class(my_module, "Base");
-       base_class.def(python::constructor&lt;void&gt;());
-
-       python::class_builder&lt;Derived&gt; derived_class(my_module, "Derived");
-       derived_class.def(python::constructor&lt;void&gt;());
-       <b>// Establish the inheritance relationship between Base and Derived
-       derived_class.declare_base(base_class);</b>
-
-       my_module.def(derived_as_base, "derived_as_base");
-       my_module.def(get_name, "get_name");
-       my_module.def(get_derived_x, "get_derived_x");
-    }
-    catch(...)
-    {
-       python::handle_exception();    // Deal with the exception for Python
-    }
-}
-</pre>
-</blockquote>
-
-<p>
-   Then, in Python:
-<blockquote>
-<pre>
-&gt;&gt;&gt; from my_module import *
-&gt;&gt;&gt; base = Base()
-&gt;&gt;&gt; derived = Derived()
-&gt;&gt;&gt; get_name(base)
-'Base'
-</pre><i>objects of wrapped class Derived may be passed where Base is expected</i><pre>
-&gt;&gt;&gt; get_name(derived) 
-'Derived'
-</pre><i>objects of wrapped class Derived can be passed where Derived is 
-expected but where type information has been lost.</i><pre>
-&gt;&gt;&gt; get_derived_x(derived_as_base()) 
--1
-</pre>
-</blockquote>
-
-<h2>Inheritance Without Virtual Functions</h2>
-
-<p>
-  If for some reason your base class has no virtual functions but you still want
-  to represent the inheritance relationship between base and derived classes,
-  pass the special symbol <code>boost::python::without_downcast</code> as the 2nd parameter
-  to <code>declare_base</code>:
-
-<blockquote>
-<pre>
-struct Base2 {};
-struct Derived2 { int f(); };
-<hr>
-   ...
-   python::class_builder&lt;Base&gt; base2_class(my_module, "Base2");
-   base2_class.def(python::constructor&lt;void&gt;());
-
-   python::class_builder&lt;Derived2&gt; derived2_class(my_module, "Derived2");
-   derived2_class.def(python::constructor&lt;void&gt;());
-   derived_class.declare_base(base_class, <b>python::without_downcast</b>);
-</pre>
-</blockquote>
-
-<p>This approach will allow <code>Derived2</code> objects to be passed where
- <code>Base2</code> is expected, but does not attempt to implicitly convert (downcast)
- smart-pointers to <code>Base2</code> into <code>Derived2</code> pointers,
- references, or values.
-
-      <p>
-         Next: <a href="special.html">Special Method and Operator Support</a>
-         Previous: <a href="overloading.html">Function Overloading</a>
-         Up: <a href="index.html">Top</a>
-      <p>
-         &copy; Copyright David Abrahams 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 warranty, and with no claim as to its suitability
-        for any purpose.
-      <p>
-         Updated: Nov 26, 2000
-    </div>
-

doc/overloading.html

@@ -1,155 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
-"http://www.w3.org/TR/REC-html40/strict.dtd">
-    <title>
-      Function Overloading
-    </title>
-    <div>
-      <h1>
-         <img width="277" height="86" id="_x0000_i1025" align="center"
-        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)">Function Overloading
-      </h1>
-
-<h2>An Example</h2>
-      <p>
-        To expose overloaded functions in Python, simply <code>def()</code> each
-        one with the same Python name:
-<blockquote>
-<pre>
-inline int f1() { return 3; }
-inline int f2(int x) { return x + 1; }
-
-class X {
-public:
-    X() : m_value(0) {}
-    X(int n) : m_value(n) {}
-    int value() const { return m_value; }
-    void value(int v) { m_value = v; }
-private:
-    int m_value;
-};
-  ...
-
-void initoverload_demo()
-{
-    try
-    {
-        boost::python::module_builder overload_demo("overload_demo");
-        // Overloaded functions at module scope
-        overload_demo.def(f1, "f");
-        overload_demo.def(f2, "f");
-
-        boost::python::class_builder&lt;X&gt; x_class(overload_demo, "X");
-        // Overloaded constructors
-        x_class.def(boost::python::constructor&lt;&gt;());
-        x_class.def(boost::python::constructor&lt;int&gt;());
-
-        // Overloaded member functions
-        x_class.def((int (X::*)() const)&amp;X::value, "value");
-        x_class.def((void (X::*)(int))&amp;X::value, "value");
-  ...
-</pre>
-</blockquote>
-
-      <p>
-        Now in Python:
-<blockquote>
-<pre>
->>> from overload_demo import *
->>> x0 = X()
->>> x1 = X(1)
->>> x0.value()
-0
->>> x1.value()
-1
->>> x0.value(3)
->>> x0.value()
-3
->>> X('hello')
-TypeError: No overloaded functions match (X, string). Candidates are:
-void (*)()
-void (*)(int)
->>> f()
-3
->>> f(4)
-5
-</pre>
-</blockquote>
-
-<h2>Discussion</h2>
-      <p>
-        Notice that overloading in the Python module was produced three ways:<ol>
-        <li>by combining the non-overloaded C++ functions <code>int f1()</code>
-        and <code>int f2(int)</code> and exposing them as <code>f</code> in Python.
-        <li>by exposing the overloaded constructors of <code>class X</code>
-        <li>by exposing the overloaded member functions <code>X::value</code>.
-        </ol>
-      <p>
-        Techniques 1. and 3. above are really alternatives. In case 3, you need
-        to form a pointer to each of the overloaded functions. The casting
-        syntax shown above is one way to do that in C++. Case 1 does not require
-        complicated-looking casts, but may not be viable if you can't change
-        your C++ interface. N.B. There's really nothing unsafe about casting an
-        overloaded (member) function address this way: the compiler won't let
-        you write it at all unless you get it right.
-
-<h2>An Alternative to Casting</h2>
-      <p>
-        This approach is not neccessarily better, but may be preferable for some
-        people who have trouble writing out the types of (member) function
-        pointers or simply prefer to avoid all casts as a matter of principle:
-<blockquote>
-<pre>
-// Forwarding functions for X::value
-inline void set_x_value(X&amp; self, int v) { self.value(v); }
-inline int get_x_value(X&amp; self) { return self.value(); }
-   ...
-        // Overloaded member functions
-        x_class.def(set_x_value, "value");
-        x_class.def(get_x_value, "value");
-</pre>
-</blockquote>
-<p>Here we are taking advantage of the ability to expose C++ functions at
-namespace scope as Python member functions.
-
-<h2>Overload Resolution</h2>
-      <p>
-        The function overload resolution mechanism  works as follows:
-
-        <ul>
-
-        <li>Attribute lookup for extension classes proceeds in <a
-        href="http://www.pythonlabs.com/pub/www.python.org/doc/current/tut/node11.html#SECTION0011510000000000000000">the
-        usual Python way</a> using a depth-first, left-to-right search. When a
-        class is found which has a matching attribute, only functions overloaded
-        in the context of that class are candidates for overload resolution. In
-        this sense, overload resolution mirrors the C++ mechanism, where a name
-        in a derived class ``hides'' all functions with the same name from a base
-        class.
-        <p>
-
-        <li>Within a name-space context (extension class or module), overloaded
-        functions are tried in the same order they were
-        <code>def()</code>ed. The first function whose signature can be made to
-        match each argument passed is the one which is ultimately called. 
-        This means in particular that you cannot overload the same function on 
-        both ``<code>int</code>'' and ``<code>float</code>'' because Python 
-        automatically converts either of the two types into the other one. 
-        If the ``<code>float</code>'' overload is found first, it is used 
-        also used for arguments of type ``<code>int</code>'' as well, and the 
-        ``<code>int</code>'' version of the function is never invoked.
-        </ul>
-
-      <p>
-         Next: <a href="inheritance.html">Inheritance</a>
-         Previous: <a href="overriding.html">Overridable Virtual Functions</a>
-         Up: <a href="index.html">Top</a>
-      <p>
-         &copy; Copyright David Abrahams 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 warranty, and with no claim as to
-        its suitability for any purpose.
-      <p>
-         Updated: Nov 26, 2000
-    </div>
-

doc/overriding.html

@@ -1,195 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
-    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-
-    <title>Overridable Virtual Functions</title>
-
-    <img src="../../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center"
-    width="277" height="86"> 
-
-    <h1>Overridable Virtual Functions</h1>
-
-<p> 
-  In the <a href="example1.html">previous example</a> we exposed a simple
-  C++ class in Python and showed that we could write a subclass. We even
-  redefined one of the functions in our derived class. Now we will learn
-  how to make the function behave virtually <em>when called from C++</em>. 
-
-
-<h2><a name="overriding_example">Example</a></h2>
-
-<p>In this example, it is assumed that <code>world::greet()</code> is a virtual
-member function:
-
-<blockquote><pre>
-class world
-{
- public:
-    world(int);
-    virtual ~world();
-    <b>virtual</b> std::string greet() const { return "hi, world"; }
-};
-</pre></blockquote>
-
-<p>
-  We'll need a derived class<a href="#why_derived">*</a> to help us
-  dispatch the call to Python. In our derived class, we need the following
-  elements:
-
-<ol>
-
-  <li><a name="derived_1">A</a> <code>PyObject*</code> data member that holds a
-  reference to the corresponding Python object.
-
-  <li><a name="derived_2">A</a> constructor for each exposed constructor of the
-  base class which stores an additional initial <code>PyObject*</code> argument
-  in the data member described above.
-
-  <li><a name="derived_3">An</a> implementation of each virtual function you may
-  wish to override in Python which uses
-  <code>boost::python::callback&lt<i>return-type</i>&gt;::call_method()</code> to call
-  the Python override.
-
-  <li><a name="derived_4">For</a> each non-pure virtual function meant to be
-  overridable from Python, a static member function (or a free function) taking
-  a reference or pointer to the base type as the first parameter and which
-  forwards any additional parameters neccessary to the <i>default</i>
-  implementation of the virtual function. See also <a href="#private">this
-  note</a> if the base class virtual function is private.
-
-</ol>
-
-<blockquote><pre>
-struct world_callback : world
-{
-    world_callback(PyObject* self, int x) // <a href="#derived_2">2</a>
-        : world(x),
-          m_self(self) {}
-
-    std::string greet() const // <a href="#derived_3">3</a>
-        { return boost::python::callback&lt;std::string&gt;::call_method(m_self, "get"); }
-
-    static std::string <a name= "default_implementation">default_get</a>(const hello::world& self) const // <a href="#derived_4">4</a>
-        { return self.world::greet(); }
- private:
-    PyObject* m_self; // <a href="#derived_1">1</a>
-};
-</pre></blockquote>
-
-<p>
-  Finally, we add <code>world_callback</code> to the <code>
-  class_builder&lt;&gt;</code> declaration in our module initialization
-  function, and when we define the function, we must tell py_cpp about the default
-  implementation:
-
-<blockquote><pre>
-// Create the <a name=
-"world_class">Python type object</a> for our extension class
-boost::python::class_builder&lt;hello::world<strong>,world_callback&gt;</strong> world_class(hello, "world");
-// Add a virtual member function
-world_class.def(&amp;world::get, "get", &amp;<b>world_callback::default_get</b>);
-</pre></blockquote>
-
-<p>
- Now our subclass of <code>hello.world</code> behaves as expected:
-
-<blockquote><pre>
-&gt;&gt;&gt; class my_subclass(hello.world):
-...     def greet(self):
-...         return 'hello, world'
-...
-&gt;&gt;&gt; hello.length(my_subclass())
-12
-</pre></blockquote>
-
-    <p>
-      <a name="why_derived">*</a>You may ask, "Why do we need this derived
-      class? This could have been designed so that everything gets done right
-      inside of <code>hello::world</code>." One of the goals of py_cpp is to be
-      minimally intrusive on an existing C++ design. In principle, it should be
-      possible to expose the interface for a 3rd party library without changing
-      it. To unintrusively hook into the virtual functions so that a Python
-      override may be called, we must use a derived class.
-
-<h2>Pure Virtual Functions</h2>
-
-    <p>
-      A pure virtual function with no implementation is actually a lot easier to
-      deal with than a virtual function with a default implementation. First of
-      all, you obviously don't need to <a href="#default_implementation"> supply
-      a default implementation</a>. Secondly, you don't need to call
-      <code>def()</code> on the <code>extension_class&lt;&gt;</code> instance
-      for the virtual function. In fact, you wouldn't <em>want</em> to: if the
-      corresponding attribute on the Python class stays undefined, you'll get an
-      <code>AttributeError</code> in Python when you try to call the function,
-      indicating that it should have been implemented. For example:
-    <blockquote>
-<pre>
-struct baz {
-    <strong>virtual</strong> int pure(int) = 0;
-};
-
-struct baz_callback {
-    int pure(int x) { boost::python::callback&lt;int&gt;::call_method(m_self, "pure", x); }
-};
-
-extern "C"
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-initfoobar()
-{
-    try
-    {
-       boost::python::module_builder foobar("foobar");
-       boost::python::class_builder&lt;baz,baz_callback&gt; baz_class("baz");
-       baz_class.def(&amp;baz::pure, "pure");
-    }
-    catch(...)
-    {
-       boost::python::handle_exception();    // Deal with the exception for Python
-    }
-}
-</pre>
-    </blockquote>
-    <p>
-      Now in Python:
-    <blockquote>
-<pre>
-&gt;&gt;&gt; from foobar import baz
-&gt;&gt;&gt; x = baz()
-&gt;&gt;&gt; x.pure(1)
-Traceback (innermost last):
-  File "&lt;stdin&gt;", line 1, in ?
-AttributeError: pure
-&gt;&gt;&gt; class mumble(baz):
-...    def pure(self, x): return x + 1
-...
-&gt;&gt;&gt; y = mumble()
-&gt;&gt;&gt; y.pure(99)
-100
-</pre></blockquote>
-
-<a name="private"><h2>Private Non-Pure Virtual Functions</h2></a>
-
-<p>This is one area where some minor intrusiveness on the wrapped library is
-required. Once it has been overridden, the only way to call the base class
-implementation of a private virtual function is to make the derived class a
-friend of the base class. You didn't hear it from me, but most C++
-implementations will allow you to change the declaration of the base class in
-this limited way without breaking binary compatibility (though it will certainly
-break the <a
-href="http://cs.calvin.edu/c++/C++Standard-Nov97/basic.html#basic.def.odr">ODR</a>).
-
-    <p>
-      Next: <a href="overloading.html">Function Overloading</a>
-      Previous: <a href="example1.html">A Simple Example Using py_cpp</a>
-      Up: <a href="index.html">Top</a>
-    <p>
-      &copy; Copyright David Abrahams 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 warranty, and with no claim as to its suitability for
-      any purpose.
-    <p>
-      Updated: Nov 26, 2000
-

doc/pointers.html

@@ -1,148 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
-"http://www.w3.org/TR/REC-html40/strict.dtd">
-    <title>
-      Pointers
-    </title>
-    <div>
-      <h1>
-         <img width="277" height="86" id="_x0000_i1025" align="center"
-        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)">Pointers
-      </h1>
-
-<h2><a name="problem">The Problem With Pointers</a></h2>
-
-      <p>
-In general, raw pointers passed to or returned from functions are problematic
-for BPL because pointers have too many potential meanings. Is it an iterator?
-A pointer to a single element? An array? When used as a return value, is the
-caller expected to manage (delete) the pointed-to object or is the pointer
-really just a reference? If the latter, what happens to Python references to the
-referent when some C++ code deletes it?
-<p>
-There are a few cases in which pointers are converted automatically:
-<ul>
-
-<li>Both const- and non-const pointers to wrapped class instances can be passed
-<i>to</i> C++ functions. 
-
-<li>Values of type <code>const char*</code> are interpreted as
-null-terminated 'C' strings and when passed to or returned from C++ functions are
-converted from/to Python strings.
-
-</ul>
-
-<h3>Can you avoid the problem?</h3>
-
-<p>My first piece of advice to anyone with a case not covered above is
-``find a way to avoid the problem.'' For example, if you have just one
-or two functions that return a pointer to an individual <code>const
-T</code>, and <code>T</code> is a wrapped class, you may be able to write a ``thin
-converting wrapper'' over those two functions as follows:
-
-<blockquote><pre>
-const Foo* f(); // original function
-const Foo& f_wrapper() { return *f(); }
-  ...
-my_module.def(f_wrapper, "f");
-</pre></blockquote>
-<p>
-Foo must have a public copy constructor for this technique to work, since BPL
-converts <code>const T&</code> values <code>to_python</code> by copying the <code>T</code>
-value into a new extension instance.
-
-<h2>Dealing with the problem</h2>
-
-<p>The first step in handling the remaining cases is to figure out what the pointer
-means. Several potential solutions are provided in the examples that follow:
-
-<h3>Returning a pointer to a wrapped type</h3>
-
-<h4>Returning a const pointer</h4>
-
-<p>If you have lots of functions returning a <code>const T*</code> for some
-wrapped <code>T</code>, you may want to provide an automatic
-<code>to_python</code> conversion function so you don't have to write lots of
-thin wrappers. You can do this simply as follows:
-
-<blockquote><pre>
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
-  PyObject* to_python(const Foo* p) {
-     return to_python(*p); // convert const Foo* in terms of const Foo&
-  }
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-</pre></blockquote>
-
-<h4>If you can't (afford to) copy the referent, or the pointer is non-const</h4>
-
-<p>If the wrapped type doesn't have a public copy constructor, if copying is
-<i>extremely</i> costly (remember, we're dealing with Python here), or if the
-pointer is non-const and you really need to be able to modify the referent from
-Python, you can use the following dangerous trick. Why dangerous? Because python
-can not control the lifetime of the referent, so it may be destroyed by your C++
-code before the last Python reference to it disappears:
-
-<blockquote><pre>
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
-  PyObject* to_python(Foo* p)
-  {
-      return boost::python::PyExtensionClassConverters<Foo>::ptr_to_python(p);
-  }
-
-  PyObject* to_python(const Foo* p)
-  {
-      return to_python(const_cast<Foo*>(p));
-  }
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-</pre></blockquote>
-
-This will cause the Foo* to be treated as though it were an owning smart
-pointer, even though it's not. Be sure you don't use the reference for anything
-from Python once the pointer becomes invalid, though. Don't worry too much about
-the <code>const_cast&lt;&gt;</code> above: Const-correctness is completely lost
-to Python anyway!
-
-<h3>[In/]Out Parameters and Immutable Types</h3>
-
-<p>If you have an interface that uses non-const pointers (or references) as
-in/out parameters to types which in Python are immutable (e.g. int, string),
-there simply is <i>no way</i> to get the same interface in Python. You must
-resort to transforming your interface with simple thin wrappers as shown below:
-<blockquote><pre>
-const void f(int* in_out_x); // original function
-const int f_wrapper(int in_x) { f(in_x); return in_x; }
-  ...
-my_module.def(f_wrapper, "f");
-</pre></blockquote>
-
-<p>Of course, [in/]out parameters commonly occur only when there is already a
-return value. You can handle this case by returning a Python tuple:
-<blockquote><pre>
-typedef unsigned ErrorCode;
-const char* f(int* in_out_x); // original function
- ...
-#include &lt;boost/python/objects.hpp&gt;
-const boost::python::tuple f_wrapper(int in_x) { 
-  const char* s = f(in_x); 
-  return boost::python::tuple(s, in_x);
-}
-  ...
-my_module.def(f_wrapper, "f");
-</pre></blockquote>
-<p>Now, in Python:
-<blockquote><pre>
-&gt;&gt;&gt; str,out_x = f(3)
-</pre></blockquote>
-
-<p>
-         Previous: <a href="enums.html">Enums</a>
-         Up: <a href="index.html">Top</a>
-      <p>
-         &copy; Copyright David Abrahams 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 warranty, and with no claim as to its suitability
-        for any purpose.
-      <p>
-         Updated: Nov 26, 2000
-    </div>
-

doc/special.html

@@ -1,905 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-    <title>
-      Special Method and Operator Support
-    </title>
-    <div>
-      <h1>
-         <img width="277" height="86" id="_x0000_i1025" align="middle" src= 
-        "../../../c++boost.gif" alt="c++boost.gif (8819 bytes)">Special Method and
-        Operator Support
-      </h1>
-      <h2>
-         Overview
-      </h2>
-      <p>
-         BPL supports all of the standard <a href=
-        "http://www.pythonlabs.com/pub/www.python.org/doc/current/ref/specialnames.html">
-        special method names</a> supported by real Python class instances <em>
-        except</em> <code>__complex__</code> (more on the reasons <a href=
-        "#reasons">below</a>). In addition, it can quickly and easily expose
-        suitable C++ functions and operators as Python operators. The following
-        categories of special method names are supported:
-<ul>
-<li><a href="#general">Basic Customization</a>
-<li><a href="#numeric">Numeric Operators</a>
-<li><a href="#sequence_and_mapping">Sequence and Mapping protocols</a>
-<li><a href="#getter_setter">Attribute Getters and Setters</a>
-</ul>
-
-<h2><a name="general">Basic Customization</a></h2>
-
-
-<p>
-      Python provides a number of special operators for basic customization of a
-      class. Only a brief description is provided below; more complete
-      documentation can be found <a
-      href="http://www.pythonlabs.com/pub/www.python.org/doc/current/ref/customization.html">here</a>.
-
-      <dl>
-        <dt>
-          <b><tt class='method'>__init__</tt></b>(<i>self</i>)
-        <dd>
-          Initialize the class instance. For extension classes not subclassed in
-          Python, <code> __init__</code> is defined by 
-          
-          <pre>    my_class.def(boost::python::constructor<...>())</pre> 
-          
-          (see section <a href="example1.html">"A Simple Example Using BPL"</a>).<p>
-        <dt>
-          <b><tt class='method'>__del__</tt></b>(<i>self</i>)
-        <dd>
-          Called when the extension instance is about to be destroyed. For extension classes 
-          not subclassed in Python, <code> __del__</code> is always defined automatically by 
-          means of the class' destructor.
-        <dt>
-          <b><tt class='method'>__repr__</tt></b>(<i>self</i>)
-        <dd>
-          Create a string representation from which the object can be
-          reconstructed.
-        <dt>
-          <b><tt class='method'>__str__</tt></b>(<i>self</i>)
-        <dd>
-          Create a string representation which is suitable for printing.
-        <dt>
-          <b><tt class='method'>__cmp__</tt></b>(<i>self, other</i>)
-        <dd>
-          Three-way compare function, used to implement comparison operators
-          (&lt; etc.) Should return a negative integer if <code> self < other
-          </code> , zero if <code> self == other </code> , a positive integer if
-          <code> self > other </code>.
-        <dt>
-          <b><tt class='method'>__hash__</tt></b>(<i>self</i>)
-        <dd>
-          Called for the key object for dictionary operations, and by the
-          built-in function hash(). Should return a 32-bit integer usable as a
-          hash value for dictionary operations (only allowed if __cmp__ is also
-          defined)
-        <dt>
-          <b><tt class='method'>__nonzero__</tt></b>(<i>self</i>)
-        <dd>
-          called if the object is used as a truth value (e.g. in an if
-          statement)
-        <dt>
-        <b><tt class='method'>__call__</tt></b> (<var>self</var><big>[</big><var>, args...</var><big>]</big>)
-<dd>
-Called when the instance is ``called'' as a function; if this method
-is defined, <code><var>x</var>(arg1, arg2, ...)</code> is a shorthand for
-<code><var>x</var>.__call__(arg1, arg2, ...)</code>.
-      </dl>
-
-      If we have a suitable C++ function that supports any of these features,
-      we can export it like any other function, using its Python special name.
-      For example, suppose that class <code>Foo</code> provides a string
-      conversion function: 
-<blockquote><pre>
-std::string to_string(Foo const&amp; f)
-{
-    std::ostringstream s;
-    s &lt;&lt; f;
-    return s.str();
-}
-</pre></blockquote>
-      This function would be wrapped like this: 
-<blockquote><pre>
-boost::python::class_builder&lt;Foo&gt; foo_class(my_module, "Foo");
-foo_class.def(&amp;to_string, "__str__");
-</pre></blockquote>
-      Note that BPL also supports <em>automatic wrapping</em> of
-      <code>__str__</code> and <code>__cmp__</code>. This is explained in the <a
-      href="#numeric">next section</a> and the <a href="#numeric_table">Table of
-      Automatically Wrapped Methods</a>.
-
-<h2><a name="numeric">Numeric Operators</a></h2>
-
-<p>
-      Numeric operators can be exposed manually, by <code>def</code>ing C++
-      [member] functions that support the standard Python <a
-      href="http://www.pythonlabs.com/pub/www.python.org/doc/current/ref/numeric-types.html">numeric
-      protocols</a>. This is the same basic technique used to expose
-      <code>to_string()</code> as <code>__str__()</code> above, and is <a
-      href="#numeric_manual">covered in detail below</a>.  BPL also supports
-      <i>automatic wrapping</i> of numeric operators whenever they have already
-      been defined in C++.
-
-<h3><a name="numeric_auto">Exposing C++ Operators Automatically</a></h3>
-
-<p>
-Supose we wanted to expose a C++ class
-      <code>BigNum</code> which supports addition. That is, in C++ we can write:
-<blockquote><pre>
-BigNum a, b, c;
-...
-c = a + b;
-</pre></blockquote>
-<p>
-      To enable the same functionality in Python, we first wrap the <code>
-      BigNum</code> class as usual: 
-<blockquote><pre>
-boost::python::class_builder&lt;BigNum&gt; bignum_class(my_module, "BigNum");
-bignum_class.def(boost::python::constructor&lt;&gt;());
-...
-</pre></blockquote>
-      Then we export the addition operator like this: 
-
-<blockquote><pre>
-bignum_class.def(boost::python::operators&lt;boost::python::op_add&gt;());
-</pre></blockquote>
-
-      Since BigNum also supports subtraction, multiplication, and division, we
-      want to export those also. This can be done in a single command by
-      ``or''ing the operator identifiers together (a complete list of these
-      identifiers and the corresponding operators can be found in the <a href= 
-      "#numeric_table">Table of Automatically Wrapped Methods</a>):
-<blockquote><pre>
-bignum_class.def(boost::python::operators&lt;(boost::python::op_sub | boost::python::op_mul | boost::python::op_div)&gt;());
-</pre></blockquote>
-      [Note that the or-expression must be enclosed in parentheses.]
-
-<p>This form of operator definition can be used to wrap unary and
-      homogeneous binary operators (a <i>homogeneous</i> operator has left and
-      right operands of the same type). Now suppose that our C++ library also
-      supports addition of BigNums and plain integers:
-
-<blockquote><pre>
-BigNum a, b;
-int i;
-...
-a = b + i;
-a = i + b;
-</pre></blockquote>
-      To wrap these heterogeneous operators, we need to specify a different type for
-      one of the operands. This is done using the <code>right_operand</code>
-      and <code>left_operand</code> templates: 
-<blockquote><pre>
-bignum_class.def(boost::python::operators&lt;boost::python::op_add&gt;(), boost::python::right_operand&lt;int&gt;());
-bignum_class.def(boost::python::operators&lt;boost::python::op_add&gt;(), boost::python::left_operand&lt;int&gt;());
-</pre></blockquote>
-      BPL uses overloading to register several variants of the same
-      operation (more on this in the context of <a href="#coercion">
-      coercion</a>). Again, several operators can be exported at once: 
-<blockquote><pre>
-bignum_class.def(boost::python::operators&lt;(boost::python::op_sub | boost::python::op_mul | boost::python::op_div)&gt;(),
-                 boost::python::right_operand&lt;int&gt;());
-bignum_class.def(boost::python::operators&lt;(boost::python::op_sub | boost::python::op_mul | boost::python::op_div)&gt;(), 
-                 boost::python::left_operand&lt;int&gt;());
-</pre></blockquote>
-      The type of the operand not mentioned is taken from the class being wrapped. In
-      our example, the class object is <code>bignum_class</code>, and thus the
-      other operand's type is ``<code>BigNum const&amp;</code>''. You can override
-      this default by explicitly specifying a type in the <code>
-      operators</code> template: 
-<blockquote><pre>
-bignum_class.def(boost::python::operators&lt;boost::python::op_add, BigNum&gt;(), boost::python::right_operand&lt;int&gt;());
-</pre></blockquote>
-      <p>
-        Note that automatic wrapping uses the <em>expression</em>
-        ``<code>left + right</code>'' and can be used uniformly
-        regardless of whether the C++ operators are supplied as free functions
-
- <blockquote><pre>
-BigNum operator+(BigNum, BigNum)
-</pre></blockquote>
-
-        or as member functions
-
-<blockquote><pre>
-BigNum::operator+(BigNum).
-</pre></blockquote>
-
-      <p>
-        For the Python built-in functions <code>pow()</code> and
-        <code>abs()</code>, there is no corresponding C++ operator. Instead,
-        automatic wrapping attempts to wrap C++ functions of the same name. This
-        only works if those functions are known in namespace
-        <code>python</code>.  On some compilers (e.g. MSVC) it might be
-        necessary to add a using declaration prior to wrapping:
-
-<blockquote><pre>
-namespace boost { namespace python { 
-  using my_namespace::pow;
-  using my_namespace::abs;
-}
-</pre></blockquote>
-
-<h3><a name="numeric_manual">Wrapping Numeric Operators Manually</a></h3>
-      <p>
-        In some cases, automatic wrapping of operators may be impossible or
-        undesirable. Suppose, for example, that the modulo operation for BigNums
-        is defined by a set of functions called <code>mod()</code>:
-
-<blockquote><pre>
-BigNum mod(BigNum const&amp; left, BigNum const&amp; right);
-BigNum mod(BigNum const&amp; left, int right);
-BigNum mod(int left, BigNum const&amp; right);
-</pre></blockquote>
-
-     <p>
-        For automatic wrapping of the modulo function, <code>operator%()</code> would be needed.
-        Therefore, the <code>mod()</code>-functions must be wrapped manually. That is, we have 
-        to export them explicitly with the Python special name "__mod__":
-
-<blockquote><pre>
-bignum_class.def((BigNum (*)(BigNum const&amp;, BigNum const&amp;))&amp;mod, "__mod__");
-bignum_class.def((BigNum (*)(BigNum const&amp;, int))&amp;mod, "__mod__");
-</pre></blockquote>
-
-<p>
-      The third form of <code>mod()</code> (with <code>int</code> as left operand) cannot 
-      be wrapped directly. We must first create a function <code>rmod()</code> with the
-      operands reversed: 
-
-<blockquote><pre>
-BigNum rmod(BigNum const&amp; right, int left)
-{
-    return mod(left, right);
-}
-</pre></blockquote>
-
-      This function must be wrapped under the name "__rmod__" (standing for "reverse mod"): 
-
-<blockquote><pre>
-bignum_class.def(&amp;rmod,  "__rmod__");
-</pre></blockquote>
-
-      Many of the possible operator names can be found in the <a href=
-      "#numeric_table">Table of Automatically Wrapped Methods</a>. Special treatment is
-      necessary to export the <a href="#ternary_pow">ternary pow</a> operator.
-
-      <p>
-        Automatic and manual wrapping can be mixed arbitrarily. Note that you
-        cannot overload the same operator for a given extension class on both
-        ``<code>int</code>'' and ``<code>float</code>'', because Python implicitly
-        converts these types into each other. Thus, the overloaded variant
-        found first (be it ``<code>int</code>`` or ``<code>float</code>'') will be
-        used for either of the two types.
-
-<h3><a name="coercion">Coercion</a></h3>
-
-
-      Plain Python can only execute operators with identical types on the left
-      and right hand side. If it encounters an expression where the types of
-      the left and right operand differ, it tries to coerce these types to a
-      common type before invoking the actual operator. Implementing good
-      coercion functions can be difficult if many type combinations must be
-      supported. 
-      <p>
-        BPL solves this problem the same way that C++ does: with <em><a
-        href="overloading.html">overloading</a></em>. This technique drastically
-        simplifies the code neccessary to support operators: you just register
-        operators for all desired type combinations, and BPL automatically
-        ensures that the correct function is called in each case; there is no
-        need for user-defined coercion functions. To enable operator
-        overloading, BPL provides a standard coercion which is <em>implicitly
-        registered</em> whenever automatic operator wrapping is used.
-      <p>
-        If you wrap all operator functions manually, but still want to use
-        operator overloading, you have to register the standard coercion
-        function explicitly:
-
-<blockquote><pre>
-// this is not necessary if automatic operator wrapping is used
-bignum_class.def_standard_coerce();
-</pre></blockquote>
-
-      If you encounter a situation where you absolutely need a customized
-      coercion, you can still define the "__coerce__" operator manually. The signature
-      of a coercion function should look like one of the following (the first is
-      the safest):
-
-<blockquote><pre>
-boost::python::tuple custom_coerce(boost::python::reference left, boost::python::reference right);
-boost::python::tuple custom_coerce(PyObject* left, PyObject* right);
-PyObject* custom_coerce(PyObject* left, PyObject* right);
-</pre></blockquote>
-
-      The resulting <code>tuple</code> must contain two elements which
-      represent the values of <code>left</code> and <code>right</code>
-      converted to the same type. Such a function is wrapped as usual: 
-
-<blockquote><pre>
-// this must be called before any use of automatic operator  
-// wrapping or a call to some_class.def_standard_coerce()
-some_class.def(&amp;custom_coerce, "__coerce__");
-</pre></blockquote>
-
-     Note that the standard coercion (defined by use of automatic 
-     operator wrapping on a <code>class_builder</code> or a call to
-     <code>class_builder::def_standard_coerce()</code>) will never be applied if
-     a custom coercion function has been registered. Therefore, in 
-     your coercion function you should call 
-
-<blockquote><pre>
-boost::python::standard_coerce(left, right);
-</pre></blockquote>
-
-     for all cases that you don't want to handle yourself.
-
-<h3><a name="ternary_pow">The Ternary <code>pow()</code> Operator</a></h3>
-
-    <p>
-      In addition to the usual binary <code>pow(x, y)</code> operator (meaning
-      <i>x<sup>y</sup></i>), Python also provides a ternary variant that implements
-      <i>x<sup>y</sup> <b>mod</b> z</i>, presumably using a more efficient algorithm than
-      concatenation of power and modulo operators. Automatic operator wrapping
-      can only be used with the binary variant. Ternary <code>pow()</code> must
-      always be wrapped manually. For a homgeneous ternary <code>pow()</code>,
-      this is done as usual: 
-
-<blockquote><pre>
-BigNum power(BigNum const&amp; first, BigNum const&amp; second, BigNum const&amp; modulus);
-typedef BigNum (ternary_function1)(const BigNum&amp;, const BigNum&amp;, const BigNum&amp;);
-...
-bignum_class.def((ternary_function1)&amp;power,  "__pow__");
-</pre></blockquote>
-
-      If you want to support this function with non-uniform argument
-      types, wrapping is a little more involved. Suppose you have to wrap: 
-
-<blockquote><pre>
-BigNum power(BigNum const&amp; first, int second, int modulus);
-BigNum power(int first, BigNum const&amp; second, int modulus);
-BigNum power(int first, int second, BigNum const&amp; modulus);
-</pre></blockquote>
-
-      The first variant can be wrapped as usual: 
-
-<blockquote><pre>
-typedef BigNum (ternary_function2)(const BigNum&amp;, int, int);
-bignum_class.def((ternary_function2)&amp;power,  "__pow__");
-</pre></blockquote>
-
-      In the second variant, however, <code>BigNum</code> appears only as second
-      argument, and in the last one it's the third argument. These functions
-      must be presented to BPL such that that the <code>BigNum</code>
-      argument appears in first position:
-
-<blockquote><pre>
-BigNum rpower(BigNum const&amp; second, int first, int modulus)
-{
-    return power(first, second, modulus);
-}
-
-BigNum rrpower(BigNum const&amp; modulus, int first, int second)
-{
-    return power(first, second, modulus);
-}
-</pre></blockquote>
-
-<p>These functions must be wrapped under the names "__rpow__" and "__rrpow__"
- respectively:
-
-<blockquote><pre>
-bignum_class.def((ternary_function2)&amp;rpower,  "__rpow__");
-bignum_class.def((ternary_function2)&amp;rrpower,  "__rrpow__");
-</pre></blockquote>
-
-Note that "__rrpow__" is an extension not present in plain Python. 
-
-<h2><a name="numeric_table">Table of Automatically Wrapped Methods</a></h2>
-      <p>
-         BPL can automatically wrap the following <a href=
-         "http://www.pythonlabs.com/pub/www.python.org/doc/current/ref/specialnames.html">
-         special methods</a>:
-
-      <p>
-      <table summary="special numeric methods" cellpadding="5" border="1"
-      width="100%">
-        <tr>
-          <td align="center">
-            <b>Python Operator Name</b>
-          <td align="center">
-            <b>Python Expression</b>
-          <td align="center">
-            <b>C++ Operator Id</b>
-          <td align="center">
-            <b>C++ Expression Used For Automatic Wrapping</b><br>
-             with <code>cpp_left = from_python(left,
-            type&lt;Left&gt;())</code>,<br>
-             <code>cpp_right = from_python(right,
-            type&lt;Right&gt;())</code>,<br>
-             and <code>cpp_oper = from_python(oper, type&lt;Oper&gt;())</code>
-        <tr>
-          <td>
-            <code>__add__, __radd__</code>
-          <td>
-            <code>left + right</code>
-          <td>
-            <code>op_add</code>
-          <td>
-            <code>cpp_left + cpp_right</code>
-        <tr>
-          <td>
-            <code>__sub__, __rsub__</code>
-          <td>
-            <code>left - right</code>
-          <td>
-            <code>op_sub</code>
-          <td>
-            <code>cpp_left - cpp_right</code>
-        <tr>
-          <td>
-            <code>__mul__, __rmul__</code>
-          <td>
-            <code>left * right</code>
-          <td>
-            <code>op_mul</code>
-          <td>
-            <code>cpp_left * cpp_right</code>
-        <tr>
-          <td>
-            <code>__div__, __rdiv__</code>
-          <td>
-            <code>left / right</code>
-          <td>
-            <code>op_div</code>
-          <td>
-            <code>cpp_left / cpp_right</code>
-        <tr>
-          <td>
-            <code>__mod__, __rmod__</code>
-          <td>
-            <code>left % right</code>
-          <td>
-            <code>op_mod</code>
-          <td>
-            <code>cpp_left % cpp_right</code>
-        <tr>
-          <td>
-            <code>__divmod__, __rdivmod__</code>
-          <td>
-            <code>(quotient, remainder)<br>
-            = divmod(left, right)</code>
-          <td>
-            <code>op_divmod</code>
-          <td>
-            <code>cpp_left / cpp_right</code>
-        <br><code>cpp_left % cpp_right</code>
-        <tr>
-          <td>
-            <code>__pow__, __rpow__</code>
-          <td>
-            <code>pow(left, right)</code><br>
-             (binary power)
-          <td>
-            <code>op_pow</code>
-          <td>
-            <code>pow(cpp_left, cpp_right)</code>
-        <tr>
-          <td>
-            <code>__rrpow__</code>
-          <td>
-            <code>pow(left, right, modulo)</code><br>
-             (ternary power modulo)
-          <td colspan="2">
-            no automatic wrapping, <a href="#ternary_pow">special treatment</a>
-            required
-        <tr>
-          <td>
-            <code>__lshift__, __rlshift__</code>
-          <td>
-            <code>left &lt;&lt; right</code>
-          <td>
-            <code>op_lshift</code>
-          <td>
-            <code>cpp_left &lt;&lt; cpp_right</code>
-        <tr>
-          <td>
-            <code>__rshift__, __rrshift__</code>
-          <td>
-            <code>left &gt;&gt; right</code>
-          <td>
-            <code>op_rshift</code>
-          <td>
-            <code>cpp_left &gt;&gt; cpp_right</code>
-        <tr>
-          <td>
-            <code>__and__, __rand__</code>
-          <td>
-            <code>left &amp; right</code>
-          <td>
-            <code>op_and</code>
-          <td>
-            <code>cpp_left &amp; cpp_right</code>
-        <tr>
-          <td>
-            <code>__xor__, __rxor__</code>
-          <td>
-            <code>left ^ right</code>
-          <td>
-            <code>op_xor</code>
-          <td>
-            <code>cpp_left ^ cpp_right</code>
-        <tr>
-          <td>
-            <code>__or__, __ror__</code>
-          <td>
-            <code>left | right</code>
-          <td>
-            <code>op_or</code>
-          <td>
-            <code>cpp_left | cpp_right</code>
-
-        <tr>
-          <td>
-            <code>__cmp__, __rcmp__</code>
-          <td>
-            <code>cmp(left, right)</code><br>
-             <code>left &lt; right</code><br>
-             <code>left &lt;= right</code><br>
-             <code>left &gt; right</code><br>
-             <code>left &gt;= right</code><br>
-             <code>left == right</code><br>
-             <code>left != right</code>
-          <td>
-            <code>op_cmp</code>
-          <td>
-            <code>cpp_left &lt; cpp_right </code>
-        <br><code>cpp_right &lt; cpp_left</code>
-
-        <tr>
-          <td>
-            <code>__neg__</code>
-          <td>
-            <code>-oper </code> (unary negation)
-          <td>
-            <code>op_neg</code>
-          <td>
-            <code>-cpp_oper</code>
-        <tr>
-          <td>
-            <code>__pos__</code>
-          <td>
-            <code>+oper </code> (identity)
-          <td>
-            <code>op_pos</code>
-          <td>
-            <code>+cpp_oper</code>
-        <tr>
-          <td>
-            <code>__abs__</code>
-          <td>
-            <code>abs(oper) </code> (absolute value)
-          <td>
-            <code>op_abs</code>
-          <td>
-            <code>abs(cpp_oper)</code>
-        <tr>
-          <td>
-            <code>__invert__</code>
-          <td>
-            <code>~oper </code> (bitwise inversion)
-          <td>
-            <code>op_invert</code>
-          <td>
-            <code>~cpp_oper</code>
-        <tr>
-          <td>
-            <code>__int__</code>
-          <td>
-            <code>int(oper) </code> (integer conversion)
-          <td>
-            <code>op_int</code>
-          <td>
-            <code>long(cpp_oper)</code>
-        <tr>
-          <td>
-            <code>__long__</code>
-          <td>
-            <code>long(oper) </code><br>
-             (infinite precision integer conversion)
-          <td>
-            <code>op_long</code>
-          <td>
-            <code>PyLong_FromLong(cpp_oper)</code>
-        <tr>
-          <td>
-            <code>__float__</code>
-          <td>
-            <code>float(oper) </code> (float conversion)
-          <td>
-            <code>op_float</code>
-          <td>
-            <code>double(cpp_oper)</code>
-        <tr>
-          <td>
-            <code>__str__</code>
-          <td>
-            <code>str(oper) </code> (string conversion)
-          <td>
-            <code>op_str</code>
-          <td>
-            <code>std::ostringstream s; s &lt;&lt; oper;</code>
-        <tr>
-          <td>
-            <code>__coerce__</code>
-          <td>
-            <code>coerce(left, right)</code>
-          <td colspan="2">
-            usually defined automatically, otherwise <a href="#coercion">
-            special treatment</a> required
-      </table>
-
-<h2><a name="sequence_and_mapping">Sequence and Mapping Operators</a></h2>
-
-<p>
-      Sequence and mapping operators let wrapped objects behave in accordance
-      to Python's iteration and access protocols. These protocols differ
-      considerably from the ones found in C++. For example, Python's typical
-      iteration idiom looks like
-
-<blockquote><pre>
-for i in S:
-</pre></blockquote>
-
-      while in C++ one writes
-
-<blockquote><pre>
-for (iterator i = S.begin(), end = S.end(); i != end; ++i)
-</pre></blockquote>
-
-<p>One could try to wrap C++ iterators in order to carry the C++ idiom into
-      Python. However, this does not work very well because 
-
-<ol>
-<li>It leads to
-      non-uniform Python code (wrapped sequences support a usage different from 
-      Python built-in sequences) and 
-
-<li>Iterators (e.g. <code>std::vector::iterator</code>) are often implemented as plain C++
-      pointers which are <a href="pointers.html#problem">problematic</a> for any automatic
-      wrapping system.
-</ol>
-
-      <p>
-        It is a better idea to support the standard <a
-        href="http://www.pythonlabs.com/pub/www.python.org/doc/current/ref/sequence-types.html">Python
-        sequence and mapping protocols</a> for your wrapped containers. These
-        operators have to be wrapped manually because there are no corresponding
-        C++ operators that could be used for automatic wrapping. The Python
-        documentation lists the relevant <a href=
-        "http://www.pythonlabs.com/pub/www.python.org/doc/current/ref/sequence-types.html">
-        container operators</a>. In particular, expose __getitem__, __setitem__
-        and remember to raise the appropriate Python exceptions
-        (<code>PyExc_IndexError</code> for sequences,
-        <code>PyExc_KeyError</code> for mappings) when the requested item is not
-        present.
-
-      <p>
-        In the following example, we expose <code>std::map&lt;std::size_t,std::string&gt;</code>:
-      <blockquote>
-<pre>
-typedef std::map&lt;std::size_t, std::string&gt; StringMap;
-
-// A helper function for dealing with errors. Throw a Python exception
-// if p == m.end().
-void throw_key_error_if_end(
-        const StringMap&amp; m, 
-        StringMap::const_iterator p, 
-        std::size_t key)
-{
-    if (p == m.end())
-    {
-        PyErr_SetObject(PyExc_KeyError, boost::python::converters::to_python(key));
-        throw boost::python::error_already_set();
-    }
-}
-
-// Define some simple wrapper functions which match the Python  protocol
-// for __getitem__, __setitem__, and __delitem__.  Just as in Python, a
-// free function with a ``self'' first parameter makes a fine class method.
-
-const std::string&amp; get_item(const StringMap&amp; self, std::size_t key)
-{
-    const StringMap::const_iterator p = self.find(key);
-    throw_key_error_if_end(self, p, key);
-    return p-&gt;second;
-}
-
-// Sets the item corresponding to key in the map.
-void StringMapPythonClass::set_item(StringMap&amp; self, std::size_t key, const std::string&amp; value)
-{
-    self[key] = value;
-}
-
-// Deletes the item corresponding to key from the map.
-void StringMapPythonClass::del_item(StringMap&amp; self, std::size_t key)
-{
-    const StringMap::iterator p = self.find(key);
-    throw_key_error_if_end(self, p, key);
-    self.erase(p);
-}
-
-class_builder&lt;StringMap&gt; string_map(my_module, "StringMap");
-string_map.def(boost::python::constructor&lt;&gt;());
-string_map.def(&amp;StringMap::size, "__len__");
-string_map.def(get_item, "__getitem__");
-string_map.def(set_item, "__setitem__");
-string_map.def(del_item, "__delitem__");
-</pre>
-      </blockquote>
-      <p>
-         Then in Python:
-      <blockquote>
-<pre>
-&gt;&gt;&gt; m = StringMap()
-&gt;&gt;&gt; m[1]
-Traceback (innermost last):
-  File "&lt;stdin&gt;", line 1, in ?
-KeyError: 1
-&gt;&gt;&gt; m[1] = 'hello'
-&gt;&gt;&gt; m[1]
-'hello'
-&gt;&gt;&gt; del m[1]
-&gt;&gt;&gt; m[1]            # prove that it's gone
-Traceback (innermost last):
-  File "&lt;stdin&gt;", line 1, in ?
-KeyError: 1
-&gt;&gt;&gt; del m[2]
-Traceback (innermost last):
-  File "&lt;stdin&gt;", line 1, in ?
-KeyError: 2
-&gt;&gt;&gt; len(m)
-0
-&gt;&gt;&gt; m[0] = 'zero'
-&gt;&gt;&gt; m[1] = 'one'
-&gt;&gt;&gt; m[2] = 'two'
-&gt;&gt;&gt; m[3] = 'three'
-&gt;&gt;&gt; len(m)
-4
-</pre>
-      </blockquote>
-
-<h2><a name="getter_setter">Customized Attribute Access</a></h2>
-
-      <p>
-        Just like built-in Python classes, BPL extension classes support <a
-        href="http://www.pythonlabs.com/pub/www.python.org/doc/current/ref/attribute-access.html">special
-        the usual attribute access methods</a> <code>__getattr__</code>,
-        <code>__setattr__</code>, and <code>__delattr__</code>.
-        Because writing these functions can
-        be tedious in the common case where the attributes being accessed are
-        known statically, BPL checks the special names
-
-      <ul>
-        <li>
-          <code>__getattr__<em>&lt;name&gt;</em>__</code>
-        <li>
-          <code>__setattr__<em>&lt;name&gt;</em>__</code>
-        <li>
-          <code>__delattr__<em>&lt;name&gt;</em>__</code>
-      </ul>
-
-      to provide functional access to the attribute <em>&lt;name&gt;</em>. 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: 
-      <blockquote>
-<pre>
-&gt;&gt;&gt; class Range(AnyBPLExtensionClass):
-...    def __init__(self, start, end):
-...        self.start = start
-...        self.end = end
-...    def __getattr__length__(self):
-...        return self.end - self.start
-...
-&gt;&gt;&gt; x = Range(3, 9)
-&gt;&gt;&gt; x.length
-6
-</pre>
-      </blockquote>
-      <h4>
-         Direct Access to Data Members
-      </h4>
-      <p>
-         BPL uses the special <code>
-        __xxxattr__<em>&lt;name&gt;</em>__</code> functionality described above
-        to allow direct access to data members through the following special
-        functions on <code>class_builder&lt;&gt;</code> and <code>
-        extension_class&lt;&gt;</code>:
-      <ul>
-        <li>
-          <code>def_getter(<em>pointer-to-member</em>, <em>name</em>)</code> //
-          read access to the member via attribute <em>name</em>
-        <li>
-          <code>def_setter(<em>pointer-to-member</em>, <em>name</em>)</code> //
-          write access to the member via attribute <em>name</em>
-        <li>
-          <code>def_readonly(<em>pointer-to-member</em>, <em>name</em>)</code>
-          // read-only access to the member via attribute <em>name</em>
-        <li>
-          <code>def_read_write(<em>pointer-to-member</em>, <em>
-          name</em>)</code> // read/write access to the member via attribute
-          <em>name</em>
-      </ul>
-      <p>
-         Note that the first two functions, used alone, may produce surprising
-        behavior. For example, when <code>def_getter()</code> is used, the
-        default functionality for <code>setattr()</code> and <code>
-        delattr()</code> remains in effect, operating on items in the extension
-        instance's name-space (i.e., its <code>__dict__</code>). For that
-        reason, you'll usually want to stick with <code>def_readonly</code> and
-        <code>def_read_write</code>.
-      <p>
-         For example, to expose a <code>std::pair&lt;int,long&gt;</code> we
-        might write:
-      <blockquote>
-<pre>
-typedef std::pair&lt;int,long&gt; Pil;
-int first(const Pil&amp; x) { return x.first; }
-long second(const Pil&amp; x) { return x.second; }
-   ...
-my_module.def(first, "first");
-my_module.def(second, "second");
-
-class_builder&lt;Pil&gt; pair_int_long(my_module, "Pair");
-pair_int_long.def(boost::python::constructor&lt;&gt;());
-pair_int_long.def(boost::python::constructor&lt;int,long&gt;());
-pair_int_long.def_read_write(&amp;Pil::first, "first");
-pair_int_long.def_read_write(&amp;Pil::second, "second");
-</pre>
-      </blockquote>
-      <p>
-         Now your Python class has attributes <code>first</code> and <code>
-        second</code> which, when accessed, actually modify or reflect the
-        values of corresponding data members of the underlying C++ object. Now
-        in Python:
-      <blockquote>
-<pre>
-&gt;&gt;&gt; x = Pair(3,5)
-&gt;&gt;&gt; x.first
-3
-&gt;&gt;&gt; x.second
-5
-&gt;&gt;&gt; x.second = 8
-&gt;&gt;&gt; x.second
-8
-&gt;&gt;&gt; second(x) # Prove that we're not just changing the instance __dict__
-8
-</pre>
-      </blockquote>
-      <h2>
-        <a name="reasons">And what about <code>__complex__</code>?</a>
-      </h2>
-      <p>
-        That, dear reader, is one problem we don't know how to solve. The
-        Python source contains the following fragment, indicating the
-        special-case code really is hardwired:
-      <blockquote>
-<pre>
-/* XXX Hack to support classes with __complex__ method */
-if (PyInstance_Check(r)) { ...
-</pre>
-      </blockquote>
-      <p>
-Next: <a href="under-the-hood.html">A Peek Under the Hood</a>
-Previous: <a href="inheritance.html">Inheritance</a> 
-Up: <a href= "index.html">Top</a>
-      <p>
-         &copy; Copyright David Abrahams and Ullrich K&ouml;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
-        warranty, and with no claim as to its suitability for any purpose.
-      <p>
-         Updated: Nov 26, 2000
-    </div>
-

doc/template.html

@@ -1,26 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN"
-"http://www.w3.org/TR/REC-html40/strict.dtd">
-    <title>
-      The Title Of This Page
-    </title>
-    <div>
-      <h1>
-         <img width="277" height="86" id="_x0000_i1025" align="center"
-        src="../../../c++boost.gif" alt= "c++boost.gif (8819 bytes)">The Title Of This
-        Page
-      </h1>
-      <p>
-      <p>
-         Prev: <a href="prev.html">Previous</a>
-         Next: <a href="next.html">Next</a>
-         Up: <a href="index.html">Top</a>
-      <p>
-         &copy; Copyright David Abrahams 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 warranty, and with no claim as to its suitability
-        for any purpose.
-      <p>
-         Updated: Nov 26, 2000
-    </div>
-

doc/under-the-hood.html

@@ -1,62 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
-    <meta http-equiv="Content-Type" content="text/html; charset=windows-1252">
-    <title>
-      A Peek Under the Hood
-    </title>
-    <h1>
-      <img src="../../../c++boost.gif" alt="c++boost.gif (8819 bytes)" align="center"
-      width="277" height="86">
-    </h1>
-    <h1>
-      A Peek Under the Hood
-    </h1>
-    <p>
-      Declaring a <code>class_builder&lt;T&gt;</code> causes the instantiation
-      of an <code>extension_class&lt;T&gt;</code> to which it forwards all
-      member function calls and which is doing most of the real work.
-      <code>extension_class&lt;T&gt;</code> is a subclass of <code>
-      PyTypeObject</code>, the <code> struct</code> which Python's 'C' API uses
-      to describe a type. <a href="example1.html#world_class">An instance of the
-      <code>extension_class&lt;&gt;</code></a> becomes the Python type object
-      corresponding to <code>hello::world</code>. When we <a href=
-      "example1.html#add_world_class">add it to the module</a> it goes into the
-      module's dictionary to be looked up under the name "world".
-    <p>
-      BPL uses C++'s template argument deduction mechanism to determine the
-      types of arguments to functions (except constructors, for which we must
-      <a href="example1.html#Constructor_example">provide an argument list</a>
-      because they can't be named in C++). Then, it calls the appropriate
-      overloaded functions <code>PyObject*
-      to_python(</code><em>S</em><code>)</code> and <em>
-      S'</em><code>from_python(PyObject*,
-      type&lt;</code><em>S</em><code>&gt;)</code> which convert between any C++
-      type <em>S</em> and a <code>PyObject*</code>, the type which represents a
-      reference to any Python object in its 'C' API. The <a href= 
-      "example1.html#world_class"><code>extension_class&lt;T&gt;</code></a>
-      template defines a whole raft of these conversions (for <code>T, T*,
-      T&amp;, std::auto_ptr&lt;T&gt;</code>, etc.), using the same inline
-      friend function technique employed by <a href= 
-      "http://www.boost.org/libs/utility/operators.htm">the boost operators
-      library</a>.
-    <p>
-      Because the <code>to_python</code> and <code>from_python</code> functions
-      for a user-defined class are defined by <code>
-      extension_class&lt;T&gt;</code>, it is important that an instantiation of
-      <code> extension_class&lt;T&gt;</code> is visible to any code which wraps
-      a C++ function with a <code>T, T*, const T&amp;</code>, etc. parameter or
-      return value. In particular, you may want to create all of the classes at
-      the top of your module's init function, then <code>def</code> the member
-      functions later to avoid problems with inter-class dependencies.
-    <p>
-      Next: <a href="building.html">Building a Module with BPL</a>
-      Previous: <a href="special.html">Special Method and Operator Support</a>
-      Up: <a href="index.html">Top</a>
-    <p>
-      &copy; Copyright David Abrahams 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 warranty, and with no claim as to its suitability for
-      any purpose.
-    <p>
-      Updated: Nov 26, 2000
-

example/example1.cpp

@@ -1,54 +0,0 @@
-#include <string.h>
-
-namespace hello {
-  class world
-  {
-   public:
-      world(int) {}
-      ~world() {}
-      const char* get() const { return "hi, world"; }
-  };
-
-  size_t length(const world& x) { return strlen(x.get()); }
-}
-
-#include <boost/python/class_builder.hpp>
-
-// Python requires an exported function called init<module-name> in every
-// extension module. This is where we build the module contents.
-extern "C"
-#ifdef _WIN32
-__declspec(dllexport)
-#endif
-void inithello()
-{
-    try
-    {
-       // create an object representing this extension module
-       boost::python::module_builder hello("hello");
-
-       // Create the Python type object for our extension class
-       boost::python::class_builder<hello::world> world_class(hello, "world");
-
-       // Add the __init__ function
-       world_class.def(boost::python::constructor<int>());
-       // Add a regular member function
-       world_class.def(&hello::world::get, "get");
-
-       // Add a regular function to the module
-       hello.def(hello::length, "length");
-    }
-    catch(...)
-    {
-       boost::python::handle_exception();    // Deal with the exception for Python
-    }
-}
-
-// Win32 DLL boilerplate
-#if defined(_WIN32)
-#include <windows.h>
-extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID)
-{
-    return 1;
-}
-#endif // _WIN32

example/rwgk1.cpp

@@ -1,41 +0,0 @@
-#include <string>
-
-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 <boost/python/class_builder.hpp>
-
-namespace python = boost::python;
-
-// Python requires an exported function called init<module-name> 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 <windows.h>
-extern "C" BOOL WINAPI DllMain(HINSTANCE, DWORD, LPVOID) { return 1; }
-#endif // _WIN32

example/test_example1.py

@@ -1,50 +0,0 @@
-r'''
-//  (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.
-
-That's it! If we build this shared library and put it on our PYTHONPATH we can
-now access our C++ class and function from Python.
-
-    >>> import hello
-    >>> hi_world = hello.world(3)
-    >>> hi_world.get()
-    'hi, world'
-    >>> hello.length(hi_world)
-    9
-
-We can even make a subclass of hello.world:
-
-
-    >>> class my_subclass(hello.world):
-    ...     def get(self):
-    ...         return 'hello, world'
-    ...
-    >>> y = my_subclass(2)
-    >>> y.get()
-    'hello, world'
-
-Pretty cool! You can't do that with an ordinary Python extension type!
-
-    >>> hello.length(y)
-    9
-
-Of course, you may now have a slightly empty feeling in the pit of your little
-pythonic stomach. Perhaps you feel your subclass deserves to have a length() of
-12? If so, read on...
-'''
-from hello import *
-
-def run(args = None):
-    if args is not None:
-        import sys
-        sys.argv = args
-    import doctest, test_example1
-    doctest.testmod(test_example1)
-    
-if __name__ == '__main__':
-    run()

example/test_rwgk1.py

@@ -1,17 +0,0 @@
-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()

include/boost/python/callback.hpp

@@ -1,829 +0,0 @@
-//  (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 was generated for 10-argument python callbacks by gen_callback.python
-
-#ifndef CALLBACK_DWA_052100_H_
-# define CALLBACK_DWA_052100_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/conversions.hpp>
-
-namespace boost { namespace python {
-
-namespace detail {
-  template <class T>
-  inline void callback_adjust_refcount(PyObject*, type<T>) {}
-  
-  inline void callback_adjust_refcount(PyObject* p, type<PyObject*>)
-      { Py_INCREF(p); }
-}
-
-// Calling Python from C++
-template <class R>
-struct callback
-{
-    static R call_method(PyObject* self, const char* name)
-    {
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("()")));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    static R call(PyObject* self)
-    {
-        ref result(PyEval_CallFunction(self, const_cast<char*>("()")));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1>
-    static R call_method(PyObject* self, const char* name, const A1& a1)
-    {
-        ref p1(to_python(a1));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(O)"),
-                                     p1.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1>
-    static R call(PyObject* self, const A1& a1)
-    {
-        ref p1(to_python(a1));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(O)"),
-                                       p1.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OO)"),
-                                     p1.get(),
-                                     p2.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2>
-    static R call(PyObject* self, const A1& a1, const A2& a2)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
-                                       p1.get(),
-                                       p2.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get(),
-                                     p8.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get(),
-                                       p8.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get(),
-                                     p8.get(),
-                                     p9.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get(),
-                                       p8.get(),
-                                       p9.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static R call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref p10(to_python(a10));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get(),
-                                     p8.get(),
-                                     p9.get(),
-                                     p10.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static R call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref p10(to_python(a10));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get(),
-                                       p8.get(),
-                                       p9.get(),
-                                       p10.get()));
-        detail::callback_adjust_refcount(result.get(), type<R>());
-        return from_python(result.get(), type<R>());
-    }
-};
-
-// This specialization wouldn't be needed, but MSVC6 doesn't correctly allow the following:
-// void g();
-// void f() { return g(); }
-template <>
-struct callback<void>
-{
-
-    static void call_method(PyObject* self, const char* name)
-    {
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("()")));
-    }
-
-    static void call(PyObject* self)
-    {
-        ref result(PyEval_CallFunction(self, const_cast<char*>("()")));
-    }
-
-    template <class A1>
-    static void call_method(PyObject* self, const char* name, const A1& a1)
-    {
-        ref p1(to_python(a1));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(O)"),
-                                     p1.get()));
-    }
-
-    template <class A1>
-    static void call(PyObject* self, const A1& a1)
-    {
-        ref p1(to_python(a1));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(O)"),
-                                       p1.get()));
-    }
-
-    template <class A1, class A2>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OO)"),
-                                     p1.get(),
-                                     p2.get()));
-    }
-
-    template <class A1, class A2>
-    static void call(PyObject* self, const A1& a1, const A2& a2)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OO)"),
-                                       p1.get(),
-                                       p2.get()));
-    }
-
-    template <class A1, class A2, class A3>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get()));
-    }
-
-    template <class A1, class A2, class A3>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get(),
-                                     p8.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get(),
-                                       p8.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get(),
-                                     p8.get(),
-                                     p9.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get(),
-                                       p8.get(),
-                                       p9.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static void call_method(PyObject* self, const char* name, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref p10(to_python(a10));
-        ref result(PyEval_CallMethod(self, const_cast<char*>(name),
-                                     const_cast<char*>("(OOOOOOOOOO)"),
-                                     p1.get(),
-                                     p2.get(),
-                                     p3.get(),
-                                     p4.get(),
-                                     p5.get(),
-                                     p6.get(),
-                                     p7.get(),
-                                     p8.get(),
-                                     p9.get(),
-                                     p10.get()));
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static void call(PyObject* self, const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10)
-    {
-        ref p1(to_python(a1));
-        ref p2(to_python(a2));
-        ref p3(to_python(a3));
-        ref p4(to_python(a4));
-        ref p5(to_python(a5));
-        ref p6(to_python(a6));
-        ref p7(to_python(a7));
-        ref p8(to_python(a8));
-        ref p9(to_python(a9));
-        ref p10(to_python(a10));
-        ref result(PyEval_CallFunction(self, const_cast<char*>("(OOOOOOOOOO)"),
-                                       p1.get(),
-                                       p2.get(),
-                                       p3.get(),
-                                       p4.get(),
-                                       p5.get(),
-                                       p6.get(),
-                                       p7.get(),
-                                       p8.get(),
-                                       p9.get(),
-                                       p10.get()));
-    }
-};
-
-// Make it a compile-time error to try to return a const char* from a virtual
-// function. The standard conversion
-//
-//      from_python(PyObject* string, boost::python::type<const char*>)
-//
-// returns a pointer to the character array which is internal to string. The
-// problem with trying to do this in a standard callback function is that the
-// Python string would likely be destroyed upon return from the calling function
-// (boost::python::callback<const char*>::call[_method]) when its reference count is
-// decremented. If you absolutely need to do this and you're sure it's safe (it
-// usually isn't), you can use
-//
-//      boost::python::string result(boost::python::callback<boost::python::string>::call[_method](...args...));
-//      ...result.c_str()... // access the char* array
-template <>
-struct callback<const char*>
-{
-    // Try hard to generate a readable error message
-    typedef struct unsafe_since_python_string_may_be_destroyed {} call, call_method;
-};
-
-}} // namespace boost::python
-
-#endif // CALLBACK_DWA_052100_H_

include/boost/python/class_builder.hpp

@@ -1,156 +0,0 @@
-#ifndef CLASS_WRAPPER_DWA101000_H_
-# define CLASS_WRAPPER_DWA101000_H_
-
-#include <boost/python/detail/extension_class.hpp>
-#include <boost/python/operators.hpp>
-#include <boost/python/module_builder.hpp>
-#include <boost/python/conversions.hpp>
-#include <boost/python/detail/cast.hpp>
-#include <boost/python/reference.hpp>
-
-namespace boost { namespace python {
-
-// Syntactic sugar to make wrapping classes more convenient
-template <class T, class U = detail::held_instance<T> >
-class class_builder
-    : python_extension_class_converters<T, U> // Works around MSVC6.x/GCC2.95.2 bug described below
-{
- public:
-    class_builder(module_builder& module, const char* name)
-        : m_class(new detail::extension_class<T, U>(name))
-    {
-        module.add(ref(as_object(m_class.get()), ref::increment_count), name);
-    }
-    
-    ~class_builder()
-    {}
-    
-    // define constructors
-    template <class signature>
-    void def(const signature& s)
-        { m_class->def(s); }
-
-    // export heterogeneous reverse-argument operators 
-    // (type of lhs: 'left', of rhs: 'right')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub), Foo>(),
-    //                       boost::python::left_operand<int const &>());
-    template <long which, class left, class right>
-    void def(operators<which, right> o1, left_operand<left> o2)
-        { m_class->def(o1, o2); }
-
-    // export heterogeneous operators (type of lhs: 'left', of rhs: 'right')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub), Foo>(),
-    //                       boost::python::right_operand<int const &>());
-    template <long which, class left, class right>
-    void def(operators<which, left> o1, right_operand<right> o2)
-        { m_class->def(o1, o2); }
-
-    // define a function that passes Python arguments and keywords
-    // to C++ verbatim (as a 'tuple const &' and 'dictionary const &' 
-    // respectively). This is useful for manual argument passing.
-    // It's also the only possibility to pass keyword arguments to C++.
-    // Fn must have a signatur that is compatible to 
-    //     PyObject * (*)(PyObject * aTuple, PyObject * aDictionary)
-    template <class Fn>
-    void def_raw(Fn fn, const char* name)
-        { m_class->def_raw(fn, name); }
-
-    // define member functions. In fact this works for free functions, too -
-    // they act like static member functions, or if they start with the
-    // appropriate self argument (as a pointer or reference), they can be used
-    // just like ordinary member functions -- just like Python!
-    template <class Fn>
-    void def(Fn fn, const char* name)
-        { m_class->def(fn, name); }
-
-    // Define a virtual member function with a default implementation.
-    // default_fn should be a function which provides the default implementation.
-    // Be careful that default_fn does not in fact call fn virtually!
-    template <class Fn, class DefaultFn>
-    void def(Fn fn, const char* name, DefaultFn default_fn)
-        { m_class->def(fn, name, default_fn); }
-
-    // Provide a function which implements x.<name>, reading from the given
-    // member (pm) of the T obj
-    template <class MemberType>
-    void def_getter(MemberType T::*pm, const char* name)
-        { m_class->def_getter(pm, name); }
-    
-    // Provide a function which implements assignment to x.<name>, writing to
-    // the given member (pm) of the T obj
-    template <class MemberType>
-    void def_setter(MemberType T::*pm, const char* name)
-        { m_class->def_getter(pm, name); }
-    
-    // Expose the given member (pm) of the T obj as a read-only attribute
-    template <class MemberType>
-    void def_readonly(MemberType T::*pm, const char* name)
-        { m_class->def_readonly(pm, name); }
-    
-    // Expose the given member (pm) of the T obj as a read/write attribute
-    template <class MemberType>
-    void def_read_write(MemberType T::*pm, const char* name)
-        { m_class->def_read_write(pm, name); }
-        
-    // define the standard coercion needed for operator overloading
-    void def_standard_coerce()
-        { m_class->def_standard_coerce(); }
-    
-    // declare the given class a base class of this one and register 
-    // conversion functions
-    template <class S, class V>
-    void declare_base(class_builder<S, V> const & base)
-    {
-        m_class->declare_base(base.get_extension_class());
-    }
-
-    // declare the given class a base class of this one and register 
-    // upcast conversion function
-    template <class S, class V>
-    void declare_base(class_builder<S, V> const & base, without_downcast_t)
-    {
-        m_class->declare_base(base.get_extension_class(), without_downcast);
-    }
-
-    // get the embedded ExtensioClass object
-    detail::extension_class<T, U> * get_extension_class() const 
-    {
-        return m_class.get();
-    }
-
-    // set an arbitrary attribute. Useful for non-function class data members,
-    // e.g. enums
-    void add(PyObject* x, const char* name)
-        { m_class->set_attribute(name, x); }
-    void add(ref x, const char* name)
-        { m_class->set_attribute(name, x); }
- private:
-    // declare the given class a base class of this one and register 
-    // conversion functions
-    template <class S, class V>
-    void declare_base(detail::extension_class<S, V> * base)
-    {
-        m_class->declare_base(base);
-    }
-        
-    // declare the given class a base class of this one and register 
-    // upcast conversion function
-    template <class S, class V>
-    void declare_base(detail::extension_class<S, V> * base, without_downcast_t)
-    {
-        m_class->declare_base(base, without_downcast);
-    }
-    
-    reference<detail::extension_class<T, U> > m_class;
-};
-
-// The bug mentioned at the top of this file is that on certain compilers static
-// global functions declared within the body of a class template will only be
-// generated when the class template is constructed, and when (for some reason)
-// the construction does not occur via a new-expression. Otherwise, we could
-// rely on the initialization of the m_class data member to cause all of the
-// to_/from_python functions to come into being.
-
-}} // namespace boost::python
-
-#endif // CLASS_WRAPPER_DWA101000_H_

include/boost/python/classes.hpp

@@ -1,527 +0,0 @@
-//  (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.
-
-#ifndef SUBCLASS_DWA051500_H_
-# define SUBCLASS_DWA051500_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/types.hpp>
-# include <boost/python/objects.hpp>
-# include <boost/python/detail/singleton.hpp>
-# include <boost/utility.hpp>
-# include <boost/python/conversions.hpp>
-# include <boost/python/callback.hpp>
-
-namespace boost { namespace python {
-
-// A simple type which acts something like a built-in Python class obj.
-class instance
-    : public boost::python::detail::python_object
-{
- public:
-    instance(PyTypeObject* class_);
-    ~instance();
-
-    // Standard Python functions.
-    PyObject* repr();
-    int compare(PyObject*);
-    PyObject* str();
-    long hash();
-    PyObject* call(PyObject* args, PyObject* keywords);
-    PyObject* getattr(const char* name, bool use_special_function = true);
-    int setattr(const char* name, PyObject* value);
-
-    // Mapping methods
-    int length();
-    PyObject* get_subscript(PyObject* key);
-    void set_subscript(PyObject* key, PyObject* value);
-
-    // Sequence methods
-    PyObject* get_slice(int start, int finish);
-    void set_slice(int start, int finish, PyObject* value);
-
-    // Number methods
-    PyObject* add(PyObject* other);
-    PyObject* subtract(PyObject* other);
-    PyObject* multiply(PyObject* other);
-    PyObject* divide(PyObject* other);
-    PyObject* remainder(PyObject* other);
-    PyObject* divmod(PyObject* other);
-    PyObject* power(PyObject*, PyObject*);
-    PyObject* negative();
-    PyObject* positive();
-    PyObject* absolute();
-    int nonzero();
-    PyObject* invert();
-    PyObject* lshift(PyObject* other);
-    PyObject* rshift(PyObject* other);
-    PyObject* do_and(PyObject* other);
-    PyObject* do_xor(PyObject* other);
-    PyObject* do_or(PyObject* other);
-    int coerce(PyObject**, PyObject**);
-    PyObject* as_int();
-    PyObject* as_long();
-    PyObject* as_float();
-    PyObject* oct();
-    PyObject* hex();
-
- private: // noncopyable, without the size bloat
-    instance(const instance&);
-    void operator=(const instance&);
-
- private: // helper functions
-    int setattr_dict(PyObject* value);
-    
- private:
-    dictionary m_name_space;
-};
-
-template <class T> class meta_class;
-
-namespace detail {
-  class class_base : public type_object_base
-  {
-   public:
-      class_base(PyTypeObject* meta_class_obj, string name, tuple bases, const dictionary& name_space);
-      tuple bases() const;
-      string name() const;
-      dictionary& dict();
-      
-      // Standard Python functions.
-      PyObject* getattr(const char* name);
-      int setattr(const char* name, PyObject* value);
-      PyObject* repr() const;
-      void add_base(ref base);
-
-   protected:
-      bool initialize_instance(instance* obj, PyObject* args, PyObject* keywords);
-
-   private: // virtual functions
-      // Subclasses should override this to delete the particular obj type
-      virtual void delete_instance(PyObject*) const = 0;
-
-   private: // boost::python::type_object_base required interface implementation
-      void instance_dealloc(PyObject*) const; // subclasses should not override this
-      
-   private:
-      string m_name;
-      tuple m_bases;
-      dictionary m_name_space;
-  };
-
-  void enable_named_method(class_base* type_obj, const char* name);
-}
-
-// A type which acts a lot like a built-in Python class. T is the obj type,
-// so class_t<instance> is a very simple "class-alike".
-template <class T>
-class class_t
-    : public boost::python::detail::class_base
-{
- public:
-    class_t(meta_class<T>* meta_class_obj, string name, tuple bases, const dictionary& name_space);
-    
-    // Standard Python functions.
-    PyObject* call(PyObject* args, PyObject* keywords);
-    
- private: // Implement mapping methods on instances
-    PyObject* instance_repr(PyObject*) const;
-    int instance_compare(PyObject*, PyObject* other) const;
-    PyObject* instance_str(PyObject*) const;
-    long instance_hash(PyObject*) const;
-    int instance_mapping_length(PyObject*) const;
-    PyObject* instance_mapping_subscript(PyObject*, PyObject*) const;
-    int instance_mapping_ass_subscript(PyObject*, PyObject*, PyObject*) const;
-
- private: // Implement sequence methods on instances
-    int instance_sequence_length(PyObject*) const;
-    PyObject* instance_sequence_item(PyObject* obj, int n) const;
-    int instance_sequence_ass_item(PyObject* obj, int n, PyObject* value) const;
-    PyObject* instance_sequence_slice(PyObject*, int start, int finish) const;
-    int instance_sequence_ass_slice(PyObject*, int start, int finish, PyObject* value) const;
-
- private: // Implement number methods on instances
-    PyObject* instance_number_add(PyObject*, PyObject*) const;
-    PyObject* instance_number_subtract(PyObject*, PyObject*) const;
-    PyObject* instance_number_multiply(PyObject*, PyObject*) const;
-    PyObject* instance_number_divide(PyObject*, PyObject*) const;
-    PyObject* instance_number_remainder(PyObject*, PyObject*) const;
-    PyObject* instance_number_divmod(PyObject*, PyObject*) const;
-    PyObject* instance_number_power(PyObject*, PyObject*, PyObject*) const;
-    PyObject* instance_number_negative(PyObject*) const;
-    PyObject* instance_number_positive(PyObject*) const;
-    PyObject* instance_number_absolute(PyObject*) const;
-    int instance_number_nonzero(PyObject*) const;
-    PyObject* instance_number_invert(PyObject*) const;
-    PyObject* instance_number_lshift(PyObject*, PyObject*) const;
-    PyObject* instance_number_rshift(PyObject*, PyObject*) const;
-    PyObject* instance_number_and(PyObject*, PyObject*) const;
-    PyObject* instance_number_xor(PyObject*, PyObject*) const;
-    PyObject* instance_number_or(PyObject*, PyObject*) const;
-    int instance_number_coerce(PyObject*, PyObject**, PyObject**) const;
-    PyObject* instance_number_int(PyObject*) const;
-    PyObject* instance_number_long(PyObject*) const;
-    PyObject* instance_number_float(PyObject*) const;
-    PyObject* instance_number_oct(PyObject*) const;
-    PyObject* instance_number_hex(PyObject*) const;
-    
- private: // Miscellaneous "special" methods
-    PyObject* instance_call(PyObject* obj, PyObject* args, PyObject* keywords) const;
-    PyObject* instance_getattr(PyObject* obj, const char* name) const;
-    int instance_setattr(PyObject* obj, const char* name, PyObject* value) const;
-
- private: // Implementation of boost::python::detail::class_base required interface
-    void delete_instance(PyObject*) const;
-    
- private: // noncopyable, without the size bloat
-    class_t(const class_t<T>&);
-    void operator=(const class_t&);
-};
-
-// The type of a class_t<T> object.
-template <class T>
-class meta_class
-    : public boost::python::detail::reprable<
-                boost::python::detail::callable<
-                   boost::python::detail::getattrable<
-                      boost::python::detail::setattrable<
-                         boost::python::detail::type_object<class_t<T> > > > > >,
-      boost::noncopyable
-{
- public:
-    meta_class();
-
-    // Standard Python functions.
-    PyObject* call(PyObject* args, PyObject* keywords);
-    
-    struct type_object
-        : boost::python::detail::singleton<type_object,
-             boost::python::detail::callable<
-                boost::python::detail::type_object<meta_class> > >
-    {
-        type_object() : singleton_base(&PyType_Type) {}
-    };
-};
-
-//
-// Member function implementations.
-//
-template <class T>
-meta_class<T>::meta_class()
-    : properties(type_object::instance())
-{
-} 
-
-template <class T>
-class_t<T>::class_t(meta_class<T>* meta_class_obj, string name, tuple bases, const dictionary& name_space)
-    : boost::python::detail::class_base(meta_class_obj, name, bases, name_space)
-{
-}
-
-template <class T>
-void class_t<T>::delete_instance(PyObject* obj) const
-{
-    delete downcast<T>(obj);
-}
-
-template <class T>
-PyObject* class_t<T>::call(PyObject* args, PyObject* keywords)
-{
-    reference<T> result(new T(this));
-    if (!this->initialize_instance(result.get(), args, keywords))
-        return 0;
-    else
-        return result.release();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_repr(PyObject* obj) const
-{
-    return downcast<T>(obj)->repr();
-}
-
-template <class T>
-int class_t<T>::instance_compare(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->compare(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_str(PyObject* obj) const
-{
-    return downcast<T>(obj)->str();
-}
-
-template <class T>
-long class_t<T>::instance_hash(PyObject* obj) const
-{
-    return downcast<T>(obj)->hash();
-}
-
-template <class T>
-int class_t<T>::instance_mapping_length(PyObject* obj) const
-{
-    return downcast<T>(obj)->length();
-}
-
-template <class T>
-int class_t<T>::instance_sequence_length(PyObject* obj) const
-{
-    return downcast<T>(obj)->length();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_mapping_subscript(PyObject* obj, PyObject* key) const
-{
-    return downcast<T>(obj)->get_subscript(key);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_sequence_item(PyObject* obj, int n) const
-{
-    ref key(to_python(n));
-    return downcast<T>(obj)->get_subscript(key.get());
-}
-
-template <class T>
-int class_t<T>::instance_sequence_ass_item(PyObject* obj, int n, PyObject* value) const
-{
-    ref key(to_python(n));
-    downcast<T>(obj)->set_subscript(key.get(), value);
-    return 0;
-}
-
-template <class T>
-int class_t<T>::instance_mapping_ass_subscript(PyObject* obj, PyObject* key, PyObject* value) const
-{
-    downcast<T>(obj)->set_subscript(key, value);
-    return 0;
-}
-
-void adjust_slice_indices(PyObject* obj, int& start, int& finish);
-
-template <class T>
-PyObject* class_t<T>::instance_sequence_slice(PyObject* obj, int start, int finish) const
-{
-    adjust_slice_indices(obj, start, finish);    
-    return downcast<T>(obj)->get_slice(start, finish);
-}
-
-template <class T>
-int class_t<T>::instance_sequence_ass_slice(PyObject* obj, int start, int finish, PyObject* value) const
-{
-    adjust_slice_indices(obj, start, finish);
-    downcast<T>(obj)->set_slice(start, finish, value);
-    return 0;
-}
-
-template <class T>
-PyObject* class_t<T>::instance_call(PyObject* obj, PyObject* args, PyObject* keywords) const
-{
-    return downcast<T>(obj)->call(args, keywords);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_getattr(PyObject* obj, const char* name) const
-{
-    return downcast<T>(obj)->getattr(name);
-}
-
-
-template <class T>
-int class_t<T>::instance_setattr(PyObject* obj, const char* name, PyObject* value) const
-{
-    return downcast<T>(obj)->setattr(name, value);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_add(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->add(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_subtract(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->subtract(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_multiply(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->multiply(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_divide(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->divide(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_remainder(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->remainder(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_divmod(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->divmod(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_power(PyObject* obj, PyObject* exponent, PyObject* modulus) const
-{
-    return downcast<T>(obj)->power(exponent, modulus);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_negative(PyObject* obj) const
-{
-    return downcast<T>(obj)->negative();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_positive(PyObject* obj) const
-{
-    return downcast<T>(obj)->positive();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_absolute(PyObject* obj) const
-{
-    return downcast<T>(obj)->absolute();
-}
-
-template <class T>
-int class_t<T>::instance_number_nonzero(PyObject* obj) const
-{
-    return downcast<T>(obj)->nonzero();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_invert(PyObject* obj) const
-{
-    return downcast<T>(obj)->invert();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_lshift(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->lshift(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_rshift(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->rshift(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_and(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->do_and(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_xor(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->do_xor(other);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_or(PyObject* obj, PyObject* other) const
-{
-    return downcast<T>(obj)->do_or(other);
-}
-
-template <class T>
-int class_t<T>::instance_number_coerce(PyObject* obj, PyObject** x, PyObject** y) const
-{
-    return downcast<T>(obj)->coerce(x, y);
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_int(PyObject* obj) const
-{
-    return downcast<T>(obj)->as_int();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_long(PyObject* obj) const
-{
-    return downcast<T>(obj)->as_long();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_float(PyObject* obj) const
-{
-    return downcast<T>(obj)->as_float();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_oct(PyObject* obj) const
-{
-    return downcast<T>(obj)->oct();
-}
-
-template <class T>
-PyObject* class_t<T>::instance_number_hex(PyObject* obj) const
-{
-    return downcast<T>(obj)->hex();
-}
-
-namespace detail {
-  inline dictionary& class_base::dict()
-  {
-      return m_name_space;
-  }
-
-  inline tuple class_base::bases() const
-  {
-      return m_bases;
-  }
-}
-
-template <class T>
-PyObject* meta_class<T>::call(PyObject* args, PyObject* /*keywords*/)
-{
-    PyObject* name;
-    PyObject* bases;
-    PyObject* name_space;
-    
-    if (!PyArg_ParseTuple(args, const_cast<char*>("O!O!O!"),
-                          &PyString_Type, &name,
-                          &PyTuple_Type, &bases,
-                          &PyDict_Type, &name_space))
-    {
-        return 0;
-    }
-    
-    return as_object(
-        new class_t<T>(this, string(ref(name, ref::increment_count)),
-                  tuple(ref(bases, ref::increment_count)),
-                  dictionary(ref(name_space, ref::increment_count)))
-        );
-}
-
-namespace detail {
-  const string& setattr_string();
-  const string& getattr_string();
-  const string& delattr_string();
-
-  inline string class_base::name() const
-  {
-      return m_name;
-  }
-}
-
-
-}} // namespace boost::python
-#endif

include/boost/python/conversions.hpp

@@ -1,325 +0,0 @@
-//  (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.
-
-#ifndef METHOD_DWA122899_H_
-# define METHOD_DWA122899_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/detail/none.hpp>
-# include <boost/python/detail/signatures.hpp>
-# include <boost/smart_ptr.hpp>
-# include <boost/python/errors.hpp>
-# include <string>
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE // this is a gcc 2.95.2 bug workaround
-
-// This can be instantiated on an enum to provide the to_python/from_python
-// conversions, provided the values can fit in a long.
-template <class EnumType>
-class py_enum_as_int_converters
-{
-    friend EnumType from_python(PyObject* x, boost::python::type<EnumType>)
-    {
-        return static_cast<EnumType>(
-            from_python(x, boost::python::type<long>()));
-    }
-
-    friend EnumType from_python(PyObject* x, boost::python::type<const EnumType&>)
-    {
-        return static_cast<EnumType>(
-            from_python(x, boost::python::type<long>()));
-    }
-
-    friend PyObject* to_python(EnumType x)
-    {
-        return to_python(static_cast<long>(x));
-    }
-};
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-namespace boost { namespace python {
-template <class EnumType> class enum_as_int_converters
-    : public BOOST_PYTHON_CONVERSION::py_enum_as_int_converters<EnumType> {};
-
-template <class P, class T> class wrapped_pointer;
-
-//#pragma warn_possunwant off
-inline void decref_impl(PyObject* p) { Py_DECREF(p); }
-inline void xdecref_impl(PyObject* p) { Py_XDECREF(p); }
-//#pragma warn_possunwant reset
-
-template <class T>
-inline void decref(T* p)
-{
-	char* const raw_p = reinterpret_cast<char*>(p);
-	char* const p_base = raw_p - offsetof(PyObject, ob_refcnt);
-	decref_impl(reinterpret_cast<PyObject*>(p_base));
-}
-
-template <class T>
-inline void xdecref(T* p)
-{
-	char* const raw_p = reinterpret_cast<char*>(p);
-	char* const p_base = raw_p - offsetof(PyObject, ob_refcnt);
-	xdecref_impl(reinterpret_cast<PyObject*>(p_base));
-}
-
-}} // namespace boost::python
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-//
-// Converters
-//
-PyObject* to_python(long);
-long from_python(PyObject* p, boost::python::type<long>);
-long from_python(PyObject* p, boost::python::type<const long&>);
-
-PyObject* to_python(unsigned long);
-unsigned long from_python(PyObject* p, boost::python::type<unsigned long>);
-unsigned long from_python(PyObject* p, boost::python::type<const unsigned long&>);
-
-PyObject* to_python(int);
-int from_python(PyObject*, boost::python::type<int>);
-int from_python(PyObject*, boost::python::type<const int&>);
-    
-PyObject* to_python(unsigned int);
-unsigned int from_python(PyObject*, boost::python::type<unsigned int>);
-unsigned int from_python(PyObject*, boost::python::type<const unsigned int&>);
-
-PyObject* to_python(short);
-short from_python(PyObject*, boost::python::type<short>);
-short from_python(PyObject*, boost::python::type<const short&>);
-    
-PyObject* to_python(unsigned short);
-unsigned short from_python(PyObject*, boost::python::type<unsigned short>);
-unsigned short from_python(PyObject*, boost::python::type<const unsigned short&>);
-
-PyObject* to_python(signed char);
-signed char from_python(PyObject*, boost::python::type<signed char>);
-signed char from_python(PyObject*, boost::python::type<const signed char&>);
-
-PyObject* to_python(unsigned char);
-unsigned char from_python(PyObject*, boost::python::type<unsigned char>);
-unsigned char from_python(PyObject*, boost::python::type<const unsigned char&>);
-
-PyObject* to_python(float);
-float from_python(PyObject*, boost::python::type<float>);
-float from_python(PyObject*, boost::python::type<const float&>);
-    
-PyObject* to_python(double);
-double from_python(PyObject*, boost::python::type<double>);
-double from_python(PyObject*, boost::python::type<const double&>);
-    
-PyObject* to_python(bool);
-bool from_python(PyObject*, boost::python::type<bool>);
-bool from_python(PyObject*, boost::python::type<const bool&>);
-
-PyObject* to_python(void);
-void from_python(PyObject*, boost::python::type<void>);
-
-PyObject* to_python(const char* s);
-const char* from_python(PyObject*, boost::python::type<const char*>);
-
-PyObject* to_python(const std::string& s);
-std::string from_python(PyObject*, boost::python::type<std::string>);
-std::string from_python(PyObject*, boost::python::type<const std::string&>);
-
-// For when your C++ function really wants to pass/return a PyObject*
-PyObject* to_python(PyObject*);
-PyObject* from_python(PyObject*, boost::python::type<PyObject*>);
-
-// Some standard conversions to/from smart pointer types. You can add your own
-// from these examples.  These are not generated using the friend technique from
-// wrapped_pointer because:
-//
-//      1. We want to be able to extend conversion to/from WrappedPointers using
-//      arbitrary smart pointer types.
-//
-//      2. It helps with compilation independence. This way, code which creates
-//      wrappers for functions accepting and returning smart_ptr<T> does not
-//      have to have already seen the invocation of wrapped_type<T>.
-//
-
-// Unfortunately, MSVC6 is so incredibly lame that we have to rely on the friend
-// technique to auto_generate standard pointer conversions for wrapped
-// types. This means that you need to write a non-templated function for each
-// specific smart_ptr<T> which you want to convert from_python. For example,
-//
-// namespace boost { namespace python {
-// #ifdef MUST_SUPPORT_MSVC
-//
-// MyPtr<Foo> from_python(PyObject*p, type<MyPtr<Foo> >)
-//     { return smart_ptr_from_python(p, type<MyPtr<Foo> >(), type<Foo>());}
-// }
-// 
-// MyPtr<Bar> from_python(PyObject*p, type<MyPtr<Bar> >)
-//     { return smart_ptr_from_python(p, type<MyPtr<Bar> >(), type<Bar>());}
-// 
-// ... // definitions for MyPtr<Baz>, MyPtr<Mumble>, etc.
-//
-// #else
-//
-// // Just once for all MyPtr<T>
-// template <class T>
-// MyPtr<T> from_python(PyObject*p, type<MyPtr<T> >)
-// {
-//    return smart_ptr_from_python(p, type<MyPtr<T> >(), type<T>());
-// }
-//
-// #endif
-// }} // namespace boost::python
-
-#if !defined(BOOST_MSVC6_OR_EARLIER)
-template <class T>
-boost::shared_ptr<T> from_python(PyObject*p, boost::python::type<boost::shared_ptr<T> >)
-{
-    return smart_ptr_from_python(p, boost::python::type<boost::shared_ptr<T> >(), boost::python::type<T>());
-}
-#endif
-
-#if 0
-template <class T>
-PyObject* to_python(std::auto_ptr<T> p)
-{
-    return new boost::python::wrapped_pointer<std::auto_ptr<T>, T>(p);
-}
-
-template <class T>
-PyObject* to_python(boost::shared_ptr<T> p)
-{
-    return new boost::python::wrapped_pointer<boost::shared_ptr<T>, T>(p);
-}
-#endif
-
-//
-// inline implementations
-//
-
-#ifndef BOOST_MSVC6_OR_EARLIER
-inline PyObject* to_python(double d)
-{
-    return PyFloat_FromDouble(d);
-}
-
-inline PyObject* to_python(float f)
-{
-    return PyFloat_FromDouble(f);
-}
-#endif // BOOST_MSVC6_OR_EARLIER
-
-inline PyObject* to_python(long l)
-{
-	return PyInt_FromLong(l);
-}
-
-inline PyObject* to_python(int x)
-{
-	return PyInt_FromLong(x);
-}
-
-inline PyObject* to_python(short x)
-{
-	return PyInt_FromLong(x);
-}
-
-inline PyObject* to_python(bool b)
-{
-	return PyInt_FromLong(b);
-}
-
-inline PyObject* to_python(void)
-{
-    return boost::python::detail::none();
-}
-
-inline PyObject* to_python(const char* s)
-{
-	return PyString_FromString(s);
-}
-
-inline std::string from_python(PyObject* p, boost::python::type<const std::string&>)
-{
-    return from_python(p, boost::python::type<std::string>());
-}
-
-inline PyObject* to_python(PyObject* p)
-{
-    Py_INCREF(p);
-    return p;
-}
-
-inline PyObject* from_python(PyObject* p, boost::python::type<PyObject*>)
-{
-    return p;
-}
-
-inline const char* from_python(PyObject* p, boost::python::type<const char* const&>)
-{
-    return from_python(p, boost::python::type<const char*>());
-}
-
-inline double from_python(PyObject* p, boost::python::type<const double&>)
-{
-    return from_python(p, boost::python::type<double>());
-}
-
-inline float from_python(PyObject* p, boost::python::type<const float&>)
-{
-    return from_python(p, boost::python::type<float>());
-}
-
-inline int from_python(PyObject* p, boost::python::type<const int&>)
-{
-    return from_python(p, boost::python::type<int>());
-}
-
-inline short from_python(PyObject* p, boost::python::type<const short&>)
-{
-    return from_python(p, boost::python::type<short>());
-}
-
-inline long from_python(PyObject* p, boost::python::type<const long&>)
-{
-    return from_python(p, boost::python::type<long>());
-}
-
-inline bool from_python(PyObject* p, boost::python::type<const bool&>)
-{
-    return from_python(p, boost::python::type<bool>());
-}
-
-inline unsigned int from_python(PyObject* p, boost::python::type<const unsigned int&>)
-{
-    return from_python(p, boost::python::type<unsigned int>());
-}
-
-inline unsigned short from_python(PyObject* p, boost::python::type<const unsigned short&>)
-{
-    return from_python(p, boost::python::type<unsigned short>());
-}
-
-inline signed char from_python(PyObject* p, boost::python::type<const signed char&>)
-{
-    return from_python(p, boost::python::type<signed char>());
-}
-
-inline unsigned char from_python(PyObject* p, boost::python::type<const unsigned char&>)
-{
-    return from_python(p, boost::python::type<unsigned char>());
-}
-
-inline unsigned long from_python(PyObject* p, boost::python::type<const unsigned long&>)
-{
-    return from_python(p, boost::python::type<unsigned long>());
-}
-
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-#endif // METHOD_DWA122899_H_

include/boost/python/detail/base_object.hpp

@@ -1,62 +0,0 @@
-//  (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.
-
-#ifndef BASE_OBJECT_DWA051600_H_
-# define BASE_OBJECT_DWA051600_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/signatures.hpp> // really just for type<>
-# include <boost/python/detail/wrap_python.hpp>
-# include <cstring>
-
-namespace boost { namespace python { namespace detail {
-
-// base_object - adds a constructor and non-virtual destructor to a
-// base Python type (e.g. PyObject, PyTypeObject).
-template <class python_type>
-struct base_object : python_type
-{
-    typedef python_type base_python_type;
-
-    // Initializes type and reference count. All other fields of base_python_type are 0
-    base_object(PyTypeObject* type_obj);
-
-    // Decrements reference count on the type
-    ~base_object();
-};
-
-// Easy typedefs for common usage
-typedef base_object<PyObject> python_object;
-typedef base_object<PyTypeObject> python_type;
-
-
-//
-// class_t template member function implementations 
-//
-template <class python_type>
-base_object<python_type>::base_object(PyTypeObject* type_obj)
-{
-    base_python_type* bp = this;
-#if !defined(_MSC_VER) || defined(__STLPORT)
-    std::
-#endif
-		memset(bp, 0, sizeof(base_python_type));
-    ob_refcnt = 1;
-    ob_type = type_obj;
-    Py_INCREF(type_obj);
-}
-
-template <class python_type>
-inline base_object<python_type>::~base_object()
-{
-    Py_DECREF(ob_type);
-}
-
-}}} // namespace boost::python::detail
-
-#endif // BASE_OBJECT_DWA051600_H_

include/boost/python/detail/cast.hpp

@@ -1,81 +0,0 @@
-//  (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.
-
-#ifndef CAST_DWA052500_H_
-# define CAST_DWA052500_H_
-
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/operators.hpp>
-
-namespace boost { namespace python {
-
-namespace detail {
-  // The default way of converting a PyObject* or PyTypeObject* to a T*
-  template <class T>
-  struct downcast_traits
-  {
-      template <class U>
-      static T* cast(U* p) { return static_cast<T*>(p); }
-  };
-
-  inline PyTypeObject* as_base_object(const PyTypeObject*, PyObject* p)
-  {
-      return reinterpret_cast<PyTypeObject*>(p);
-  }
-
-  inline PyObject* as_base_object(const PyObject*, PyObject* p)
-  {
-      return p;
-  }
-
-  inline const PyTypeObject* as_base_object(const PyTypeObject*, const PyObject* p)
-  {
-      return reinterpret_cast<const PyTypeObject*>(p);
-  }
-
-  inline const PyObject* as_base_object(const PyObject*, const PyObject* p)
-  {
-      return p;
-  }
-} // namespace detail
-
-// Convert a pointer to any type derived from PyObject or PyTypeObject to a PyObject*
-inline PyObject* as_object(PyObject* p) { return p; }
-inline PyObject* as_object(PyTypeObject* p) { return reinterpret_cast<PyObject*>(p); }
-
-// If I didn't have to support stupid MSVC6 we could just use a simple template function:
-// template <class T> T* downcast(PyObject*).
-template <class T>
-struct downcast : boost::dereferenceable<downcast<T>, T*>
-{
-    downcast(PyObject* p)
-        : m_p(detail::downcast_traits<T>::cast(detail::as_base_object((T*)0, p)))
-        {}
-    
-    downcast(const PyObject* p)
-        : m_p(detail::downcast_traits<T>::cast(detail::as_base_object((const T*)0, p)))
-        {}
-    
-    downcast(PyTypeObject* p)
-        : m_p(detail::downcast_traits<T>::cast(p))
-        {}
-    
-    downcast(const PyTypeObject* p)
-        : m_p(detail::downcast_traits<T>::cast(p))
-        {}
-    
-    operator T*() const { return m_p; }
-    T* get() const { return m_p; }
-    T& operator*() const { return *m_p; }
- private:
-    T* m_p;
-};
-
-}} // namespace boost::python
-
-#endif // CAST_DWA052500_H_

include/boost/python/detail/config.hpp

@@ -1,56 +0,0 @@
-//  (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.
-
-#ifndef CONFIG_DWA052200_H_
-# define CONFIG_DWA052200_H_
-
-# include <boost/config.hpp>
-# include <cstddef>
-
-# ifdef BOOST_NO_OPERATORS_IN_NAMESPACE
-   // A gcc bug forces some symbols into the global namespace
-#  define BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-#  define BOOST_PYTHON_END_CONVERSION_NAMESPACE
-#  define BOOST_PYTHON_CONVERSION
-#  define BOOST_PYTHON_IMPORT_CONVERSION(x) using ::x
-# else
-#  define BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE namespace boost { namespace python {
-#  define BOOST_PYTHON_END_CONVERSION_NAMESPACE }} // namespace boost::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
-
-# if defined(BOOST_MSVC)
-#  if _MSC_VER <= 1200
-#   define BOOST_MSVC6_OR_EARLIER 1
-#  endif
-
-# pragma warning (disable : 4786)
-
-# endif
-
-// Work around the broken library implementation/strict ansi checking on some
-// EDG-based compilers (e.g. alpha), which incorrectly warn that the result of
-// offsetof() is not an integer constant expression.
-# if defined(__DECCXX_VER) && __DECCXX_VER <= 60290024
-#  define BOOST_OFFSETOF(s_name, s_member) \
-        ((size_t)__INTADDR__(&(((s_name *)0)->s_member)))
-# else
-#  define BOOST_OFFSETOF(s_name, s_member) \
-        offsetof(s_name, s_member)
-# endif
-
-// The STLport puts all of the standard 'C' library names in std (as far as the
-// user is concerned), but without it you need a fix if you're using MSVC.
-# if defined(BOOST_MSVC6_OR_EARLIER) && !defined(__STLPORT)
-#  define BOOST_CSTD_
-# else
-#  define BOOST_CSTD_ std
-# endif
-
-#endif // CONFIG_DWA052200_H_

include/boost/python/detail/extension_class.hpp

@@ -1,861 +0,0 @@
-//  (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 automatically generated for 10-argument constructors by
-//  gen_extclass.python
-
-#ifndef EXTENSION_CLASS_DWA052000_H_
-# define EXTENSION_CLASS_DWA052000_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/classes.hpp>
-# include <vector>
-# include <boost/python/detail/none.hpp>
-# include <boost/python/objects.hpp>
-# include <boost/python/detail/functions.hpp>
-# include <memory>
-# include <boost/python/detail/init_function.hpp>
-# include <typeinfo>
-# include <boost/smart_ptr.hpp>
-
-namespace boost { namespace python {
-
-// forward declarations
-template <long which, class operand> struct operators;
-template <class T> struct left_operand;
-template <class T> struct right_operand;
-
-enum without_downcast_t { without_downcast };
-
-namespace detail {
-
-// forward declarations
-class extension_instance;
-class extension_class_base;
-template <class T> class instance_holder;
-template <class T, class U> class instance_value_holder;
-template <class ref, class T> class instance_ptr_holder;
-template <class Specified> struct operand_select;
-  template <long> struct choose_op;
-  template <long> struct choose_rop;
-  template <long> struct choose_unary_op;
-  template <long> struct define_operator;
-
-meta_class<extension_instance>* extension_meta_class();
-extension_instance* get_extension_instance(PyObject* p);
-void report_missing_instance_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
-void report_missing_ptr_data(extension_instance*, class_t<extension_instance>*, const std::type_info&);
-void report_missing_class_object(const std::type_info&);
-void report_released_smart_pointer(const std::type_info&);
-    
-template <class T>
-T* check_non_null(T* p)
-{
-    if (p == 0)
-        report_released_smart_pointer(typeid(T));
-    return p;
-}
-
-template <class T> class held_instance;
-
-typedef void* (*conversion_function_ptr)(void*);
-
-struct base_class_info
-{
-    base_class_info(extension_class_base* t, conversion_function_ptr f)
-        :class_object(t), convert(f)
-        {}
-    
-    extension_class_base* class_object;
-    conversion_function_ptr convert;
-};
-
-typedef base_class_info derived_class_info;
-
-struct add_operator_base;
-
-class extension_class_base : public class_t<extension_instance>
-{
- public:
-    extension_class_base(const char* name);
-    
- public:
-    // the purpose of try_class_conversions() and its related functions 
-    // is explained in extclass.cpp
-    void* try_class_conversions(instance_holder_base*) const;
-    void* try_base_class_conversions(instance_holder_base*) const;
-    void* try_derived_class_conversions(instance_holder_base*) const;
-
-    void set_attribute(const char* name, PyObject* x);
-    void set_attribute(const char* name, ref x);
-    
- private:
-    virtual void* extract_object_from_holder(instance_holder_base* v) const = 0;
-    virtual std::vector<base_class_info> const& base_classes() const = 0;
-    virtual std::vector<derived_class_info> const& derived_classes() const = 0;
-
- protected:
-    friend struct add_operator_base;
-    void add_method(reference<function> method, const char* name);
-    void add_method(function* method, const char* name);
-    
-    void add_constructor_object(function*);
-    void add_setter_method(function*, const char* name);
-    void add_getter_method(function*, const char* name);
-};
-
-template <class T>
-class class_registry
-{
- public:
-    static extension_class_base* class_object()
-        { return static_class_object; }
-
-    // Register/unregister the Python class object corresponding to T
-    static void register_class(extension_class_base*);
-    static void unregister_class(extension_class_base*);
-
-    // Establish C++ inheritance relationships
-    static void register_base_class(base_class_info const&);
-    static void register_derived_class(derived_class_info const&);
-
-    // Query the C++ inheritance relationships
-    static std::vector<base_class_info> const& base_classes();
-    static std::vector<derived_class_info> const& derived_classes();
- private:
-    static extension_class_base* static_class_object;
-    static std::vector<base_class_info> static_base_class_info;
-    static std::vector<derived_class_info> static_derived_class_info;
-};
-
-}}} // namespace boost::python::detail
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-// This class' only job is to define from_python and to_python converters for T
-// and U. T is the class the user really intends to wrap. U is a class derived
-// from T with some virtual function overriding boilerplate, or if there are no
-// virtual functions, U = held_instance<T>.
-template <class T, class U = boost::python::detail::held_instance<T> >
-class python_extension_class_converters
-{
- public:
-    // Get an object which can be used to convert T to/from python. This is used
-    // as a kind of concept check by the global template
-    //
-    //     PyObject* to_python(const T& x)
-    //
-    // below this class, to prevent the confusing messages that would otherwise
-    // pop up. Now, if T hasn't been wrapped as an extension class, the user
-    // will see an error message about the lack of an eligible
-    // py_extension_class_converters() function.
-    friend python_extension_class_converters py_extension_class_converters(boost::python::type<T>)
-    { 
-        return python_extension_class_converters();
-    }
-
-    // This is a member function because in a conforming implementation, friend
-    // funcitons defined inline in the class body are all instantiated as soon
-    // as the enclosing class is instantiated. If T is not copyable, that causes
-    // a compiler error. Instead, we access this function through the global
-    // template 
-    //
-    //     PyObject* to_python(const T& x)
-    //
-    // defined below this class. Since template functions are instantiated only
-    // on demand, errors will be avoided unless T is noncopyable and the user
-    // writes code which causes us to try to copy a T.
-    PyObject* to_python(const T& x) const
-    {
-        boost::python::reference<boost::python::detail::extension_instance> result(create_instance());
-        result->add_implementation(
-            std::auto_ptr<boost::python::detail::instance_holder_base>(
-                new boost::python::detail::instance_value_holder<T,U>(result.get(), x)));
-        return result.release();
-    }
-    
-    // Convert to T*
-    friend T* from_python(PyObject* obj, boost::python::type<T*>)
-    {
-        // downcast to an extension_instance, then find the actual T
-        boost::python::detail::extension_instance* self = boost::python::detail::get_extension_instance(obj);
-        typedef std::vector<boost::python::detail::instance_holder_base*>::const_iterator iterator;
-        for (iterator p = self->wrapped_objects().begin();
-             p != self->wrapped_objects().end(); ++p)
-        {
-            boost::python::detail::instance_holder<T>* held = dynamic_cast<boost::python::detail::instance_holder<T>*>(*p);
-            if (held != 0)
-                return held->target();
-
-            // see extclass.cpp for an explanation of try_class_conversions()
-            void* target = boost::python::detail::class_registry<T>::class_object()->try_class_conversions(*p);
-            if(target) 
-                return static_cast<T*>(target);
-        }
-        boost::python::detail::report_missing_instance_data(self, boost::python::detail::class_registry<T>::class_object(), typeid(T));
-        throw boost::python::argument_error();
-    }
-
-    // Convert to PtrType, where PtrType can be dereferenced to obtain a T.
-    template <class PtrType>
-    static PtrType& ptr_from_python(PyObject* obj, boost::python::type<PtrType>)
-    {
-        // downcast to an extension_instance, then find the actual T
-        boost::python::detail::extension_instance* self = boost::python::detail::get_extension_instance(obj);
-        typedef std::vector<boost::python::detail::instance_holder_base*>::const_iterator iterator;
-        for (iterator p = self->wrapped_objects().begin();
-             p != self->wrapped_objects().end(); ++p)
-        {
-            boost::python::detail::instance_ptr_holder<PtrType, T>* held =
-                dynamic_cast<boost::python::detail::instance_ptr_holder<PtrType, T>*>(*p);
-            if (held != 0)
-                return held->ptr();
-        }
-        boost::python::detail::report_missing_ptr_data(self, boost::python::detail::class_registry<T>::class_object(), typeid(T));
-        throw boost::python::argument_error();
-    }
-
-    template <class PtrType>
-    static PyObject* ptr_to_python(PtrType x)
-    {
-        boost::python::reference<boost::python::detail::extension_instance> result(create_instance());
-        result->add_implementation(
-            std::auto_ptr<boost::python::detail::instance_holder_base>(
-                new boost::python::detail::instance_ptr_holder<PtrType,T>(x)));
-        return result.release();
-    }
-
-    static boost::python::reference<boost::python::detail::extension_instance> create_instance()
-    {
-        PyTypeObject* class_object = boost::python::detail::class_registry<T>::class_object();
-        if (class_object == 0)
-            boost::python::detail::report_missing_class_object(typeid(T));
-            
-        return boost::python::reference<boost::python::detail::extension_instance>(
-            new boost::python::detail::extension_instance(class_object));
-    }
-
-    // Convert to const T*
-    friend const T* from_python(PyObject* p, boost::python::type<const T*>)
-        { return from_python(p, boost::python::type<T*>()); }
-
-    // Convert to const T* const&
-    friend const T* from_python(PyObject* p, boost::python::type<const T*const&>)
-         { return from_python(p, boost::python::type<const T*>()); }
-  
-    // Convert to T* const&
-    friend T* from_python(PyObject* p, boost::python::type<T* const&>)
-         { return from_python(p, boost::python::type<T*>()); }
- 
-    // Convert to T&
-    friend T& from_python(PyObject* p, boost::python::type<T&>)
-        { return *boost::python::detail::check_non_null(from_python(p, boost::python::type<T*>())); }
-
-    // Convert to const T&
-    friend const T& from_python(PyObject* p, boost::python::type<const T&>)
-        { return from_python(p, boost::python::type<T&>()); }
-
-    // Convert to T
-    friend const T& from_python(PyObject* p, boost::python::type<T>)
-        { return from_python(p, boost::python::type<T&>()); }
-
-    friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T>&>)
-        { return ptr_from_python(p, boost::python::type<std::auto_ptr<T> >()); }
-    
-    friend std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<std::auto_ptr<T> >)
-        { return ptr_from_python(p, boost::python::type<std::auto_ptr<T> >()); }
-    
-    friend const std::auto_ptr<T>& from_python(PyObject* p, boost::python::type<const std::auto_ptr<T>&>)
-        { return ptr_from_python(p, boost::python::type<std::auto_ptr<T> >()); }
-
-    friend PyObject* to_python(std::auto_ptr<T> x)
-        { return ptr_to_python(x); }
-
-    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T>&>)
-        { return ptr_from_python(p, boost::python::type<boost::shared_ptr<T> >()); }
-    
-    friend boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<boost::shared_ptr<T> >)
-        { return ptr_from_python(p, boost::python::type<boost::shared_ptr<T> >()); }
-    
-    friend const boost::shared_ptr<T>& from_python(PyObject* p, boost::python::type<const boost::shared_ptr<T>&>)
-        { return ptr_from_python(p, boost::python::type<boost::shared_ptr<T> >()); }
-
-    friend PyObject* to_python(boost::shared_ptr<T> x)
-        { return ptr_to_python(x); }
-};
-
-// Convert T to_python, instantiated on demand and only if there isn't a
-// non-template overload for this function. This version is the one invoked when
-// T is a wrapped class. See the first 2 functions declared in
-// python_extension_class_converters above for more info.
-template <class T>
-PyObject* to_python(const T& x)
-{
-    return py_extension_class_converters(boost::python::type<T>()).to_python(x);
-}
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-namespace boost { namespace python {
-
-BOOST_PYTHON_IMPORT_CONVERSION(python_extension_class_converters);
-
-namespace detail {
-
-template <class T> class instance_holder;
-
-class read_only_setattr_function : public function
-{
- public:
-    read_only_setattr_function(const char* name);
-    PyObject* do_call(PyObject* args, PyObject* keywords) const;
-    const char* description() const;
- private:
-    string m_name;
-};
-
-  template <class From, class To>
-  struct define_conversion
-  {
-      static void* upcast_ptr(void* v)
-      {
-          return static_cast<To*>(static_cast<From*>(v));
-      }
-
-      static void* downcast_ptr(void* v)
-      {
-          return dynamic_cast<To*>(static_cast<From*>(v));
-      }
-  };
-
-// An easy way to make an extension base class which wraps T. Note that Python
-// subclasses of this class will simply be class_t<extension_instance> objects.
-//
-// U should be a class derived from T which overrides virtual functions with
-// boilerplate code to call back into Python. See extclass_demo.h for examples.
-// 
-// U is optional, but you won't be able to override any member functions in
-// Python which are called from C++ if you don't supply it. If you just want to
-// be able to use T in python without overriding member functions, you can omit
-// U.
-template <class T, class U = held_instance<T> >
-class extension_class
-    : public python_extension_class_converters<T, U>, // This generates the to_python/from_python functions
-      public extension_class_base
-{
- public:
-    typedef T wrapped_type;
-    typedef U callback_type;
-    
-    // Construct with a name that comes from typeid(T).name(). The name only
-    // affects the objects of this class are represented through repr()
-    extension_class();
-    
-    // Construct with the given name. The name only affects the objects of this
-    // class are represented through repr()
-    extension_class(const char* name);
-    
-    ~extension_class();
-
-    // define constructors
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    inline void def(constructor<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>)
-    // The following incantation builds a signature1, signature2,... object. It
-    // should _all_ get optimized away.
-    { add_constructor(
-        prepend(type<A1>::id(),
-        prepend(type<A2>::id(),
-        prepend(type<A3>::id(),
-        prepend(type<A4>::id(),
-        prepend(type<A5>::id(),
-        prepend(type<A6>::id(),
-        prepend(type<A7>::id(),
-        prepend(type<A8>::id(),
-        prepend(type<A9>::id(),
-        prepend(type<A10>::id(),
-                signature0())))))))))));
-    }
-
-
-    // export homogeneous operators (type of both lhs and rhs is 'operator')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub), Foo>());
-    
-    // export homogeneous operators (type of both lhs and rhs is 'T const&')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>());
-    template <long which, class Operand>
-    inline void def(operators<which,Operand>)
-    {
-        typedef typename operand_select<Operand>::template wrapped<T>::type true_operand;
-        def_operators(operators<which,true_operand>());
-    }
-
-    // export heterogeneous operators (type of lhs: 'left', of rhs: 'right')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub), Foo>(),
-    //                       boost::python::right_operand<int const&>());
-
-    // export heterogeneous operators (type of lhs: 'T const&', of rhs: 'right')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>(),
-    //                       boost::python::right_operand<int const&>());
-    template <long which, class Left, class Right>
-    inline void def(operators<which,Left>, right_operand<Right> r)
-    {
-        typedef typename operand_select<Left>::template wrapped<T>::type true_left;
-        def_operators(operators<which,true_left>(), r);
-    }
-
-    // export heterogeneous reverse-argument operators 
-    // (type of lhs: 'left', of rhs: 'right')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub), Foo>(),
-    //                       boost::python::left_operand<int const&>());
-    
-    // export heterogeneous reverse-argument operators 
-    // (type of lhs: 'left', of rhs: 'T const&')
-    // usage:  foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>(),
-    //                       boost::python::left_operand<int const&>());
-    template <long which, class Left, class Right>
-    inline void def(operators<which,Right>, left_operand<Left> l)
-    {
-        typedef typename operand_select<Right>::template wrapped<T>::type true_right;
-        def_operators(operators<which,true_right>(), l);
-    }
-
-    // define a function that passes Python arguments and keywords
-    // to C++ verbatim (as a 'tuple const&' and 'dictionary const&' 
-    // respectively). This is useful for manual argument passing.
-    // It's also the only possibility to pass keyword arguments to C++.
-    // Fn must have a signatur that is compatible to 
-    //     PyObject* (*)(PyObject* aTuple, PyObject* aDictionary)
-    template <class Fn>
-    inline void def_raw(Fn fn, const char* name)
-    {
-        this->add_method(new_raw_arguments_function(fn), name);
-    }
-
-    // define member functions. In fact this works for free functions, too -
-    // they act like static member functions, or if they start with the
-    // appropriate self argument (as a pointer), they can be used just like
-    // ordinary member functions -- just like Python!
-    template <class Fn>
-    inline void def(Fn fn, const char* name)
-    {
-        this->add_method(new_wrapped_function(fn), name);
-    }
-
-    // Define a virtual member function with a default implementation.
-    // default_fn should be a function which provides the default implementation.
-    // Be careful that default_fn does not in fact call fn virtually!
-    template <class Fn, class DefaultFn>
-    inline void def(Fn fn, const char* name, DefaultFn default_fn)
-    {
-        this->add_method(new_virtual_function(type<T>(), fn, default_fn), name);
-    }
-
-    // Provide a function which implements x.<name>, reading from the given
-    // member (pm) of the T obj
-    template <class MemberType>
-    inline void def_getter(MemberType T::*pm, const char* name)
-    {
-        this->add_getter_method(new getter_function<T, MemberType>(pm), name);
-    }
-    
-    // Provide a function which implements assignment to x.<name>, writing to
-    // the given member (pm) of the T obj
-    template <class MemberType>
-    inline void def_setter(MemberType T::*pm, const char* name)
-    {
-        this->add_setter_method(new setter_function<T, MemberType>(pm), name);
-    }
-    
-    // Expose the given member (pm) of the T obj as a read-only attribute
-    template <class MemberType>
-    inline void def_readonly(MemberType T::*pm, const char* name)
-    {
-        this->add_setter_method(new read_only_setattr_function(name), name);
-        this->def_getter(pm, name);
-    }
-    
-    // Expose the given member (pm) of the T obj as a read/write attribute
-    template <class MemberType>
-    inline void def_read_write(MemberType T::*pm, const char* name)
-    {
-        this->def_getter(pm, name);
-        this->def_setter(pm, name);
-    }
-    
-    // define the standard coercion needed for operator overloading
-    void def_standard_coerce();
-
-    // declare the given class a base class of this one and register 
-    // up and down conversion functions
-    template <class S, class V>
-    void declare_base(extension_class<S, V>* base)
-    {
-        // see extclass.cpp for an explanation of why we need to register
-        // conversion functions
-        base_class_info baseInfo(base, 
-                            &define_conversion<S, T>::downcast_ptr);
-        class_registry<T>::register_base_class(baseInfo);
-        add_base(ref(as_object(base), ref::increment_count));
-        
-        derived_class_info derivedInfo(this, 
-                            &define_conversion<T, S>::upcast_ptr);
-        class_registry<S>::register_derived_class(derivedInfo);
-    }
-        
-    // declare the given class a base class of this one and register 
-    // only up conversion function
-    template <class S, class V>
-    void declare_base(extension_class<S, V>* base, without_downcast_t)
-    {
-        // see extclass.cpp for an explanation of why we need to register
-        // conversion functions
-        base_class_info baseInfo(base, 0);
-        class_registry<T>::register_base_class(baseInfo);
-        add_base(ref(as_object(base), ref::increment_count));
-        
-        derived_class_info derivedInfo(this, 
-                           &define_conversion<T, S>::upcast_ptr);
-        class_registry<S>::register_derived_class(derivedInfo);
-    }
-    
- private: // types
-    typedef instance_value_holder<T,U> holder;
-
- private: // extension_class_base virtual function implementations
-    std::vector<base_class_info> const& base_classes() const;
-    std::vector<derived_class_info> const& derived_classes() const;
-    void* extract_object_from_holder(instance_holder_base* v) const;
-
- private: // Utility functions
-    template <long which, class Operand>
-    inline void def_operators(operators<which,Operand>)
-    {
-        def_standard_coerce();
-
-        // for some strange reason, this prevents MSVC from having an
-        // "unrecoverable block scoping error"!
-        typedef choose_op<(which & op_add)> choose_add;
-
-        choose_op<(which & op_add)>::template args<Operand>::add(this);
-        choose_op<(which & op_sub)>::template args<Operand>::add(this);
-        choose_op<(which & op_mul)>::template args<Operand>::add(this);
-        choose_op<(which & op_div)>::template args<Operand>::add(this);
-        choose_op<(which & op_mod)>::template args<Operand>::add(this);
-        choose_op<(which & op_divmod)>::template args<Operand>::add(this);
-        choose_op<(which & op_pow)>::template args<Operand>::add(this);
-        choose_op<(which & op_lshift)>::template args<Operand>::add(this);
-        choose_op<(which & op_rshift)>::template args<Operand>::add(this);
-        choose_op<(which & op_and)>::template args<Operand>::add(this);
-        choose_op<(which & op_xor)>::template args<Operand>::add(this);
-        choose_op<(which & op_or)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_neg)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_pos)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_abs)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_invert)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_int)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_long)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_float)>::template args<Operand>::add(this);
-        choose_op<(which & op_cmp)>::template args<Operand>::add(this);
-        choose_unary_op<(which & op_str)>::template args<Operand>::add(this);
-    }
-
-    template <long which, class Left, class Right>
-    inline void def_operators(operators<which,Left>, right_operand<Right>)
-    {
-        def_standard_coerce();
-        
-        choose_op<(which & op_add)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_sub)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_mul)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_div)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_mod)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_divmod)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_pow)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_lshift)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_rshift)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_and)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_xor)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_or)>::template args<Left,Right>::add(this);
-        choose_op<(which & op_cmp)>::template args<Left,Right>::add(this);
-    }
-    
-    template <long which, class Left, class Right>
-    inline void def_operators(operators<which,Right>, left_operand<Left>)
-    {
-        def_standard_coerce();
-        
-        choose_rop<(which & op_add)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_sub)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_mul)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_div)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_mod)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_divmod)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_pow)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_lshift)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_rshift)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_and)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_xor)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_or)>::template args<Left,Right>::add(this);
-        choose_rop<(which & op_cmp)>::template args<Left,Right>::add(this);
-    }
-    
-    template <class signature>
-    void add_constructor(signature sig)
-    {
-        this->add_constructor_object(init_function<holder>::create(sig));
-    }
-};
-
-// A simple wrapper over a T which allows us to use extension_class<T> with a
-// single template parameter only. See extension_class<T>, above.
-template <class T>
-class held_instance : public T
-{
-    // There are no member functions: we want to avoid inadvertently overriding
-    // any virtual functions in T.
-public:
-    held_instance(PyObject*) : T() {}
-    template <class A1>
-    held_instance(PyObject*, A1 a1) : T(a1) {}
-    template <class A1, class A2>
-    held_instance(PyObject*, A1 a1, A2 a2) : T(a1, a2) {}
-    template <class A1, class A2, class A3>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3) : T(a1, a2, a3) {}
-    template <class A1, class A2, class A3, class A4>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4) : T(a1, a2, a3, a4) {}
-    template <class A1, class A2, class A3, class A4, class A5>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) : T(a1, a2, a3, a4, a5) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) : T(a1, a2, a3, a4, a5, a6) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) : T(a1, a2, a3, a4, a5, a6, a7) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) : T(a1, a2, a3, a4, a5, a6, a7, a8) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) : T(a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    held_instance(PyObject*, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) : T(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
-};
-
-// Abstract base class for all obj holders. Base for template class
-// instance_holder<>, below.
-class instance_holder_base
-{
-public:
-    virtual ~instance_holder_base() {}
-    virtual bool held_by_value() = 0;
-};
-
-// Abstract base class which holds a Held, somehow. Provides a uniform way to
-// get a pointer to the held object
-template <class Held>
-class instance_holder : public instance_holder_base
-{
-public:
-    virtual Held*target() = 0;
-};
-
-// Concrete class which holds a Held by way of a wrapper class Wrapper. If Held
-// can be constructed with arguments (A1...An), Wrapper must have a
-// corresponding constructor for arguments (PyObject*, A1...An). Wrapper is
-// neccessary to implement virtual function callbacks (there must be a
-// back-pointer to the actual Python object so that we can call any
-// overrides). held_instance (above) is used as a default Wrapper class when
-// there are no virtual functions.
-template <class Held, class Wrapper>
-class instance_value_holder : public instance_holder<Held>
-{
-public:
-    Held* target() { return &m_held; }
-    Wrapper* value_target() { return &m_held; }
-
-    instance_value_holder(extension_instance* p) :
-        m_held(p) {}
-    template <class A1>
-    instance_value_holder(extension_instance* p, A1 a1) :
-        m_held(p, a1) {}
-    template <class A1, class A2>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2) :
-        m_held(p, a1, a2) {}
-    template <class A1, class A2, class A3>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3) :
-        m_held(p, a1, a2, a3) {}
-    template <class A1, class A2, class A3, class A4>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4) :
-        m_held(p, a1, a2, a3, a4) {}
-    template <class A1, class A2, class A3, class A4, class A5>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) :
-        m_held(p, a1, a2, a3, a4, a5) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) :
-        m_held(p, a1, a2, a3, a4, a5, a6) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) :
-        m_held(p, a1, a2, a3, a4, a5, a6, a7) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) :
-        m_held(p, a1, a2, a3, a4, a5, a6, a7, a8) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) :
-        m_held(p, a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    instance_value_holder(extension_instance* p, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9, A10 a10) :
-        m_held(p, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
-
- public: // implementation of instance_holder_base required interface
-    bool held_by_value() { return true; }
-
- private:
-    Wrapper m_held;
-};
-
-// Concrete class which holds a HeldType by way of a (possibly smart) pointer
-// PtrType. By default, these are only generated for PtrType ==
-// std::auto_ptr<HeldType> and PtrType == boost::shared_ptr<HeldType>.
-template <class PtrType, class HeldType>
-class instance_ptr_holder : public instance_holder<HeldType>
-{
- public:
-    HeldType* target() { return &*m_ptr; }
-    PtrType& ptr() { return m_ptr; }
-
-    instance_ptr_holder(PtrType ptr) : m_ptr(ptr) {}
-    
- public: // implementation of instance_holder_base required interface
-    bool held_by_value() { return false; }
- private:
-    PtrType m_ptr;
-};
-
-class extension_instance : public instance
-{
- public:
-    extension_instance(PyTypeObject* class_);
-    ~extension_instance();
-    
-    void add_implementation(std::auto_ptr<instance_holder_base> holder);
-
-    typedef std::vector<instance_holder_base*> held_objects;
-    const held_objects& wrapped_objects() const
-        { return m_wrapped_objects; }
- private:
-    held_objects m_wrapped_objects;
-};
-
-//
-// Template function implementations
-//
-
-template <class T, class U>
-extension_class<T, U>::extension_class()
-    : extension_class_base(typeid(T).name())
-{
-    class_registry<T>::register_class(this);
-}
-
-template <class T, class U>
-extension_class<T, U>::extension_class(const char* name)
-    : extension_class_base(name)
-{
-    class_registry<T>::register_class(this);
-}
-
-template <class T, class U>
-void extension_class<T, U>::def_standard_coerce()
-{
-    ref coerce_fct = dict().get_item(string("__coerce__"));
-    
-    if(coerce_fct.get() == 0) // not yet defined
-        this->def(&standard_coerce, "__coerce__");
-}
-
-template <class T, class U>
-inline
-std::vector<base_class_info> const& 
-extension_class<T, U>::base_classes() const
-{
-    return class_registry<T>::base_classes();
-}
-
-template <class T, class U>
-inline
-std::vector<derived_class_info> const& 
-extension_class<T, U>::derived_classes() const
-{
-    return class_registry<T>::derived_classes();
-}
-       
-template <class T, class U>
-void* extension_class<T, U>::extract_object_from_holder(instance_holder_base* v) const
-{
-    instance_holder<T>* held = dynamic_cast<instance_holder<T>*>(v);
-    if(held)
-        return held->target();
-    return 0;
-}
-
-template <class T, class U>
-extension_class<T, U>::~extension_class()
-{
-    class_registry<T>::unregister_class(this);
-}
-
-template <class T>
-inline void class_registry<T>::register_class(extension_class_base* p)
-{
-    // You're not expected to create more than one of these!
-    assert(static_class_object == 0);
-    static_class_object = p;
-}
-
-template <class T>
-inline void class_registry<T>::unregister_class(extension_class_base* p)
-{
-    // The user should be destroying the same object they created.
-    assert(static_class_object == p);
-    (void)p; // unused in shipping version
-    static_class_object = 0;
-}
-
-template <class T>
-void class_registry<T>::register_base_class(base_class_info const& i)
-{
-    static_base_class_info.push_back(i);
-}
-
-template <class T>
-void class_registry<T>::register_derived_class(derived_class_info const& i)
-{
-    static_derived_class_info.push_back(i);
-}
-
-template <class T>
-std::vector<base_class_info> const& class_registry<T>::base_classes()
-{
-    return static_base_class_info;
-}
-
-template <class T>
-std::vector<derived_class_info> const& class_registry<T>::derived_classes()
-{
-    return static_derived_class_info;
-}
-
-//
-// Static data member declaration.
-//
-template <class T>
-extension_class_base* class_registry<T>::static_class_object;
-template <class T>
-std::vector<base_class_info> class_registry<T>::static_base_class_info;
-template <class T>
-std::vector<derived_class_info> class_registry<T>::static_derived_class_info;
-
-}}} // namespace boost::python::detail
-
-#endif // EXTENSION_CLASS_DWA052000_H_

include/boost/python/detail/functions.hpp

@@ -1,306 +0,0 @@
-//  (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.
-
-#ifndef FUNCTIONS_DWA051400_H_
-# define FUNCTIONS_DWA051400_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/reference.hpp>
-# include <boost/python/detail/signatures.hpp>
-# include <boost/python/caller.hpp>
-# include <boost/call_traits.hpp>
-# include <boost/python/objects.hpp>
-# include <boost/python/detail/base_object.hpp>
-# include <typeinfo>
-# include <vector>
-
-namespace boost { namespace python { namespace detail {
-
-// forward declaration
-class extension_instance;
-
-
-// function --
-//      the common base class for all overloadable function and method objects
-//      supplied by the library.
-class function : public python_object
-{
- public:
-    function();
-    // function objects are reasonably rare, so we guess we can afford a virtual table.
-    // This cuts down on the number of distinct type objects which need to be defined.
-    virtual ~function() {}
-
-    PyObject* call(PyObject* args, PyObject* keywords) const;
-    static void add_to_namespace(reference<function> f, const char* name, PyObject* dict);
-    
- private:
-    virtual PyObject* do_call(PyObject* args, PyObject* keywords) const = 0;
-    virtual const char* description() const = 0;
- private:
-    struct type_object;
- private:
-    reference<function> m_overloads;
-};
-
-// wrapped_function_pointer<> --
-//      A single function or member function pointer wrapped and presented to
-//      Python as a callable object.
-//
-//   Template parameters:
-//      R - the return type of the function pointer
-//      F - the complete type of the wrapped function pointer
-template <class R, class F>
-struct wrapped_function_pointer : function
-{
-	typedef F ptr_fun; // pointer-to--function or pointer-to-member-function
-	
-	wrapped_function_pointer(ptr_fun pf)
-        : m_pf(pf) {}
-
- private:
-	PyObject* do_call(PyObject* args, PyObject* keywords) const
-        { return caller<R>::call(m_pf, args, keywords); }
-    
-    const char* description() const
-        { return typeid(F).name(); }
-    
- private:
-	const ptr_fun m_pf;
-};
-
-// raw_arguments_function
-//      A function that passes the Python argument tuple and keyword dictionary 
-//      verbatim to C++ (useful for customized argument parsing and variable
-//      argument lists)
-template <class Ret, class Args, class Keywords>
-struct raw_arguments_function : function
-{
-	typedef Ret (*ptr_fun)(Args, Keywords); 
-	
-	raw_arguments_function(ptr_fun pf)
-        : m_pf(pf) {}
-
- private:
-	PyObject* do_call(PyObject* args, PyObject* keywords) const
-    { 
-        ref dict(keywords ? 
-                 ref(keywords, ref::increment_count) :
-                 ref(PyDict_New()));
-            
-        return to_python(
-            (*m_pf)(from_python(args, boost::python::type<Args>()),
-                    from_python(dict.get(), boost::python::type<Keywords>()))); 
-    }
-    
-    const char* description() const
-        { return typeid(ptr_fun).name(); }
-    
- private:
-	const ptr_fun m_pf;
-};
-
-// virtual_function<> --
-//      A virtual function with a default implementation wrapped and presented
-//      to Python as a callable object.
-//
-//   Template parameters:
-//      T - the type of the target class
-//      R - the return type of the function pointer
-//      V - the virtual function pointer being wrapped
-//          (should be of the form R(T::*)(<args>), or R (*)(T, <args>))
-//      D - a function which takes a T&, const T&, T*, or const T* first
-//          parameter and calls T::f on it /non-virtually/, where V
-//          approximates &T::f.
-template <class T, class R, class V, class D>
-class virtual_function : public function
-{
- public:
-	virtual_function(V virtual_function_ptr, D default_implementation)
-        : m_virtual_function_ptr(virtual_function_ptr),
-          m_default_implementation(default_implementation)
-        {}
-
- private:
-	PyObject* do_call(PyObject* args, PyObject* keywords) const;
-    
-    const char* description() const
-        { return typeid(V).name(); }
-    
- private:
-	const V m_virtual_function_ptr;
-    const D m_default_implementation;
-};
-
-// A helper function for new_member_function(), below.  Implements the core
-// functionality once the return type has already been deduced. R is expected to
-// be type<X>, where X is the actual return type of pmf.
-template <class F, class R>
-function* new_wrapped_function_aux(R, F pmf)
-{
-    // We can't just use "typename R::Type" below because MSVC (incorrectly) pukes.
-    typedef typename R::type return_type;
-    return new wrapped_function_pointer<return_type, F>(pmf);
-}
-
-// Create and return a new member function object wrapping the given
-// pointer-to-member function
-template <class F>
-inline function* new_wrapped_function(F pmf)
-{
-    // Deduce the return type and pass it off to the helper function above
-	return new_wrapped_function_aux(return_value(pmf), pmf);
-}
-
-template <class R, class Args, class keywords>
-function* new_raw_arguments_function(R (*pmf)(Args, keywords))
-{
-    return new raw_arguments_function<R, Args, keywords>(pmf);
-}
-
-
-// A helper function for new_virtual_function(), below.  Implements the core
-// functionality once the return type has already been deduced. R is expected to
-// be type<X>, where X is the actual return type of V.
-template <class T, class R, class V, class D>
-inline function* new_virtual_function_aux(
-    type<T>, R, V virtual_function_ptr, D default_implementation
-    )
-{
-    // We can't just use "typename R::Type" below because MSVC (incorrectly) pukes.
-    typedef typename R::type return_type;
-    return new virtual_function<T, return_type, V, D>(
-        virtual_function_ptr, default_implementation);
-}
-
-// Create and return a new virtual_function object wrapping the given
-// virtual_function_ptr and default_implementation
-template <class T, class V, class D>
-inline function* new_virtual_function(
-    type<T>, V virtual_function_ptr, D default_implementation
-    )
-{
-    // Deduce the return type and pass it off to the helper function above
-    return new_virtual_function_aux(
-        type<T>(), return_value(virtual_function_ptr),
-        virtual_function_ptr, default_implementation);
-}
-
-// A function with a bundled "bound target" object. This is what is produced by
-// the expression a.b where a is an instance or extension_instance object and b
-// is a callable object not found in the obj namespace but on its class or
-// a base class.
-class bound_function : public python_object
-{
- public:
-    static bound_function* create(const ref& target, const ref& fn);
-    
-    bound_function(const ref& target, const ref& fn);
-    PyObject* call(PyObject*args, PyObject* keywords) const;
-    PyObject* getattr(const char* name) const;
-    
- private:
-    struct type_object;
-    friend struct type_object;
-    
-    ref m_target;
-    ref m_unbound_function;
-    
- private: // data members for allocation/deallocation optimization
-    bound_function* m_free_list_link;
-
-	static bound_function* free_list;
-};
-
-// Special functions designed to access data members of a wrapped C++ object.
-template <class ClassType, class MemberType>
-class getter_function : public function
-{
- public:
-    typedef MemberType ClassType::* pointer_to_member;
-    
-    getter_function(pointer_to_member pm)
-        : m_pm(pm) {}
-
- private:
-    PyObject* do_call(PyObject* args, PyObject* keywords) const;
-    
-    const char* description() const
-        { return typeid(MemberType (*)(const ClassType&)).name(); }
- private:
-    pointer_to_member m_pm;
-};
-
-template <class ClassType, class MemberType>
-class setter_function : public function
-{
- public:
-    typedef MemberType ClassType::* pointer_to_member;
-    
-    setter_function(pointer_to_member pm)
-        : m_pm(pm) {}
-
- private:
-    PyObject* do_call(PyObject* args, PyObject* keywords) const;
-    
-    const char* description() const
-        { return typeid(void (*)(const ClassType&, const MemberType&)).name(); }
- private:
-    pointer_to_member m_pm;
-};
-
-template <class ClassType, class MemberType>
-PyObject* getter_function<ClassType, MemberType>::do_call(
-    PyObject* args, PyObject* /* keywords */) const
-{
-    PyObject* self;
-    if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &self))
-        return 0;
-
-    return to_python(
-        from_python(self, type<const ClassType*>())->*m_pm);
-}
-
-template <class ClassType, class MemberType>
-PyObject* setter_function<ClassType, MemberType>::do_call(
-    PyObject* args, PyObject* /* keywords */) const
-{
-    PyObject* self;
-    PyObject* value;
-    if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &self, &value))
-        return 0;
-    
-    typedef typename boost::call_traits<MemberType>::const_reference extract_type;
-    from_python(self, type<ClassType*>())->*m_pm
-        = from_python(value, type<extract_type>());
-    
-    return none();
-}
-
-template <class T, class R, class V, class D>
-PyObject* virtual_function<T,R,V,D>::do_call(PyObject* args, PyObject* keywords) const
-{
-    // If the target object is held by pointer, we must call through the virtual
-    // function pointer to the most-derived override.
-    PyObject* target = PyTuple_GetItem(args, 0);
-    if (target != 0)
-    {
-        extension_instance* self = get_extension_instance(target);
-        if (self->wrapped_objects().size() == 1
-            && !self->wrapped_objects()[0]->held_by_value())
-        {
-            return caller<R>::call(m_virtual_function_ptr, args, keywords);
-        }
-    }
-    return caller<R>::call(m_default_implementation, args, keywords);
-}
-    
-}}} // namespace boost::python::detail
-
-#endif // FUNCTIONS_DWA051400_H_

include/boost/python/detail/init_function.hpp

@@ -1,507 +0,0 @@
-//  (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 was generated for %d-argument constructors by gen_init_function.python
-
-#ifndef INIT_FUNCTION_DWA052000_H_
-# define INIT_FUNCTION_DWA052000_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/functions.hpp>
-# include <boost/python/detail/signatures.hpp>
-# include <typeinfo>
-
-namespace boost { namespace python {
-
-namespace detail {
-
-  // parameter_traits - so far, this is a way to pass a const T& when we can be
-  // sure T is not a reference type, and a raw T otherwise. This should be
-  // rolled into boost::call_traits. Ordinarily, parameter_traits would be
-  // written:
-  //
-  //    template <class T> struct parameter_traits
-  //    {
-  //        typedef const T& const_reference;
-  //    };
-  //
-  //    template <class T> struct parameter_traits<T&>
-  //    {
-  //        typedef T& const_reference;
-  //    };
-  //
-  //    template <> struct parameter_traits<void>
-  //    {
-  //        typedef void const_reference;
-  //    };
-  //
-  // ...but since we can't partially specialize on reference types, we need this
-  // long-winded but equivalent incantation.
-
-  // const_ref_selector -- an implementation detail of parameter_traits (below). This uses
-  // the usual "poor man's partial specialization" hack for MSVC. 
-  template <bool is_ref>
-  struct const_ref_selector
-  {
-      template <class T>
-      struct const_ref
-      {
-          typedef const T& type;
-      };
-  };
-
-  template <>
-  struct const_ref_selector<true>
-  {
-      template <class T>
-      struct const_ref
-      {
-          typedef T type;
-      };
-  };
-
-# ifdef BOOST_MSVC
-#  pragma warning(push)
-#  pragma warning(disable: 4181)
-# endif // BOOST_MSVC
-  template <class T>
-  struct parameter_traits
-  {
-   private:
-      typedef const_ref_selector<boost::is_reference<T>::value> selector;
-   public:
-      typedef typename selector::template const_ref<T>::type const_reference;
-  };
-# ifdef BOOST_MSVC
-#  pragma warning(pop)
-# endif // BOOST_MSVC
-
-  // Full spcialization for void
-  template <>
-  struct parameter_traits<void>
-  {
-      typedef void const_reference;
-  };
-
-  template <class T>
-  class reference_parameter
-  {
-      typedef typename parameter_traits<T>::const_reference const_reference;
-   public:
-      reference_parameter(const_reference value)
-          : value(value) {}
-      operator const_reference() { return value; }
-   private:
-      const_reference value;
-  };
-
-class extension_instance;
-class instance_holder_base;
-
-class init;
-template <class T> struct init0;
-template <class T, class A1> struct init1;
-template <class T, class A1, class A2> struct init2;
-template <class T, class A1, class A2, class A3> struct init3;
-template <class T, class A1, class A2, class A3, class A4> struct init4;
-template <class T, class A1, class A2, class A3, class A4, class A5> struct init5;
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6> struct init6;
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7> struct init7;
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> struct init8;
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> struct init9;
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10> struct init10;
-
-template <class T>
-struct init_function
-{
-    static init* create(signature0) {
-        return new init0<T>;
-    }
-
-    template <class A1>
-    static init* create(signature1<A1>) {
-        return new init1<T,
-                       detail::parameter_traits<A1>::const_reference>;
-    }
-
-    template <class A1, class A2>
-    static init* create(signature2<A1, A2>) {
-        return new init2<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3>
-    static init* create(signature3<A1, A2, A3>) {
-        return new init3<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4>
-    static init* create(signature4<A1, A2, A3, A4>) {
-        return new init4<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    static init* create(signature5<A1, A2, A3, A4, A5>) {
-        return new init5<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    static init* create(signature6<A1, A2, A3, A4, A5, A6>) {
-        return new init6<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference,
-                       detail::parameter_traits<A6>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    static init* create(signature7<A1, A2, A3, A4, A5, A6, A7>) {
-        return new init7<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference,
-                       detail::parameter_traits<A6>::const_reference,
-                       detail::parameter_traits<A7>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    static init* create(signature8<A1, A2, A3, A4, A5, A6, A7, A8>) {
-        return new init8<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference,
-                       detail::parameter_traits<A6>::const_reference,
-                       detail::parameter_traits<A7>::const_reference,
-                       detail::parameter_traits<A8>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    static init* create(signature9<A1, A2, A3, A4, A5, A6, A7, A8, A9>) {
-        return new init9<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference,
-                       detail::parameter_traits<A6>::const_reference,
-                       detail::parameter_traits<A7>::const_reference,
-                       detail::parameter_traits<A8>::const_reference,
-                       detail::parameter_traits<A9>::const_reference>;
-    }
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    static init* create(signature10<A1, A2, A3, A4, A5, A6, A7, A8, A9, A10>) {
-        return new init10<T,
-                       detail::parameter_traits<A1>::const_reference,
-                       detail::parameter_traits<A2>::const_reference,
-                       detail::parameter_traits<A3>::const_reference,
-                       detail::parameter_traits<A4>::const_reference,
-                       detail::parameter_traits<A5>::const_reference,
-                       detail::parameter_traits<A6>::const_reference,
-                       detail::parameter_traits<A7>::const_reference,
-                       detail::parameter_traits<A8>::const_reference,
-                       detail::parameter_traits<A9>::const_reference,
-                       detail::parameter_traits<A10>::const_reference>;
-    }
-};
-
-class init : public function
-{
-private: // override function hook
-    PyObject* do_call(PyObject* args, PyObject* keywords) const;
-private:
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* tail_args, PyObject* keywords) const = 0;
-};
-
-
-template <class T>
-struct init0 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        if (!PyArg_ParseTuple(args, const_cast<char*>("")))
-            throw argument_error();
-        return new T(self
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&)).name(); }
-};
-
-template <class T, class A1>
-struct init1 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("O"), &a1))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1)).name(); }
-};
-
-template <class T, class A1, class A2>
-struct init2 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OO"), &a1, &a2))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2)).name(); }
-};
-
-template <class T, class A1, class A2, class A3>
-struct init3 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOO"), &a1, &a2, &a3))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4>
-struct init4 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOO"), &a1, &a2, &a3, &a4))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5>
-struct init5 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOO"), &a1, &a2, &a3, &a4, &a5))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6>
-struct init6 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
-            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-struct init7 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
-            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
-            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-struct init8 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        PyObject* a8;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
-            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
-            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>())),
-            boost::python::detail::reference_parameter<A8>(from_python(a8, type<A8>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-struct init9 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        PyObject* a8;
-        PyObject* a9;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
-            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
-            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>())),
-            boost::python::detail::reference_parameter<A8>(from_python(a8, type<A8>())),
-            boost::python::detail::reference_parameter<A9>(from_python(a9, type<A9>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8, A9)).name(); }
-};
-
-template <class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-struct init10 : init
-{
-    virtual instance_holder_base* create_holder(extension_instance* self, PyObject* args, PyObject* /*keywords*/) const
-    {
-        PyObject* a1;
-        PyObject* a2;
-        PyObject* a3;
-        PyObject* a4;
-        PyObject* a5;
-        PyObject* a6;
-        PyObject* a7;
-        PyObject* a8;
-        PyObject* a9;
-        PyObject* a10;
-        if (!PyArg_ParseTuple(args, const_cast<char*>("OOOOOOOOOO"), &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10))
-            throw argument_error();
-        return new T(self,
-            boost::python::detail::reference_parameter<A1>(from_python(a1, type<A1>())),
-            boost::python::detail::reference_parameter<A2>(from_python(a2, type<A2>())),
-            boost::python::detail::reference_parameter<A3>(from_python(a3, type<A3>())),
-            boost::python::detail::reference_parameter<A4>(from_python(a4, type<A4>())),
-            boost::python::detail::reference_parameter<A5>(from_python(a5, type<A5>())),
-            boost::python::detail::reference_parameter<A6>(from_python(a6, type<A6>())),
-            boost::python::detail::reference_parameter<A7>(from_python(a7, type<A7>())),
-            boost::python::detail::reference_parameter<A8>(from_python(a8, type<A8>())),
-            boost::python::detail::reference_parameter<A9>(from_python(a9, type<A9>())),
-            boost::python::detail::reference_parameter<A10>(from_python(a10, type<A10>()))
-            );
-    }
-    const char* description() const
-        { return typeid(void (*)(T&, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)).name(); }
-};
-
-}}} // namespace boost::python::detail
-
-#endif // INIT_FUNCTION_DWA052000_H_

include/boost/python/detail/none.hpp

@@ -1,21 +0,0 @@
-//  (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.
-
-#ifndef NONE_DWA_052000_H_
-# define NONE_DWA_052000_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-
-namespace boost { namespace python { namespace detail {
-
-inline PyObject* none() { Py_INCREF(Py_None); return Py_None; }
-    
-}}} // namespace boost::python::detail
-
-#endif // NONE_DWA_052000_H_

include/boost/python/detail/signatures.hpp

@@ -1,251 +0,0 @@
-//  (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 automatically generated by gen_signatures.python for 10 arguments.
-#ifndef SIGNATURES_DWA050900_H_
-# define SIGNATURES_DWA050900_H_
-
-# include <boost/python/detail/config.hpp>
-
-namespace boost { namespace python {
-
-namespace detail {
-// A stand-in for the built-in void. This one can be passed to functions and
-// (under MSVC, which has a bug, be used as a default template type parameter).
-struct void_t {};
-}
-
-// An envelope in which type information can be delivered for the purposes
-// of selecting an overloaded from_python() function. This is needed to work
-// around MSVC's lack of partial specialiation/ordering. Where normally we'd
-// want to form a function call like void f<const T&>(), We instead pass
-// type<const T&> as one of the function parameters to select a particular
-// overload.
-//
-// The id typedef helps us deal with the lack of partial ordering by generating
-// unique types for constructor signatures. In general, type<T>::id is type<T>,
-// but type<void_t>::id is just void_t.
-template <class T>
-struct type
-{
-    typedef type id;
-};
-
-template <>
-struct type<boost::python::detail::void_t>
-{
-    typedef boost::python::detail::void_t id;
-};
-
-namespace detail {
-// These basically encapsulate a chain of types, , used to make the syntax of
-// add(constructor<T1, ...>()) work. We need to produce a unique type for each number
-// of non-default parameters to constructor<>.  Q: why not use a recursive
-// formulation for infinite extensibility? A: MSVC6 seems to choke on constructs
-// that involve recursive template nesting.
-//
-// signature chaining
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
-struct signature10 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9>
-struct signature9 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class X>
-inline signature10<X, T1, T2, T3, T4, T5, T6, T7, T8, T9> prepend(type<X>, signature9<T1, T2, T3, T4, T5, T6, T7, T8, T9>)
-    { return signature10<X, T1, T2, T3, T4, T5, T6, T7, T8, T9>(); }
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
-struct signature8 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class X>
-inline signature9<X, T1, T2, T3, T4, T5, T6, T7, T8> prepend(type<X>, signature8<T1, T2, T3, T4, T5, T6, T7, T8>)
-    { return signature9<X, T1, T2, T3, T4, T5, T6, T7, T8>(); }
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
-struct signature7 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class T7, class X>
-inline signature8<X, T1, T2, T3, T4, T5, T6, T7> prepend(type<X>, signature7<T1, T2, T3, T4, T5, T6, T7>)
-    { return signature8<X, T1, T2, T3, T4, T5, T6, T7>(); }
-
-template <class T1, class T2, class T3, class T4, class T5, class T6>
-struct signature6 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class T6, class X>
-inline signature7<X, T1, T2, T3, T4, T5, T6> prepend(type<X>, signature6<T1, T2, T3, T4, T5, T6>)
-    { return signature7<X, T1, T2, T3, T4, T5, T6>(); }
-
-template <class T1, class T2, class T3, class T4, class T5>
-struct signature5 {};
-
-template <class T1, class T2, class T3, class T4, class T5, class X>
-inline signature6<X, T1, T2, T3, T4, T5> prepend(type<X>, signature5<T1, T2, T3, T4, T5>)
-    { return signature6<X, T1, T2, T3, T4, T5>(); }
-
-template <class T1, class T2, class T3, class T4>
-struct signature4 {};
-
-template <class T1, class T2, class T3, class T4, class X>
-inline signature5<X, T1, T2, T3, T4> prepend(type<X>, signature4<T1, T2, T3, T4>)
-    { return signature5<X, T1, T2, T3, T4>(); }
-
-template <class T1, class T2, class T3>
-struct signature3 {};
-
-template <class T1, class T2, class T3, class X>
-inline signature4<X, T1, T2, T3> prepend(type<X>, signature3<T1, T2, T3>)
-    { return signature4<X, T1, T2, T3>(); }
-
-template <class T1, class T2>
-struct signature2 {};
-
-template <class T1, class T2, class X>
-inline signature3<X, T1, T2> prepend(type<X>, signature2<T1, T2>)
-    { return signature3<X, T1, T2>(); }
-
-template <class T1>
-struct signature1 {};
-
-template <class T1, class X>
-inline signature2<X, T1> prepend(type<X>, signature1<T1>)
-    { return signature2<X, T1>(); }
-
-struct signature0 {};
-
-template <class X>
-inline signature1<X> prepend(type<X>, signature0)
-    { return signature1<X>(); }
-
-
-// This one terminates the chain. Prepending void_t to the head of a void_t
-// signature results in a void_t signature again.
-inline signature0 prepend(void_t, signature0) { return signature0(); }
-
-} // namespace detail
-
-template <class A1 = detail::void_t, class A2 = detail::void_t, class A3 = detail::void_t, class A4 = detail::void_t, class A5 = detail::void_t, class A6 = detail::void_t, class A7 = detail::void_t, class A8 = detail::void_t, class A9 = detail::void_t, class A10 = detail::void_t>
-struct constructor
-{
-};
-
-namespace detail {
-// Return value extraction:
-
-// This is just another little envelope for carrying a typedef (see type,
-// above). I could have re-used type, but that has a very specific purpose. I
-// thought this would be clearer.
-template <class T>
-struct return_value_select { typedef T type; };
-
-// free functions
-template <class R>
-return_value_select<R> return_value(R (*)()) { return return_value_select<R>(); }
-
-template <class R, class A1>
-return_value_select<R> return_value(R (*)(A1)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2>
-return_value_select<R> return_value(R (*)(A1, A2)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3>
-return_value_select<R> return_value(R (*)(A1, A2, A3)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) { return return_value_select<R>(); }
-
-template <class R, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-return_value_select<R> return_value(R (*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) { return return_value_select<R>(); }
-
-// TODO(?): handle 'const void'
-
-// member functions
-template <class R, class T>
-return_value_select<R> return_value(R (T::*)()) { return return_value_select<R>(); }
-
-template <class R, class T, class A1>
-return_value_select<R> return_value(R (T::*)(A1)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2>
-return_value_select<R> return_value(R (T::*)(A1, A2)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9)) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)) { return return_value_select<R>(); }
-
-template <class R, class T>
-return_value_select<R> return_value(R (T::*)() const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1>
-return_value_select<R> return_value(R (T::*)(A1) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2>
-return_value_select<R> return_value(R (T::*)(A1, A2) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9) const) { return return_value_select<R>(); }
-
-template <class R, class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-return_value_select<R> return_value(R (T::*)(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) const) { return return_value_select<R>(); }
-
-}}} // namespace boost::python::detail
-
-#endif

include/boost/python/detail/singleton.hpp

@@ -1,68 +0,0 @@
-//  (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.
-
-#ifndef SINGLETON_DWA051900_H_
-# define SINGLETON_DWA051900_H_
-
-# include <boost/python/detail/config.hpp>
-
-namespace boost { namespace python { namespace detail {
-
-struct empty {};
-template <class Derived, class Base = empty>
-struct singleton : Base
-{
-    typedef singleton singleton_base; // Convenience type for derived class constructors
-    
-    static Derived* instance();
-
-    // Pass-through constructors
-    singleton() : Base() {}
-
-    template <class A1>
-    singleton(const A1& a1) : Base(a1) {}
-
-    template <class A1, class A2>
-    singleton(const A1& a1, const A2& a2) : Base(a1, a2) {}
-
-    template <class A1, class A2, class A3>
-    singleton(const A1& a1, const A2& a2, const A3& a3) : Base(a1, a2, a3) {}
-
-    template <class A1, class A2, class A3, class A4>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4) : Base(a1, a2, a3, a4) {}
-
-    template <class A1, class A2, class A3, class A4, class A5>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5) : Base(a1, a2, a3, a4, a5) {}
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6) : Base(a1, a2, a3, a4, a5, a6) {}
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7) : Base(a1, a2, a3, a4, a5, a6, a7) {}
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8) : Base(a1, a2, a3, a4, a5, a6, a7, a8) {}
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9) : Base(a1, a2, a3, a4, a5, a6, a7, a8, a9) {}
-
-    template <class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
-    singleton(const A1& a1, const A2& a2, const A3& a3, const A4& a4, const A5& a5, const A6& a6, const A7& a7, const A8& a8, const A9& a9, const A10& a10) : Base(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) {}
-
-};
-
-template <class Derived, class Base>
-Derived* singleton<Derived,Base>::instance()
-{
-    static Derived x;
-    return &x;
-}
-
-}}} // namespace boost::python::detail
-
-#endif

include/boost/python/detail/types.hpp

@@ -1,389 +0,0 @@
-//  (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.
-
-#ifndef TYPES_DWA051800_H_
-# define TYPES_DWA051800_H_
-
-//  Usage:
-//  class X : public
-//          boost::python::callable<
-//          boost::python::getattrable <
-//          boost::python::setattrable<python_object, X> > >
-//  {
-//  public:
-//      ref call(args, kw);
-//      ref getattr(args, kw);
-//      ref setattr(args, kw);
-//  };
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/detail/signatures.hpp> // really just for type<>
-# include <boost/python/detail/cast.hpp>
-# include <boost/python/detail/base_object.hpp>
-# include <typeinfo>
-# include <vector>
-# include <cassert>
-
-namespace boost { namespace python {
-
-class string;
-
-namespace detail {
-
-class instance_holder_base;
-
-class type_object_base : public python_type
-{
- public:
-    explicit type_object_base(PyTypeObject* type_type);
-    virtual ~type_object_base();
-
- public:
-    enum capability {
-        hash, call, str, getattr, setattr, compare, repr,
-
-        mapping_length, mapping_subscript, mapping_ass_subscript,
-        
-        sequence_length, sequence_item, sequence_ass_item,
-        sequence_concat, sequence_repeat, sequence_slice, sequence_ass_slice,
-        
-        number_add, number_subtract, number_multiply, number_divide,
-        number_remainder, number_divmod, number_power, number_negative,
-        number_positive, number_absolute, number_nonzero, number_invert,
-        number_lshift, number_rshift, number_and, number_xor, number_or,
-        number_coerce, number_int, number_long, number_float, number_oct,
-        number_hex
-    };
-    
-    void enable(capability);
-    
-    //
-    // type behaviors
-    //
- public: // Callbacks for basic type functionality.
-    virtual PyObject* instance_repr(PyObject*) const;
-    virtual int instance_compare(PyObject*, PyObject* other) const;
-    virtual PyObject* instance_str(PyObject*) const;
-    virtual long instance_hash(PyObject*) const;
-    virtual PyObject* instance_call(PyObject* obj, PyObject* args, PyObject* kw) const;
-    virtual PyObject* instance_getattr(PyObject* obj, const char* name) const;
-    virtual int instance_setattr(PyObject* obj, const char* name, PyObject* value) const;
-
-    // Dealloc is a special case, since every type needs a nonzero tp_dealloc slot.
-    virtual void instance_dealloc(PyObject*) const = 0;
-
- public: // Callbacks for mapping methods
-    virtual int instance_mapping_length(PyObject*) const;
-    virtual PyObject* instance_mapping_subscript(PyObject*, PyObject*) const ;
-    virtual int instance_mapping_ass_subscript(PyObject*, PyObject*, PyObject*) const;
-
- public: // Callbacks for sequence methods
-    virtual int instance_sequence_length(PyObject* obj) const;
-    virtual PyObject* instance_sequence_concat(PyObject* obj, PyObject* other) const;
-    virtual PyObject* instance_sequence_repeat(PyObject* obj, int n) const;
-    virtual PyObject* instance_sequence_item(PyObject* obj, int n) const;
-    virtual PyObject* instance_sequence_slice(PyObject* obj, int start, int finish) const;
-    virtual int instance_sequence_ass_item(PyObject* obj, int n, PyObject* value) const;
-    virtual int instance_sequence_ass_slice(PyObject* obj, int start, int finish, PyObject* value) const;
-    
- public: // Callbacks for number methods
-    virtual PyObject* instance_number_add(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_subtract(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_multiply(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_divide(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_remainder(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_divmod(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_power(PyObject*, PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_negative(PyObject*) const;
-    virtual PyObject* instance_number_positive(PyObject*) const;
-    virtual PyObject* instance_number_absolute(PyObject*) const;
-    virtual int instance_number_nonzero(PyObject*) const;
-    virtual PyObject* instance_number_invert(PyObject*) const;
-    virtual PyObject* instance_number_lshift(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_rshift(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_and(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_xor(PyObject*, PyObject*) const;
-    virtual PyObject* instance_number_or(PyObject*, PyObject*) const;
-    virtual int instance_number_coerce(PyObject*, PyObject**, PyObject**) const;
-    virtual PyObject* instance_number_int(PyObject*) const;
-    virtual PyObject* instance_number_long(PyObject*) const;
-    virtual PyObject* instance_number_float(PyObject*) const;
-    virtual PyObject* instance_number_oct(PyObject*) const;
-    virtual PyObject* instance_number_hex(PyObject*) const;
-};
-
-template <class T>
-class type_object : public type_object_base
-{
- public:
-    typedef T instance;
-
-    type_object(PyTypeObject* type_type, const char* name)
-        : type_object_base(type_type)
-    {
-        assert(name != 0);
-        this->tp_name = const_cast<char*>(name);
-    }
-
-    type_object(PyTypeObject* type_type)
-        : type_object_base(type_type)
-    {
-        this->tp_name = const_cast<char*>(typeid(instance).name());
-    }
-
- private: // Overridable behaviors.
-    // Called when the reference count goes to zero. The default implementation
-    // is "delete p". If you have not allocated your object with operator new or
-    // you have other constraints, you'll need to override this
-    virtual void dealloc(T* p) const;
-    
- private: // Implementation of type_object_base hooks. Do not reimplement in derived classes.
-    void instance_dealloc(PyObject*) const;
-};
-
-//
-// type objects
-//
-template <class Base>
-class callable : public Base
-{
- public:
-    typedef callable properties; // Convenience for derived class construction
-    typedef typename Base::instance instance;
-    callable(PyTypeObject* type_type, const char* name);
-    callable(PyTypeObject* type_type);
- private:
-    PyObject* instance_call(PyObject* obj, PyObject* args, PyObject* kw) const;
-};
-
-template <class Base>
-class getattrable : public Base
-{
- public:
-    typedef getattrable properties; // Convenience for derived class construction
-    typedef typename Base::instance instance;
-    getattrable(PyTypeObject* type_type, const char* name);
-    getattrable(PyTypeObject* type_type);
- private:
-    PyObject* instance_getattr(PyObject* obj, const char* name) const;
-};
-
-template <class Base>
-class setattrable : public Base
-{
- public:
-    typedef setattrable properties; // Convenience for derived class construction
-    typedef typename Base::instance instance;
-    setattrable(PyTypeObject* type_type, const char* name);
-    setattrable(PyTypeObject* type_type);
- private:
-    int instance_setattr(PyObject* obj, const char* name, PyObject* value) const;
-};
-
-template <class Base>
-class reprable : public Base
-{
- public:
-    typedef reprable properties; // Convenience for derived class construction
-    typedef typename Base::instance instance;
-    reprable(PyTypeObject* type_type, const char* name);
-    reprable(PyTypeObject* type_type);
- private:
-    PyObject* instance_repr(PyObject* obj) const;
-};
-
-//
-// Member function definitions
-//
-
-// type_object<>
-template <class T>
-void type_object<T>::instance_dealloc(PyObject* obj) const
-{
-    this->dealloc(downcast<instance>(obj).get());
-}
-
-template <class T>
-void type_object<T>::dealloc(T* obj) const
-{
-    delete obj;
-}
-
-// callable
-template <class Base>
-callable<Base>::callable(PyTypeObject* type_type, const char* name)
-    : Base(type_type, name)
-{
-    this->enable(call);
-}
-        
-template <class Base>
-callable<Base>::callable(PyTypeObject* type_type)
-    : Base(type_type)
-{
-    this->enable(call);
-}
-        
-template <class Base>
-PyObject* callable<Base>::instance_call(PyObject* obj, PyObject* args, PyObject* kw) const
-{
-    return downcast<instance>(obj)->call(args, kw);
-}
-
-// getattrable
-template <class Base>
-getattrable<Base>::getattrable(PyTypeObject* type_type, const char* name)
-    : Base(type_type, name)
-{
-    this->enable(getattr);
-}
-        
-template <class Base>
-getattrable<Base>::getattrable(PyTypeObject* type_type)
-    : Base(type_type)
-{
-    this->enable(getattr);
-}
-        
-template <class Base>
-PyObject* getattrable<Base>::instance_getattr(PyObject* obj, const char* name) const
-{
-    return downcast<instance>(obj)->getattr(name);
-}
-
-// setattrable
-template <class Base>
-setattrable<Base>::setattrable(PyTypeObject* type_type, const char* name)
-    : Base(type_type, name)
-{
-    this->enable(setattr);
-}
-        
-template <class Base>
-setattrable<Base>::setattrable(PyTypeObject* type_type)
-    : Base(type_type)
-{
-    this->enable(setattr);
-}
-        
-template <class Base>
-int setattrable<Base>::instance_setattr(PyObject* obj, const char* name, PyObject* value) const
-{
-    return downcast<instance>(obj)->setattr(name, value);
-}
-
-// reprable
-template <class Base>
-reprable<Base>::reprable(PyTypeObject* type_type, const char* name)
-    : Base(type_type, name)
-{
-    this->enable(repr);
-}
-        
-template <class Base>
-reprable<Base>::reprable(PyTypeObject* type_type)
-    : Base(type_type)
-{
-    this->enable(repr);
-}
-        
-template <class Base>
-PyObject* reprable<Base>::instance_repr(PyObject* obj) const
-{
-    return downcast<instance>(obj)->repr();
-}
-
-  // Helper class for optimized allocation of PODs: If two PODs
-  // happen to contain identical byte patterns, they may share their
-  // memory. Reference counting is used to free unused memory. 
-  // This is useful because method tables of related extension classes tend
-  // to be identical, so less memory is needed for them.
-  class shared_pod_manager
-  {
-      typedef std::pair<char*, std::size_t> holder;
-      typedef std::vector<holder> storage;
-        
-   public:
-      static shared_pod_manager& obj();
-      ~shared_pod_manager();
-
-      // Allocate memory for POD T and fill it with zeros.
-      // This memory is initially not shared.
-      template <class T>
-      static void create(T*& t)
-      {
-          t = reinterpret_cast<T*>(obj().create(sizeof(T)));
-      }
-
-      // Decrement the refcount for the memory t points to. If the count 
-      // goes to zero, the memory is freed.
-      template <class T>
-      static void dispose(T* t)
-      {
-          obj().dec_ref(t, sizeof(T));
-      }
-
-      // Attempt to share the memory t points to. If memory with the same 
-      // contents already exists, t is replaced by a pointer to this memory,
-      // and t's old memory is disposed. Otherwise, t will be registered for
-      // potential future sharing.
-      template <class T>
-      static void replace_if_equal(T*& t)
-      {
-          t = reinterpret_cast<T*>(obj().replace_if_equal(t, sizeof(T)));
-      }
-
-      // Create a copy of t's memory that is guaranteed to be private to t.
-      // Afterwards t points to the new memory, unless it was already private, in
-      // which case there is no change (except that t's memory will no longer
-      // be considered for future sharing - see raplade_if_equal())
-      // This function *must* be called before the contents of (*t) can
-      // be overwritten. Otherwise, inconsistencies and crashes may result.
-      template <class T>
-      static void make_unique_copy(T*& t)
-      {
-          t = reinterpret_cast<T*>(obj().make_unique_copy(t, sizeof(T)));
-      }
-
-   private:
-      void* replace_if_equal(void* pod, std::size_t size);
-      void* make_unique_copy(void* pod, std::size_t size);
-      void* create(std::size_t size);
-      void dec_ref(void* pod, std::size_t size);
-      void erase_from_list(void* pod);
-        
-      struct compare;
-      struct identical;
-
-   private:
-      shared_pod_manager() {} // instance
-
-#ifdef TYPE_OBJECT_BASE_STANDALONE_TEST
-   public:
-#endif
-      storage m_storage;
-  };
-
-
-  void add_capability(type_object_base::capability capability, 
-                      PyTypeObject* dest);
-
-// This macro gets the length of an array as a compile-time constant, and will
-// fail to compile if the parameter is a pointer.
-# define PY_ARRAY_LENGTH(a) \
-        (sizeof(::boost::python::detail::countof_validate(a, &(a))) ? sizeof(a) / sizeof((a)[0]) : 0)
-
-  template<typename T>
-  inline void countof_validate(T* const, T* const*);
-
-  template<typename T>
-  inline int countof_validate(const void*, T);
-
-}}} // namespace boost::python::detail
-
-#endif // TYPES_DWA051800_H_

include/boost/python/detail/wrap_python.hpp

@@ -1,78 +0,0 @@
-//  (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 <Python.h> 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 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
-#endif
-
-//
-// Some things we need in order to get Python.h to work with compilers other
-// than MSVC on Win32
-//
-#if defined(_WIN32)
-# ifdef __GNUC__
-
-typedef int pid_t;
-#  define WORD_BIT 32
-#  define hypot _hypot
-#  include <stdio.h>
-#  define HAVE_CLOCK
-#  define HAVE_STRFTIME
-#  define HAVE_STRERROR
-#  define NT_THREADS
-#  define WITH_THREAD
-#  ifndef NETSCAPE_PI
-#   define USE_SOCKET
-#  endif
-
-#  ifdef USE_DL_IMPORT
-#   define DL_IMPORT(RTYPE) __declspec(dllimport) RTYPE
-#  endif
-
-#  ifdef USE_DL_EXPORT
-#   define DL_IMPORT(RTYPE) __declspec(dllexport) RTYPE
-#   define DL_EXPORT(RTYPE) __declspec(dllexport) RTYPE
-#  endif
-
-#  define HAVE_LONG_LONG 1
-#  define LONG_LONG long long
-
-# elif defined(__MWERKS__)
-
-#  ifndef _MSC_VER
-#   define PY_MSC_VER_DEFINED_FROM_WRAP_PYTHON_H 1
-#   define _MSC_VER 900
-#  endif
-
-# endif
-
-#endif // _WIN32
-
-#include <Python.h>
-
-#ifdef PY_MSC_VER_DEFINED_FROM_WRAP_PYTHON_H
-# undef _MSC_VER
-#endif
-
-#ifdef DEBUG_UNDEFINED_FROM_WRAP_PYTHON_H
-# undef DEBUG_UNDEFINED_FROM_WRAP_PYTHON_H
-# define _DEBUG
-#endif
-

include/boost/python/errors.hpp

@@ -1,30 +0,0 @@
-//  (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.
-
-#ifndef ERRORS_DWA052500_H_
-# define ERRORS_DWA052500_H_
-
-namespace boost { namespace python {
-
-struct error_already_set {};
-struct argument_error : error_already_set {};
-
-// Handles exceptions caught just before returning to Python code.
-void handle_exception();
-
-template <class T>
-T* expect_non_null(T* x)
-{
-    if (x == 0)
-        throw error_already_set();
-    return x;
-}
-
-}} // namespace boost::python
-
-#endif // ERRORS_DWA052500_H_

include/boost/python/module_builder.hpp

@@ -1,68 +0,0 @@
-//  (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.
-
-#ifndef MODULE_DWA051000_H_
-# define MODULE_DWA051000_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/python/reference.hpp>
-# include <boost/python/objects.hpp>
-# include <boost/python/detail/functions.hpp>
-
-namespace boost { namespace python {
-
-class module_builder
-{
- 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);
-    void add(PyTypeObject* x, const char* name = 0);
-    void add(ref x, const char*name);
-
-    template <class Fn>
-    void def_raw(Fn fn, const char* name)
-    {
-        add(detail::new_raw_arguments_function(fn), name);
-    }
-    
-    template <class Fn>
-    void def(Fn fn, const char* name)
-    {
-        add(detail::new_wrapped_function(fn), 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

include/boost/python/objects.hpp

@@ -1,334 +0,0 @@
-//  (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.
-
-#ifndef OBJECTS_DWA051100_H_
-# define OBJECTS_DWA051100_H_
-
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/detail/config.hpp>
-# include <boost/python/reference.hpp>
-# include "boost/operators.hpp"
-# include <utility>
-
-namespace boost { namespace python {
-
-class object
-{
- public:
-    explicit object(ref p);
-    
-    // Return a reference to the held object
-    ref reference() const;
-
-    // Return a raw pointer to the held object
-    PyObject* get() const;
-    
- private:
-    ref m_p;
-};
-
-class tuple : public object
-{
- public:
-    explicit tuple(std::size_t n = 0);
-    explicit tuple(ref p);
-
-    template <class First, class Second>
-    tuple(const std::pair<First,Second>& x)
-        : object(ref(PyTuple_New(2)))
-    {
-        set_item(0, x.first);
-        set_item(1, x.second);
-    }
-    
-    template <class First, class Second>
-    tuple(const First& first, const Second& second)
-        : object(ref(PyTuple_New(2)))
-    {
-        set_item(0, first);
-        set_item(1, second);
-    }
-    
-    template <class First, class Second, class Third>
-    tuple(const First& first, const Second& second, const Third& third)
-        : object(ref(PyTuple_New(3)))
-    {
-        set_item(0, first);
-        set_item(1, second);
-        set_item(2, third);
-    }
-    
-    template <class First, class Second, class Third, class Fourth>
-    tuple(const First& first, const Second& second, const Third& third, const Fourth& fourth)
-        : object(ref(PyTuple_New(4)))
-    {
-        set_item(0, first);
-        set_item(1, second);
-        set_item(2, third);
-        set_item(3, fourth);
-    }
-    
-    static PyTypeObject* type_obj();
-    static bool accepts(ref p);
-    std::size_t size() const;
-    ref operator[](std::size_t pos) const;
-
-    template <class T>
-    void set_item(std::size_t pos, const T& rhs)
-    {
-        this->set_item(pos, make_ref(rhs));
-    }
-    
-    void set_item(std::size_t pos, const ref& rhs);
-    
-    tuple slice(int low, int high) const;
-
-    friend tuple operator+(const tuple&, const tuple&);
-    tuple& operator+=(const tuple& rhs);
-};
-
-class list : public object
-{
-    struct proxy;
-    struct slice_proxy;
- public:
-    explicit list(ref p);
-    explicit list(std::size_t sz = 0);
-    static PyTypeObject* type_obj();
-    static bool accepts(ref p);
-    std::size_t size();
-    ref operator[](std::size_t pos) const;
-    proxy operator[](std::size_t pos);
-    ref get_item(std::size_t pos) const;
-
-    template <class T>
-    void set_item(std::size_t pos, const T& x)
-        { this->set_item(pos, make_ref(x)); }
-    void set_item(std::size_t pos, const ref& );
-    
-//    void set_item(std::size_t pos, const object& );
-
-    template <class T>
-    void insert(std::size_t index, const T& x)
-        { this->insert(index, make_ref(x)); }
-    void insert(std::size_t index, const ref& item);
-
-    template <class T>
-    void push_back(const T& item)
-        { this->push_back(make_ref(item)); }
-    void push_back(const ref& item);
-    
-    template <class T>
-    void append(const T& item)
-        { this->append(make_ref(item)); }
-    void append(const ref& item);
-    
-    list slice(int low, int high) const;
-    slice_proxy slice(int low, int high);
-    void sort();
-    void reverse();
-    tuple as_tuple() const;
-};
-
-class string
-    : public object, public boost::multipliable2<string, unsigned int>
-{
- public:
-    // Construct from an owned PyObject*.
-    // Precondition: p must point to a python string.
-    explicit string(ref p);
-    explicit string(const char* s);
-    string(const char* s, std::size_t length);
-    string(const string& rhs);
-
-    enum interned_t { interned };
-    string(const char* s, interned_t);
-    
-    // Get the type object for Strings
-    static PyTypeObject* type_obj();
-
-    // Return true if the given object is a python string
-    static bool accepts(ref o);
-
-    // Return the length of the string.
-    std::size_t size() const;
-
-    // Returns a null-terminated representation of the contents of string.
-    // The pointer refers to the internal buffer of string, not a copy.
-    // The data must not be modified in any way. It must not be de-allocated. 
-    const char* c_str() const;
-
-    string& operator*=(unsigned int repeat_count);
-    string& operator+=(const string& rhs);
-    friend string operator+(string x, string y);
-    string& operator+=(const char* rhs);
-    friend string operator+(string x, const char* y);
-    friend string operator+(const char* x, string y);
-
-    void intern();
-
-    friend string operator%(const string& format, const tuple& args);
-};
-
-class dictionary : public object
-{
- private:
-    struct proxy;
-    
- public:
-    explicit dictionary(ref p);
-    dictionary();
-    void clear();
-
-    static PyTypeObject* type_obj();
-    static bool accepts(ref p);
-    
- public:
-    template <class Key>
-    proxy operator[](const Key& key)
-        { return this->operator[](make_ref(key)); }
-    proxy operator[](ref key);
-    
-    template <class Key>
-    ref operator[](const Key& key) const
-        { return this->operator[](make_ref(key)); }
-    ref operator[](ref key) const;
-
-    template <class Key>
-    ref get_item(const Key& key) const
-        { return this->get_item(make_ref(key)); }
-    ref get_item(const ref& key) const;
-    
-    template <class Key, class Default>
-    ref get_item(const Key& key, const Default& default_) const
-        { return this->get_item(make_ref(key), make_ref(default_)); }
-    ref get_item(const ref& key, const ref& default_) const;
-    
-    template <class Key, class Value>
-    void set_item(const Key& key, const Value& value)
-        { this->set_item(make_ref(key), make_ref(value)); }
-    void set_item(const ref& key, const ref& value);
-
-    template <class Key>
-    void erase(const Key& key)
-        { this->erase(make_ref(key)); }
-    void erase(ref key);
-
-//    proxy operator[](const object& key);
-//    ref operator[](const object& key) const;
-
-//    ref get_item(const object& key, ref default_ = ref()) const;
-//    void set_item(const object& key, const ref& value);
-        
-//    void erase(const object& key);
-
-    list items() const;
-    list keys() const;
-    list values() const;
-
-    std::size_t size() const;
-    // TODO: iterator support
-};
-
-struct dictionary::proxy
-{
-    template <class T>
-    const ref& operator=(const T& rhs)
-        { return (*this) = make_ref(rhs); }
-    const ref& operator=(const ref& rhs);
-
-    operator ref() const;
- private:
-    friend class dictionary;
-    proxy(const ref& dict, const ref& key);
-
-    // This is needed to work around the very strange MSVC error report that the
-    // return type of the built-in operator= differs from that of the ones
-    // defined above. Couldn't hurt to make these un-assignable anyway, though.
-    const ref& operator=(const proxy&); // Not actually implemented
- private:
-    ref m_dict;
-    ref m_key;
-};
-
-struct list::proxy
-{
-    template <class T>
-    const ref& operator=(const T& rhs)
-        { return (*this) = make_ref(rhs); }
-    const ref& operator=(const ref& rhs);
-    
-    operator ref() const;
-    
- private:
-    friend class list;
-    proxy(const ref& list, std::size_t index);
-    
-    // This is needed to work around the very strange MSVC error report that the
-    // return type of the built-in operator= differs from that of the ones
-    // defined above. Couldn't hurt to make these un-assignable anyway, though.
-    const ref& operator=(const proxy&); // Not actually implemented
- private:
-    list m_list;
-    std::size_t m_index;
-};
-
-struct list::slice_proxy
-{
-    const list& operator=(const list& rhs);
-    operator ref() const;
-    operator list() const;
-    std::size_t size();
-    ref operator[](std::size_t pos) const;
- private:
-    friend class list;
-    slice_proxy(const ref& list, int low, int high);
- private:
-    ref m_list;
-    int m_low, m_high;
-};
-
-}} // namespace boost::python
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-PyObject* to_python(const boost::python::tuple&);
-boost::python::tuple from_python(PyObject* p, boost::python::type<boost::python::tuple>);
-
-inline boost::python::tuple from_python(PyObject* p, boost::python::type<const boost::python::tuple&>)
-{
-    return from_python(p, boost::python::type<boost::python::tuple>());
-}
-
-PyObject* to_python(const boost::python::list&);
-boost::python::list from_python(PyObject* p, boost::python::type<boost::python::list>);
-
-inline boost::python::list from_python(PyObject* p, boost::python::type<const boost::python::list&>)
-{
-    return from_python(p, boost::python::type<boost::python::list>());
-}
-
-PyObject* to_python(const boost::python::string&);
-boost::python::string from_python(PyObject* p, boost::python::type<boost::python::string>);
-
-inline boost::python::string from_python(PyObject* p, boost::python::type<const boost::python::string&>)
-{
-    return from_python(p, boost::python::type<boost::python::string>());
-}
-
-PyObject* to_python(const boost::python::dictionary&);
-boost::python::dictionary from_python(PyObject* p, boost::python::type<boost::python::dictionary>);
-
-inline boost::python::dictionary from_python(PyObject* p, boost::python::type<const boost::python::dictionary&>)
-{
-    return from_python(p, boost::python::type<boost::python::dictionary>());
-}
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-#endif // OBJECTS_DWA051100_H_

include/boost/python/operators.hpp

@@ -1,509 +0,0 @@
-#ifndef OPERATORS_UK112000_H_
-#define OPERATORS_UK112000_H_
-
-# include <boost/python/reference.hpp>
-# include <boost/python/detail/functions.hpp>
-
-// 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) ? defined(__SGI_STL_OWN_IOSTREAMS) : (!defined(__GNUC__) || __GNUC__ > 2)
-#  include <sstream>
-# else
-#  include <strstream>
-# endif
-
-namespace boost { namespace python {
-
-tuple standard_coerce(ref l, ref r);
-
-namespace detail {
-  
-  // helper class for automatic operand type detection
-  // during operator wrapping.
-  struct auto_operand {};
-}
-
-// Define operator ids that can be or'ed together
-// (boost::python::op_add | boost::python::op_sub | boost::python::op_mul).
-// This allows to wrap several operators in one line.
-enum operator_id
-{ 
-    op_add = 0x1, 
-    op_sub = 0x2, 
-    op_mul = 0x4, 
-    op_div = 0x8, 
-    op_mod = 0x10, 
-    op_divmod =0x20, 
-    op_pow = 0x40, 
-    op_lshift = 0x80, 
-    op_rshift = 0x100, 
-    op_and = 0x200, 
-    op_xor = 0x400, 
-    op_or = 0x800, 
-    op_neg = 0x1000, 
-    op_pos = 0x2000, 
-    op_abs = 0x4000, 
-    op_invert = 0x8000, 
-    op_int = 0x10000, 
-    op_long = 0x20000, 
-    op_float = 0x40000, 
-    op_str = 0x80000,
-    op_cmp = 0x100000 
-};
-
-// Wrap the operators given by "which". Usage:
-//   foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>());
-template <long which, class operand = boost::python::detail::auto_operand>
-struct operators {};
-
-// Wrap heterogeneous operators with given left operand type. Usage:
-//   foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>(),
-//                 boost::python::left_operand<int>());
-template <class T>
-struct left_operand {};
-
-// Wrap heterogeneous operators with given right operand type. Usage:
-//   foo_class.def(boost::python::operators<(boost::python::op_add | boost::python::op_sub)>(),
-//                 boost::python::right_operand<int>());
-template <class T>
-struct right_operand {};
-
-namespace detail
-{
-  template <class Specified>
-  struct operand_select
-  {
-      template <class wrapped_type>
-      struct wrapped
-      {
-          typedef Specified type;
-      };
-  };
-
-  template <>
-  struct operand_select<auto_operand>
-  {
-      template <class wrapped_type>
-      struct wrapped
-      {
-          typedef const wrapped_type& type;
-      };
-  };
-
-  template <long> struct define_operator;
-
-  // Base class which grants access to extension_class_base::add_method() to its derived classes
-  struct add_operator_base
-  {
-   protected:
-      static inline void add_method(extension_class_base* target, function* method, const char* name)
-          { target->add_method(method, name); }
-  };
-
-//
-// choose_op, choose_unary_op, and choose_rop
-//
-// These templates use "poor man's partial specialization" to generate the
-// appropriate add_method() call (if any) for a given operator and argument set.
-//
-//  Usage:
-//      choose_op<(which & op_add)>::template args<left_t,right_t>::add(ext_class);
-// 
-// (see extension_class<>::def_operators() for more examples).
-//
-  template <long op_selector>
-  struct choose_op
-  {
-      template <class Left, class Right = Left>
-      struct args : add_operator_base
-      {
-          static inline void add(extension_class_base* target)
-          {
-              typedef define_operator<op_selector> def_op;
-              add_method(target,
-                         new typename def_op::template operator_function<Left, Right>(),
-                         def_op::name());
-          }
-
-      };
-  };
-
-  // specialization for 0 has no effect
-  template <>
-  struct choose_op<0>
-  {
-      template <class Left, class Right = Left>
-      struct args
-      {
-          static inline void add(extension_class_base*)
-          {
-          }
-
-      };
-  };
-  
-  template <long op_selector>
-  struct choose_unary_op
-  {
-      template <class Operand>
-      struct args : add_operator_base
-      {
-          static inline void add(extension_class_base* target)
-          {
-              typedef define_operator<op_selector> def_op;
-              add_method(target,
-                         new typename def_op::template operator_function<Operand>(),
-                         def_op::name());
-          }
-
-      };
-  };
-  
-  // specialization for 0 has no effect
-  template <>
-  struct choose_unary_op<0>
-  {
-      template <class Operand>
-      struct args
-      {
-          static inline void add(extension_class_base*)
-          {
-          }
-
-      };
-  };
-  
-  template <long op_selector>
-  struct choose_rop
-  {
-      template <class Left, class Right = Left>
-      struct args : add_operator_base
-      {
-          static inline void add(extension_class_base* target)
-          {
-              typedef define_operator<op_selector> def_op;
-              add_method(target,
-                         new typename def_op::template roperator_function<Right, Left>(),
-                         def_op::rname());
-          }
-
-      };
-  };
-  
-  // specialization for 0 has no effect
-  template <>
-  struct choose_rop<0>
-  {
-      template <class Left, class Right = Left>
-      struct args
-      {
-          static inline void add(extension_class_base*)
-          {
-          }
-
-      };
-  };
-
-
-// Fully specialize define_operator for all operators defined in operator_id above.
-// Every specialization defines one function object for normal operator calls and one
-// for operator calls with operands reversed ("__r*__" function variants).
-// Specializations for most operators follow a standard pattern: execute the expression
-// that uses the operator in question. This standard pattern is realized by the following 
-// macros so that the actual specialization can be done by just calling a macro.
-#define PY_DEFINE_BINARY_OPERATORS(id, oper)                                            \
-  template <>                                                                           \
-  struct define_operator<op_##id>                                                       \
-  {                                                                                     \
-      template <class Left, class Right = Left>                                         \
-      struct operator_function : function                                               \
-      {                                                                                 \
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const        \
-          {                                                                             \
-              tuple args(ref(arguments, ref::increment_count));                                 \
-                                                                                        \
-              return BOOST_PYTHON_CONVERSION::to_python(                                          \
-                  BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>()) oper      \
-                  BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>()));        \
-          }                                                                             \
-                                                                                        \
-          const char* description() const                                               \
-              { return "__" #id "__"; }                                                 \
-      };                                                                                \
-                                                                                        \
-      template <class Right, class Left>                                                \
-      struct roperator_function : function                                              \
-      {                                                                                 \
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const        \
-          {                                                                             \
-              tuple args(ref(arguments, ref::increment_count));                                 \
-                                                                                        \
-              return BOOST_PYTHON_CONVERSION::to_python(                                          \
-                  BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>()) oper      \
-                  BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>()));        \
-          }                                                                             \
-                                                                                        \
-          const char* description() const                                               \
-              { return "__r" #id "__"; }                                                \
-                                                                                        \
-      };                                                                                \
-                                                                                        \
-      static const char * name() { return "__" #id "__"; }                              \
-      static const char * rname() { return "__r" #id "__"; }                            \
-  }
-
-#define PY_DEFINE_UNARY_OPERATORS(id, oper) \
-  template <>                                                                                   \
-  struct define_operator<op_##id>                                                               \
-  {                                                                                             \
-      template <class operand>                                                                  \
-      struct operator_function : function                                                       \
-      {                                                                                         \
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const                \
-          {                                                                                     \
-              tuple args(ref(arguments, ref::increment_count));                                         \
-                                                                                                \
-              return BOOST_PYTHON_CONVERSION::to_python(                                                  \
-                  oper(BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<operand>())));        \
-          }                                                                                     \
-                                                                                                \
-          const char* description() const                                                       \
-              { return "__" #id "__"; }                                                         \
-      };                                                                                        \
-                                                                                                \
-      static const char * name() { return "__" #id "__"; }                                      \
-  }
-
-  PY_DEFINE_BINARY_OPERATORS(add, +);
-  PY_DEFINE_BINARY_OPERATORS(sub, -);
-  PY_DEFINE_BINARY_OPERATORS(mul, *);
-  PY_DEFINE_BINARY_OPERATORS(div, /);
-  PY_DEFINE_BINARY_OPERATORS(mod, %);
-  PY_DEFINE_BINARY_OPERATORS(lshift, <<);
-  PY_DEFINE_BINARY_OPERATORS(rshift, >>);
-  PY_DEFINE_BINARY_OPERATORS(and, &);
-  PY_DEFINE_BINARY_OPERATORS(xor, ^);
-  PY_DEFINE_BINARY_OPERATORS(or, |);
-
-  PY_DEFINE_UNARY_OPERATORS(neg, -);
-  PY_DEFINE_UNARY_OPERATORS(pos, +);
-  PY_DEFINE_UNARY_OPERATORS(abs, abs);
-  PY_DEFINE_UNARY_OPERATORS(invert, ~);
-  PY_DEFINE_UNARY_OPERATORS(int, long);
-  PY_DEFINE_UNARY_OPERATORS(long, PyLong_FromLong);
-  PY_DEFINE_UNARY_OPERATORS(float, double);
-
-#undef PY_DEFINE_BINARY_OPERATORS
-#undef PY_DEFINE_UNARY_OPERATORS
-
-// Some operators need special treatment, e.g. because there is no corresponding 
-// expression in C++. These are specialized manually.
-
-// pow(): Manual specialization needed because an error message is required if this 
-// function is called with three arguments. The "power modulo" operator is not  
-// supported by define_operator, but can be wrapped manually (see special.html).
-  template <>
-  struct define_operator<op_pow>
-  {
-      template <class Left, class Right = Left>
-      struct operator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-
-              if (args.size() == 3 && args[2]->ob_type != Py_None->ob_type)
-              {
-                  PyErr_SetString(PyExc_TypeError, "expected 2 arguments, got 3");
-                  throw argument_error();
-              }
-
-              return BOOST_PYTHON_CONVERSION::to_python(
-                  pow(BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>()),
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>()))); 
-          }
-
-          const char* description() const
-              { return "__pow__"; }
-
-      };
-
-      template <class Right, class Left>
-      struct roperator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-
-              if (args.size() == 3 && args[2]->ob_type != Py_None->ob_type)
-              {
-                  PyErr_SetString(PyExc_TypeError, "bad operand type(s) for pow()");
-                  throw argument_error();
-              }
-
-              return BOOST_PYTHON_CONVERSION::to_python(
-                  pow(BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>()),
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>()))); 
-          }
-
-          const char* description() const
-              { return "__rpow__"; }
-
-      };
-
-      static const char * name() { return "__pow__"; }
-      static const char * rname() { return "__rpow__"; }
-  };
-
-// divmod(): Manual specialization needed because we must actually call two operators and
-// return a tuple containing both results
-  template <>
-  struct define_operator<op_divmod>
-  {
-      template <class Left, class Right = Left>
-      struct operator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-              PyObject * res = PyTuple_New(2);
-
-              PyTuple_SET_ITEM(res, 0,
-                BOOST_PYTHON_CONVERSION::to_python(
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>()) /
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>()))); 
-              PyTuple_SET_ITEM(res, 1,
-                BOOST_PYTHON_CONVERSION::to_python(
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>()) %
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>())));
-
-              return res; 
-          }
-
-          const char* description() const
-              { return "__divmod__"; }
-
-      };
-
-      template <class Right, class Left>
-      struct roperator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-              PyObject * res = PyTuple_New(2);
-
-              PyTuple_SET_ITEM(res, 0,
-                BOOST_PYTHON_CONVERSION::to_python(
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>()) /
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>()))); 
-              PyTuple_SET_ITEM(res, 1,
-                BOOST_PYTHON_CONVERSION::to_python(
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>()) %
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>())));
-
-              return res; 
-          }
-
-          const char* description() const
-              { return "__rdivmod__"; }
-
-      };
-
-      static const char * name() { return "__divmod__"; }
-      static const char * rname() { return "__rdivmod__"; }
-  };
-
-// cmp(): Manual specialization needed because there is no three-way compare in C++.
-// It is implemented by two one-way comparisons with operators reversed in the second.
-  template <>
-  struct define_operator<op_cmp>
-  {
-      template <class Left, class Right = Left>
-      struct operator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-
-              return BOOST_PYTHON_CONVERSION::to_python(
-                  (BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>()) <
-                   BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>())) ?
-                       - 1 :
-                       (BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Right>()) <
-                       BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Left>())) ?
-                           1 :
-                           0) ; 
-          }
-
-          const char* description() const
-              { return "__cmp__"; }
-
-      };
-
-      template <class Right, class Left>
-      struct roperator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject* /* keywords */) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-
-              return BOOST_PYTHON_CONVERSION::to_python(
-                  (BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>()) <
-                   BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>())) ?
-                       - 1 :
-                       (BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<Right>()) <
-                       BOOST_PYTHON_CONVERSION::from_python(args[1].get(), boost::python::type<Left>())) ?
-                           1 :
-                           0) ; 
-          }
-
-          const char* description() const
-              { return "__rcmp__"; }
-
-      };
-
-      static const char * name() { return "__cmp__"; }
-      static const char * rname() { return "__rcmp__"; }
-  };
-
-// str(): Manual specialization needed because the string conversion does not follow
-// the standard pattern relized by the macros.
-  template <>
-  struct define_operator<op_str>
-  {
-      template <class operand>
-      struct operator_function : function
-      {
-          PyObject* do_call(PyObject* arguments, PyObject*) const
-          { 
-              tuple args(ref(arguments, ref::increment_count));
-
-// When STLport is used with native streams, _STL::ostringstream().str() is not
-// _STL::string, but std::string.
-#if defined(__SGI_STL_PORT) ? defined(__SGI_STL_OWN_IOSTREAMS) : (!defined(__GNUC__) || __GNUC__ > 2)
-              std::ostringstream s;
-              s << BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<operand>());
-              return BOOST_PYTHON_CONVERSION::to_python(s.str()); 
-#else
-              std::ostrstream s;
-              s << BOOST_PYTHON_CONVERSION::from_python(args[0].get(), boost::python::type<operand>()) << char();
-              return BOOST_PYTHON_CONVERSION::to_python(const_cast<char const *>(s.str())); 
-#endif
-          }
-
-          const char* description() const
-              { return "__str__"; }
-
-      };
-
-      static const char * name() { return "__str__"; }
-  };
-
-
-} // namespace detail
-
-}} // namespace boost::python
-
-#endif /* OPERATORS_UK112000_H_ */

include/boost/python/reference.hpp

@@ -1,173 +0,0 @@
-//  (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.
-
-#ifndef PYPTR_DWA050400_H_
-# define PYPTR_DWA050400_H_
-
-# include <boost/python/detail/config.hpp>
-# include <boost/operators.hpp>
-# include <boost/python/detail/wrap_python.hpp>
-# include <boost/python/detail/cast.hpp>
-# include <cassert>
-# include <boost/python/detail/signatures.hpp>
-# include <boost/python/errors.hpp>
-# include <boost/python/conversions.hpp>
-
-BOOST_PYTHON_BEGIN_CONVERSION_NAMESPACE
-
-template <class T, class Value, class Base>
-struct py_ptr_conversions : Base
-{
-    inline friend T from_python(PyObject* x, boost::python::type<const T&>)
-        { return T(boost::python::downcast<Value>(x).get(), T::increment_count); }
-
-    inline friend T from_python(PyObject* x, boost::python::type<T>)
-        { return T(boost::python::downcast<Value>(x).get(), T::increment_count); }
-    
-    inline friend PyObject* to_python(T x)
-        { return boost::python::as_object(x.release()); }
-    
-};
-
-BOOST_PYTHON_END_CONVERSION_NAMESPACE
-
-namespace boost { namespace python {
-
-BOOST_PYTHON_IMPORT_CONVERSION(py_ptr_conversions);
-
-template <class T>
-class reference
-	: public py_ptr_conversions<reference<T>, T,
-       boost::dereferenceable<reference<T>, T*> > // supplies op->
-{
-public:
-    typedef T value_type;
-    
-	reference(const reference& rhs)
-		: m_p(rhs.m_p)
-	{
-		Py_XINCREF(object());
-	}
-
-#if !defined(BOOST_MSVC6_OR_EARLIER)
-	template <class T2>
-	reference(const reference<T2>& rhs)
-		: m_p(rhs.object())
-	{
-		Py_XINCREF(object());
-	}
-#endif
-
-	reference() : m_p(0) {}
-    
-    // These are two ways of spelling the same thing, that we need to increment
-    // the reference count on the pointer when we're initialized.
-	enum increment_count_t { increment_count };
-
-    enum allow_null { null_ok };
-    
-    template <class T2>
-    explicit reference(T2* x)
-        : m_p(expect_non_null(x)) {}
-
-    template <class T2>
-    reference(T2* x, increment_count_t)
-        : m_p(expect_non_null(x)) { Py_INCREF(object()); }
-	
-    template <class T2>
-    reference(T2* x, allow_null)
-        : m_p(x) {}
-
-    template <class T2>
-    reference(T2* x, allow_null, increment_count_t)
-        : m_p(x) { Py_XINCREF(object()); }
-	
-    template <class T2>
-    reference(T2* x, increment_count_t, allow_null)
-        : m_p(x) { Py_XINCREF(object()); }
-	
-#if !defined(BOOST_MSVC6_OR_EARLIER)
-	template <class T2>
-	reference& operator=(const reference<T2>& rhs)
-	{
-		Py_XDECREF(object());
-		m_p = rhs.m_p;
-		Py_XINCREF(object());
-		return *this;
-	}
-#endif
-
-	reference& operator=(const reference& rhs)
-	{
-		Py_XINCREF(static_cast<PyObject*>(rhs.m_p));
-		Py_XDECREF(object());
-		m_p = rhs.m_p;
-		return *this;
-	}
-    
-	~reference()
-	{
-		Py_XDECREF(m_p);
-	}
-	
-	T& operator*() const { return *m_p; }
-    
-	T* get() const { return m_p; }
-
-	T* release()
-	{
-		T* p = m_p;
-		m_p = 0;
-		return p;
-	}
-
-    void reset()
-        { Py_XDECREF(m_p); m_p = 0; }
-    
-    template <class T2>
-    void reset(T2* x)
-        { Py_XDECREF(m_p); m_p = expect_non_null(x);}
-
-    template <class T2>
-    void reset(T2* x, increment_count_t)
-        { Py_XDECREF(m_p); m_p = expect_non_null(x); Py_INCREF(object()); }
-	
-    template <class T2>
-    void reset(T2* x, allow_null)
-        { Py_XDECREF(m_p); m_p = x;}
-
-    template <class T2>
-    void reset(T2* x, allow_null, increment_count_t)
-        { Py_XDECREF(m_p); m_p = x; Py_XINCREF(object()); }
-	
-    template <class T2>
-    void reset(T2* x, increment_count_t, allow_null)
-        { Py_XDECREF(m_p); m_p = x; Py_XINCREF(object()); }
-	
-#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-private:
-    template<typename Y> friend class shared_ptr;
-#endif
-
-    inline PyObject* object() const
-        { return as_object(m_p); }
-
-	T* m_p;
-};
-
-typedef reference<PyObject> ref;
-
-template <class T>
-ref make_ref(const T& x)
-{
-    return ref(to_python(x));
-}
-
-}} // namespace boost::python
-
-#endif // PYPTR_DWA050400_H_

pyste/NEWS

@@ -0,0 +1,154 @@
+20 September 2003
+Added return_by_value in the list of policies supported. Thanks to Niall
+Douglas for the remainder.
+
+19 September 2003
+Better support for unnamed enums, plus they are by default exported to the
+parent's namespace. Normal enums can have the same behaviour using the function
+export_values on the Enum object. Feature requested by Niall Douglas.
+
+10 September 2003
+A new variable is accessible in the Pyste files: INTERFACE_FILE contains the 
+full path of the pyste file.
+
+4 September 2003
+Now it is possible to override protected and private pure virtual functions
+in Python, as requested by Roman Yakovenko.
+
+23 August 2003
+Fixed bug where some Imports where not writing their include files.  
+Now whenever the declarations change, the cache files are rebuilt
+automatically.
+
+19 August 2003
+Fixed a bug related to the generation of the bases<> template.
+
+17 August 2003
+Added support for insertion of user code in the generated code.
+
+16 August 2003
+Applied a patch by Gottfried Ganssauge that adds exception specifiers to 
+wrapper functions and pointer declarations. Thanks a lot Gottfried!!
+
+Applied a patch by Prabhu Ramachandran that fixes ae problem with the 
+pure virtual method generation. Thanks again Prabhu!
+
+10 August 2003
+Support for incremental generation of the code has been added. This changes
+how --multiple works; documentation of this new feature will follow. Thanks
+to Prabhu Ramachandran, that saw the need for this feature and discussed a
+solution. 
+
+Automatically convert \ to / in Windows systems before passing the paths to
+gccxml.
+
+Fixed a bug reported by Prabhu Ramachandran, where in some classes the virtual
+methods were being definied incorrectly. Thanks a lot Prabhu!
+
+7 July 2003
+Applied 2 patches by Prabhu Ramachandran: a fix in the new --multiple method,
+and two new functions "hold_with_shared_ptr" and its counterpart for auto_ptr.
+Thanks a lot Prabhu!
+
+Fixed a bug where the macro BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID was being
+called multiple times for the same type.
+Thanks to Gottfried Ganßauge for reporting this!
+
+Fixed bug where using AllFromHeader didn't use bases<> when exporting 
+hierarchies.
+
+Fixed the staticmethod bug.
+
+5 July 2003
+Changed how --multiple works: now it generates one cpp file for each pyste
+file, makeing easier to integrate Pyste with build systems.
+
+4 July 2003
+Applied patch that solved a bug in ClassExporter and added a distutils install
+script (install/setup.py), both contributed by Prabhu Ramachandran.
+Thanks Prabhu!
+
+2 July 2003
+Jim Wilson found a bug where types like "char**" were being interpreted as 
+"char*". Thanks Jim!
+
+16 June 2003
+Thanks to discussions with David Abrahams and Roman Sulzhyk, some behaviours
+have changed:
+
+- If you export a derived class without exporting its base classes, the derived
+  class will explicitly export the bases's methods and attributes. Before, if
+  you were interested in the bases's methods, you had to export the base
+  classes too.
+
+- Added a new function, no_override. When a member function is specified as
+  "no_override", no virtual wrappers are generated for it, improving
+  performance and letting the code more clean.
+
+- There was a bug in which the policy of virtual member functions was being
+  ignored (patch by Roman Sulzhyk). 
+  
+Thanks again to Roman Sulzhyk for the patches and discussion in the c++-sig.
+
+4 June 2003
+Major improvements in memory usage.
+
+3 June 2003
+Appliced a patch from Giulio Eulisse that allows unnamed enumerations to be
+exported with an AllFromHeader construct. Thanks a lot Giulio!
+
+2 June 2003
+Added a new construct, add_method. See documentation.
+
+23 May 2003
+Support for global variables added.
+Various bug fixes.
+
+08 May 2003
+Fixed bug where in a certain cases the GCCXMLParser would end up with multiple
+declarations of the same class
+
+22 Apr 2003
+- Now shows a warning when the user tries to export a forward-declared class.
+  Forward-declared classes are ignored by the AllFromHeader construct.
+- Fixed a bug where classes, functions and enums where being exported, even if
+  excluded from a AllFromHeader construct.
+
+16 Apr 2003
+Added a more generic (but ugly) code to declare the smart pointer converters.
+
+07 Apr 2003
+- Removed the warnings about forward declarations: it was not accurate enough.
+  Another strategy must be thought of.
+- Fixed bug in the --multiple mode, where the order of the class instantiations
+  could end up wrong.
+- Lots of fixes in the documentation, pointed out by Dirk Gerrits. Thanks Dirk!
+- Fixed support for the return_opaque_pointer policy (the support macro was not
+  being declared).
+
+
+06 Apr 2003
+Support for the improved static data members support of Boost.Python.
+
+05 Apr 2003
+New option for generating the bindings: --multiple.
+
+02 Apr 2003
+Forward declarations are now detected and a warning is generated.
+
+24 Mar 2003
+Default policy for functions/methods that return const T& is now
+return_value_policy<copy_const_reference>().
+
+22 Mar 2003
+Exporting virtual methods of the base classes in the derived classes too.
+
+21 Mar 2003
+Added manual support for boost::shared_ptr and std::auto_ptr (see doc).
+
+19 Mar 2003 
+Added support for int, double, float and long operators acting as expected in
+python.
+
+14 Mar 2003 
+Fixed bug: Wrappers for protected and virtual methods were not being generated.

pyste/README

@@ -0,0 +1,31 @@
+Pyste - Python Semi-Automatic Exporter
+======================================
+
+Pyste is a Boost.Python code generator. The user specifies the classes and
+functions to be exported using a simple interface file, which following the
+Boost.Python's philosophy, is simple Python code. Pyste then uses GCCXML to
+parse all the headers and extract the necessary information to automatically
+generate C++ code.
+
+The documentation can be found in the file index.html accompaning this README.
+
+Enjoy!
+Bruno da Silva de Oliveira (nicodemus@globalite.com.br)
+
+Thanks
+======
+
+- David Abrahams, creator of Boost.Python, for tips on the syntax of the interface
+  file and support.
+- Marcelo Camelo, for design tips, support and inspiration for this project.
+  Also, the name was his idea. 8)
+- Brad King, creator of the excellent GCCXML (http://www.gccxml.org)
+- Fredrik Lundh, creator of the elementtree library (http://effbot.org)
+
+Bugs
+====
+
+Pyste is a young tool, so please help it to get better! Send bug reports to
+nicodemus@globalite.com.br, accompaining the stack trace in case of exceptions.
+If possible, run pyste with --debug, and send the resulting xmls too (pyste
+will output a xml file with the same of each header it parsed).

pyste/TODO

@@ -0,0 +1,12 @@
+- Make Pyste accept already-generated xml files
+
+- throw() declaration in virtual wrapper's member functions
+
+- Allow protected methods to be overriden in Python
+
+- Expose programmability to the Pyste files (listing members of a class, for
+  instance)
+
+- Virtual operators  
+
+- args() support

pyste/dist/.cvsignore

@@ -0,0 +1,2 @@
+*.zip
+*.pyc

pyste/dist/create_build.py

@@ -0,0 +1,51 @@
+import os
+import sys
+import shutil
+import fnmatch
+from zipfile import ZipFile, ZIP_DEFLATED
+
+def findfiles(directory, mask):
+    def visit(files, dir, names):
+        for name in names:
+            if fnmatch.fnmatch(name, mask):
+                files.append(os.path.join(dir, name))
+    files = []
+    os.path.walk(directory, visit, files)
+    return files
+                
+        
+def main():
+    # test if PyXML is installed
+    try:
+        import _xmlplus.parsers.expat
+        pyxml = '--includes _xmlplus.parsers.expat'
+    except ImportError:
+        pyxml = ''
+    # create exe
+    status = os.system('python setup.py py2exe %s >& build.log' % pyxml)
+    if status != 0:
+        raise RuntimeError, 'Error creating EXE'
+
+    # create distribution
+    import pyste
+    version = pyste.__VERSION__
+    zip = ZipFile('pyste-%s.zip' % version, 'w', ZIP_DEFLATED)    
+    # include the base files
+    dist_dir = 'dist/pyste'
+    for basefile in os.listdir(dist_dir):
+        zip.write(os.path.join(dist_dir, basefile), os.path.join('pyste', basefile))
+    # include documentation
+    for doc_file in findfiles('../doc', '*.*'):
+        dest_name = os.path.join('pyste/doc', doc_file[3:])
+        zip.write(doc_file, dest_name)
+    zip.write('../index.html', 'pyste/doc/index.html')
+    zip.close()
+    # cleanup
+    os.remove('build.log')
+    shutil.rmtree('build')
+    shutil.rmtree('dist')
+    
+
+if __name__ == '__main__':
+    sys.path.append('../src')
+    main()

pyste/dist/setup.py

@@ -0,0 +1,6 @@
+from distutils.core import setup
+import py2exe
+import sys
+
+sys.path.append('../src')
+setup(name='pyste', scripts=['../src/pyste.py'])

pyste/doc/adding_new_methods.html

@@ -0,0 +1,79 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Adding New Methods</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="global_variables.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Adding New Methods</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="global_variables.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><img src="theme/r_arr_disabled.gif" border="0"></td>
+   </tr>
+</table>
+<p>
+Suppose that you want to add a function to a class, turning it into a member
+function:</p>
+<code><pre>
+    <span class=keyword>struct </span><span class=identifier>World
+    </span><span class=special>{
+        </span><span class=keyword>void </span><span class=identifier>set</span><span class=special>(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>msg</span><span class=special>) { </span><span class=keyword>this</span><span class=special>-&gt;</span><span class=identifier>msg </span><span class=special>= </span><span class=identifier>msg</span><span class=special>; }
+        </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>msg</span><span class=special>;
+    };
+
+    </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>greet</span><span class=special>(</span><span class=identifier>World</span><span class=special>&amp; </span><span class=identifier>w</span><span class=special>)
+    {
+        </span><span class=keyword>return </span><span class=identifier>w</span><span class=special>.</span><span class=identifier>msg</span><span class=special>;
+    }
+</span></pre></code>
+<p>
+Here, we want to make <tt>greet</tt> work as a member function of the class <tt>World</tt>. We do
+that using the <tt>add_method</tt> construct:</p>
+<code><pre>
+    <span class=identifier>W </span><span class=special>= </span><span class=identifier>Class</span><span class=special>(</span><span class=string>&quot;World&quot;</span><span class=special>, </span><span class=string>&quot;hello.h&quot;</span><span class=special>)
+    </span><span class=identifier>add_method</span><span class=special>(</span><span class=identifier>W</span><span class=special>, </span><span class=string>&quot;greet&quot;</span><span class=special>)
+</span></pre></code>
+<p>
+Notice also that then you can rename it, set its policy, just like a regular
+member function:</p>
+<code><pre>
+    <span class=identifier>rename</span><span class=special>(</span><span class=identifier>W</span><span class=special>.</span><span class=identifier>greet</span><span class=special>, </span><span class=literal>'Greet'</span><span class=special>)
+</span></pre></code>
+<p>
+Now from Python:</p>
+<code><pre>
+    <span class=special>&gt;&gt;&gt; </span><span class=identifier>import </span><span class=identifier>hello
+    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>w </span><span class=special>= </span><span class=identifier>hello</span><span class=special>.</span><span class=identifier>World</span><span class=special>()
+    &gt;&gt;&gt; </span><span class=identifier>w</span><span class=special>.</span><span class=identifier>set</span><span class=special>(</span><span class=literal>'Ni'</span><span class=special>)
+    &gt;&gt;&gt; </span><span class=identifier>w</span><span class=special>.</span><span class=identifier>greet</span><span class=special>()
+    </span><span class=literal>'Ni'
+    </span><span class=special>&gt;&gt;&gt; </span><span class=identifier>print </span><span class=literal>'Oh no! The knights who say Ni!'
+    </span><span class=identifier>Oh </span><span class=identifier>no</span><span class=special>! </span><span class=identifier>The </span><span class=identifier>knights </span><span class=identifier>who </span><span class=identifier>say </span><span class=identifier>Ni</span><span class=special>!
+</span></pre></code>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="global_variables.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><img src="theme/r_arr_disabled.gif" border="0"></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2003 Bruno da Silva de Oliveira<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

pyste/doc/exporting_an_entire_header.html

@@ -0,0 +1,77 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Exporting An Entire Header</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="wrappers.html">
+<link rel="next" href="smart_pointers.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Exporting An Entire Header</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="wrappers.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="smart_pointers.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<p>
+Pyste also supports a mechanism to export all declarations found in a header
+file. Suppose again our file, <tt>hello.h</tt>:</p>
+<code><pre>
+    <span class=keyword>struct </span><span class=identifier>World
+    </span><span class=special>{
+        </span><span class=identifier>World</span><span class=special>(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>msg</span><span class=special>): </span><span class=identifier>msg</span><span class=special>(</span><span class=identifier>msg</span><span class=special>) {} 
+        </span><span class=keyword>void </span><span class=identifier>set</span><span class=special>(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>msg</span><span class=special>) { </span><span class=keyword>this</span><span class=special>-&gt;</span><span class=identifier>msg </span><span class=special>= </span><span class=identifier>msg</span><span class=special>; }
+        </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>greet</span><span class=special>() { </span><span class=keyword>return </span><span class=identifier>msg</span><span class=special>; }
+        </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>msg</span><span class=special>;
+    };
+
+    </span><span class=keyword>enum </span><span class=identifier>choice </span><span class=special>{ </span><span class=identifier>red</span><span class=special>, </span><span class=identifier>blue </span><span class=special>};
+    
+    </span><span class=keyword>void </span><span class=identifier>show</span><span class=special>(</span><span class=identifier>choice </span><span class=identifier>c</span><span class=special>) { </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=string>&quot;value: &quot; </span><span class=special>&lt;&lt; (</span><span class=keyword>int</span><span class=special>)</span><span class=identifier>c </span><span class=special>&lt;&lt; </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>endl</span><span class=special>; } 
+</span></pre></code>
+<p>
+You can just use the <tt>AllFromHeader</tt> construct:</p>
+<code><pre>
+    <span class=identifier>hello </span><span class=special>= </span><span class=identifier>AllFromHeader</span><span class=special>(</span><span class=string>&quot;hello.h&quot;</span><span class=special>)
+</span></pre></code>
+<p>
+this will export all the declarations found in <tt>hello.h</tt>, which is equivalent
+to write:</p>
+<code><pre>
+    <span class=identifier>Class</span><span class=special>(</span><span class=string>&quot;World&quot;</span><span class=special>, </span><span class=string>&quot;hello.h&quot;</span><span class=special>)
+    </span><span class=identifier>Enum</span><span class=special>(</span><span class=string>&quot;choice&quot;</span><span class=special>, </span><span class=string>&quot;hello.h&quot;</span><span class=special>)
+    </span><span class=identifier>Function</span><span class=special>(</span><span class=string>&quot;show&quot;</span><span class=special>, </span><span class=string>&quot;hello.h&quot;</span><span class=special>)
+</span></pre></code>
+<p>
+Note that you can still use the functions <tt>rename</tt>, <tt>set_policy</tt>, <tt>exclude</tt>, etc. Just access
+the members of the header object like this:</p>
+<code><pre>
+    <span class=identifier>rename</span><span class=special>(</span><span class=identifier>hello</span><span class=special>.</span><span class=identifier>World</span><span class=special>.</span><span class=identifier>greet</span><span class=special>, </span><span class=string>&quot;Greet&quot;</span><span class=special>)
+    </span><span class=identifier>exclude</span><span class=special>(</span><span class=identifier>hello</span><span class=special>.</span><span class=identifier>World</span><span class=special>.</span><span class=identifier>set</span><span class=special>, </span><span class=string>&quot;Set&quot;</span><span class=special>)
+</span></pre></code>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="wrappers.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="smart_pointers.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2003 Bruno da Silva de Oliveira<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

pyste/doc/global_variables.html

@@ -0,0 +1,50 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Global Variables</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="smart_pointers.html">
+<link rel="next" href="adding_new_methods.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Global Variables</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="smart_pointers.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="adding_new_methods.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<p>
+To export global variables, use the <tt>Var</tt> construct:</p>
+<code><pre>
+    <span class=identifier>Var</span><span class=special>(</span><span class=string>&quot;myglobal&quot;</span><span class=special>, </span><span class=string>&quot;foo.h&quot;</span><span class=special>)
+</span></pre></code>
+<p>
+Beware of non-const global variables: changes in Python won't reflect in C++!
+If you really must change them in Python, you will have to write some accessor
+functions, and export those.</p>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="smart_pointers.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="adding_new_methods.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2003 Bruno da Silva de Oliveira<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

pyste/doc/introduction.html

@@ -0,0 +1,74 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Introduction</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="next" href="running_pyste.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Introduction</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><img src="theme/l_arr_disabled.gif" border="0"></td>
+    <td width="20"><a href="running_pyste.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<a name="what_is_pyste_"></a><h2>What is Pyste?</h2><p>
+Pyste is a <a href="../../index.html">
+Boost.Python</a> code generator. The user specifies the classes and
+functions to be exported using a simple <i>interface file</i>, which following the
+<a href="../../index.html">
+Boost.Python</a>'s philosophy, is simple Python code. Pyste then uses <a href="http://www.gccxml.org">
+GCCXML</a> to
+parse all the headers and extract the necessary information to automatically
+generate C++ code.</p>
+<a name="example"></a><h2>Example</h2><p>
+Let's borrow the class <tt>World</tt> from the <a href="../../doc/tutorial/doc/exposing_classes.html">
+tutorial</a>: </p>
+<code><pre>
+    <span class=keyword>struct </span><span class=identifier>World
+    </span><span class=special>{
+        </span><span class=keyword>void </span><span class=identifier>set</span><span class=special>(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>msg</span><span class=special>) { </span><span class=keyword>this</span><span class=special>-&gt;</span><span class=identifier>msg </span><span class=special>= </span><span class=identifier>msg</span><span class=special>; }
+        </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>greet</span><span class=special>() { </span><span class=keyword>return </span><span class=identifier>msg</span><span class=special>; }
+        </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>msg</span><span class=special>;
+    };
+</span></pre></code>
+<p>
+Here's the interface file for it, named <tt>world.pyste</tt>:</p>
+<code><pre>
+    <span class=identifier>Class</span><span class=special>(</span><span class=string>&quot;World&quot;</span><span class=special>, </span><span class=string>&quot;world.h&quot;</span><span class=special>)
+</span></pre></code>
+<p>
+and that's it!</p>
+<p>
+The next step is invoke Pyste in the command-line:</p>
+<code><pre>python pyste.py --module=hello world.pyste</pre></code><p>
+this will create a file &quot;<tt>hello.cpp</tt>&quot; in the directory where the command was
+run. </p>
+<p>
+Pyste supports the following features:</p>
+<ul><li>Functions</li><li>Classes</li><li>Class Templates</li><li>Virtual Methods</li><li>Overloading</li><li>Attributes </li><li>Enums (both &quot;free&quot; enums and class enums)</li><li>Nested Classes</li><li>Support for <tt>boost::shared_ptr</tt> and <tt>std::auto_ptr</tt></li><li>Global Variables</li></ul><table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><img src="theme/l_arr_disabled.gif" border="0"></td>
+    <td width="20"><a href="running_pyste.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2003 Bruno da Silva de Oliveira<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

pyste/doc/policies.html

@@ -0,0 +1,91 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Policies</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="renaming_and_excluding.html">
+<link rel="next" href="templates.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Policies</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="renaming_and_excluding.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="templates.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<p>
+Even thought Pyste can identify various elements in the C++ code, like virtual
+member functions, attributes, and so on, one thing that it can't do is to
+guess the semantics of functions that return pointers or references. In this
+case, the user must manually specify the policy. Policies are explained in the
+<a href="../../doc/tutorial/doc/call_policies.html">
+tutorial</a>.</p>
+<p>
+The policies in Pyste are named exactly as in <a href="../../index.html">
+Boost.Python</a>, only the syntax is
+slightly different. For instance, this policy:</p>
+<code><pre>
+    <span class=identifier>return_internal_reference</span><span class=special>&lt;</span><span class=number>1</span><span class=special>, </span><span class=identifier>with_custodian_and_ward</span><span class=special>&lt;</span><span class=number>1</span><span class=special>, </span><span class=number>2</span><span class=special>&gt; &gt;()
+</span></pre></code>
+<p>
+becomes in Pyste:    </p>
+<code><pre>
+    <span class=identifier>return_internal_reference</span><span class=special>(</span><span class=number>1</span><span class=special>, </span><span class=identifier>with_custodian_and_ward</span><span class=special>(</span><span class=number>1</span><span class=special>, </span><span class=number>2</span><span class=special>))
+</span></pre></code>
+<p>
+The user can specify policies for functions and virtual member functions with
+the <tt>set_policy</tt> function:</p>
+<code><pre>
+    <span class=identifier>set_policy</span><span class=special>(</span><span class=identifier>f</span><span class=special>, </span><span class=identifier>return_internal_reference</span><span class=special>())
+    </span><span class=identifier>set_policy</span><span class=special>(</span><span class=identifier>C</span><span class=special>.</span><span class=identifier>foo</span><span class=special>, </span><span class=identifier>return_value_policy</span><span class=special>(</span><span class=identifier>manage_new_object</span><span class=special>))
+</span></pre></code>
+<table width="80%" border="0" align="center">
+  <tr>
+    <td class="note_box">
+
+<img src="theme/note.gif"></img> <b>What if a function or member function needs a policy and
+the user doesn't set one?</b><br><br> If a function needs a policy and one
+was not set, Pyste will issue a error.  The user should then go in the
+interface file and set the policy for it, otherwise the generated cpp won't
+compile.
+    </td>
+  </tr>
+</table>
+<table width="80%" border="0" align="center">
+  <tr>
+    <td class="note_box">
+
+<img src="theme/note.gif"></img> 
+Note that, for functions that return <tt>const T&amp;</tt>, the policy
+<tt>return_value_policy&lt;copy_const_reference&gt;()</tt> wil be used by default, because
+that's normally what you want. You can change it to something else if you need
+to, though.
+    </td>
+  </tr>
+</table>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="renaming_and_excluding.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="templates.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2003 Bruno da Silva de Oliveira<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

pyste/doc/pyste.txt

@@ -0,0 +1,541 @@
+[doc Pyste Documentation]
+
+[def GCCXML             [@http://www.gccxml.org GCCXML]]
+[def Boost.Python       [@../../index.html Boost.Python]]
+
+[page Introduction]
+
+[h2 What is Pyste?]
+
+Pyste is a Boost.Python code generator. The user specifies the classes and
+functions to be exported using a simple ['interface file], which following the
+Boost.Python's philosophy, is simple Python code. Pyste then uses GCCXML to
+parse all the headers and extract the necessary information to automatically
+generate C++ code.
+
+[h2 Example]
+
+Let's borrow the class [^World] from the [@../../doc/tutorial/doc/exposing_classes.html tutorial]: 
+
+    struct World
+    {
+        void set(std::string msg) { this->msg = msg; }
+        std::string greet() { return msg; }
+        std::string msg;
+    };
+
+Here's the interface file for it, named [^world.pyste]:
+
+    Class("World", "world.h")
+
+and that's it!
+
+The next step is invoke Pyste in the command-line:
+
+[pre python pyste.py --module=hello world.pyste]
+
+this will create a file "[^hello.cpp]" in the directory where the command was
+run. 
+
+Pyste supports the following features:
+
+* Functions
+* Classes
+* Class Templates
+* Virtual Methods
+* Overloading
+* Attributes 
+* Enums (both "free" enums and class enums)
+* Nested Classes
+* Support for [^boost::shared_ptr] and [^std::auto_ptr]
+* Global Variables
+
+[page Running Pyste]
+
+To run Pyste, you will need:
+
+* Python 2.2, available at [@http://www.python.org python's website].
+* The great [@http://effbot.org elementtree] library, from Fredrik Lundh.
+* The excellent GCCXML, from Brad King.
+
+Installation for the tools is available in their respective webpages.
+
+[blurb 
+[$theme/note.gif] GCCXML must be accessible in the PATH environment variable, so
+that Pyste can call it. How to do this varies from platform to platform.
+]
+
+[h2 Ok, now what?]
+
+Well, now let's fire it up:
+
+[pre 
+'''
+>python pyste.py
+
+Pyste version 0.6.5
+
+Usage:
+    pyste [options] --module=<name> interface-files
+
+where options are:
+    -I <path>           add an include path    
+    -D <symbol>         define symbol    
+    --multiple          create various cpps (one for each pyste file), instead
+                        of only one (useful during development)                        
+    --out               specify output filename (default: <module>.cpp)
+                        in --multiple mode, this will be a directory
+    --no-using          do not declare "using namespace boost";
+                        use explicit declarations instead
+    --pyste-ns=<name>   set the namespace where new types will be declared;
+                        default is the empty namespace
+    --debug             writes the xml for each file parsed in the current
+                        directory
+    -h, --help          print this help and exit
+    -v, --version       print version information      
+'''                        
+]
+
+Options explained:
+
+The [^-I] and [^-D] are preprocessor flags, which are needed by GCCXML to parse
+the header files correctly and by Pyste to find the header files declared in the
+interface files.
+
+[^--multiple] tells Pyste to generate multiple cpps for this module (one for
+each header parsed) in the directory named by [^--out], instead of the usual
+single cpp file. This mode is useful during development of a binding, because
+you are constantly changing source files, re-generating the bindings and
+recompiling. This saves a lot of time in compiling.
+
+[^--out] names the output file (default: [^<module>.cpp]), or in multiple mode,
+names a output directory for the files (default: [^<module>]).
+
+[^--no-using] tells Pyste to don't declare "[^using namespace boost;]" in the
+generated cpp, using the namespace boost::python explicitly in all declarations.
+Use only if you're having a name conflict in one of the files.
+
+Use [^--pyste-ns] to change the namespace where new types are declared (for
+instance, the virtual wrappers). Use only if you are having any problems. By
+default, Pyste uses the empty namespace.
+
+[^--debug] will write in the current directory a xml file as outputted by GCCXML
+for each header parsed. Useful for bug reports.
+
+[^-h, --help, -v, --version] are self-explaining, I believe. ;)
+
+So, the usage is simple enough:
+
+[pre >python pyste.py --module=mymodule file.pyste file2.pyste ...]
+
+will generate a file [^mymodule.cpp] in the same dir where the command was
+executed. Now you can compile the file using the same instructions of the
+[@../../doc/tutorial/doc/building_hello_world.html tutorial]. Or, if you prefer:
+
+[pre >python pyste.py --module=mymodule --multiple file.pyste file2.pyste ...]
+
+will create a directory named "mymodule" in the current directory, and will
+generate a bunch of cpp files, one for each header exported. You can then
+compile them all into a single shared library (or dll).
+
+[h2 Wait... how do I set those I and D flags?]
+
+Don't worry: normally GCCXML is already configured correctly for your plataform, 
+so the search path to the standard libraries and the standard defines should 
+already be set. You only have to set the paths to other libraries that your code 
+needs, like Boost, for example.
+
+Plus, Pyste automatically uses the contents of the environment variable
+[^INCLUDE] if it exists. Visual C++ users should run the [^Vcvars32.bat] file,
+which for Visual C++ 6 is normally located at:
+
+    C:\Program Files\Microsoft Visual Studio\VC98\bin\Vcvars32.bat
+
+with that, you should have little trouble setting up the flags.
+
+[blurb [$theme/note.gif][*A note about Psyco][br][br]
+Although you don't have to install [@http://psyco.sourceforge.net/ Psyco] to use Pyste, if you do, Pyste will make use of it to speed up the wrapper generation. Speed ups of 30% can be achieved, so it's highly recommended.
+]
+
+[page The Interface Files]
+
+The interface files are the heart of Pyste. The user creates one or more
+interface files declaring the classes and functions he wants to export, and then
+invokes Pyste passing the interface files to it. Pyste then generates a single
+cpp file with Boost.Python code, with all the classes and functions exported.
+
+Besides declaring the classes and functions, the user has a number of other
+options, like renaming e excluding classes and member functionis. Those are
+explained later on.
+
+[h2 Basics]
+
+Suppose we have a class and some functions that we want to expose to Python
+declared in the header [^hello.h]:
+
+    struct World
+    {
+        World(std::string msg): msg(msg) {} 
+        void set(std::string msg) { this->msg = msg; }
+        std::string greet() { return msg; }
+        std::string msg;
+    };
+
+    enum choice { red, blue };
+    
+    namespace test {
+    
+    void show(choice c) { std::cout << "value: " << (int)c << std::endl; }
+    
+    }
+
+We create a file named [^hello.pyste] and create instances of the classes
+[^Function], [^Class] and [^Enum]:
+
+    Function("test::show", "hello.h")
+    Class("World", "hello.h")
+    Enum("choice", "hello.h")
+
+That will expose the class, the free function and the enum found in [^hello.h]. 
+
+[page:1 Renaming and Excluding]
+
+You can easily rename functions, classes, member functions, attributes, etc. Just use the
+function [^rename], like this:
+
+    World = Class("World", "hello.h")
+    rename(World, "IWorld")
+    show = Function("choice", "hello.h")
+    rename(show, "Show")
+
+You can rename member functions and attributes using this syntax:
+
+    rename(World.greet, "Greet")
+    rename(World.set, "Set")
+    choice = Enum("choice", "hello.h")
+    rename(choice.red, "Red")
+    rename(choice.blue, "Blue")
+
+You can exclude functions, classes, member functions, attributes, etc, in the same way,
+with the function [^exclude]:
+
+    exclude(World.greet)
+    exclude(World.msg)
+
+To access the operators of a class, access the member [^operator] like this
+(supposing that [^C] is a class being exported):
+
+    exclude(C.operator['+'])
+    exclude(C.operator['*'])
+    exclude(C.operator['<<'])
+
+The string inside the brackets is the same as the name of the operator in C++.[br]
+
+[h2 Virtual Member Functions]
+
+Pyste automatically generates wrappers for virtual member functions, but you
+may want to disable this behaviour (for performance reasons, or to let the
+code more clean) if you do not plan to override the functions in Python. To do
+this, use the function [^final]:
+
+    C = Class('C', 'C.h')
+    final(C.foo) # C::foo is a virtual member function
+
+No virtual wrapper code will be generated for the virtual member function
+C::foo that way.
+
+[page:1 Policies]
+
+Even thought Pyste can identify various elements in the C++ code, like virtual
+member functions, attributes, and so on, one thing that it can't do is to
+guess the semantics of functions that return pointers or references. In this
+case, the user must manually specify the policy. Policies are explained in the
+[@../../doc/tutorial/doc/call_policies.html tutorial].
+
+The policies in Pyste are named exactly as in Boost.Python, only the syntax is
+slightly different. For instance, this policy:
+
+    return_internal_reference<1, with_custodian_and_ward<1, 2> >()
+
+becomes in Pyste:    
+
+    return_internal_reference(1, with_custodian_and_ward(1, 2))
+
+The user can specify policies for functions and virtual member functions with
+the [^set_policy] function:
+
+    set_policy(f, return_internal_reference())
+    set_policy(C.foo, return_value_policy(manage_new_object))
+
+[blurb 
+[$theme/note.gif] [*What if a function or member function needs a policy and
+the user doesn't set one?][br][br] If a function needs a policy and one
+was not set, Pyste will issue a error.  The user should then go in the
+interface file and set the policy for it, otherwise the generated cpp won't
+compile.
+]
+
+[blurb
+[$theme/note.gif] 
+Note that, for functions that return [^const T&], the policy
+[^return_value_policy<copy_const_reference>()] wil be used by default, because
+that's normally what you want. You can change it to something else if you need
+to, though.
+]
+
+[page:1 Templates]
+
+Template classes can easily be exported too, but you can't export the template
+itself... you have to export instantiations of it! So, if you want to export a
+[^std::vector], you will have to export vectors of int, doubles, etc.
+
+Suppose we have this code:
+
+    template <class T>
+    struct Point
+    {
+        T x;
+        T y;
+    };
+
+And we want to export [^Point]s of int and double:
+
+    Point = Template("Point", "point.h")
+    Point("int")
+    Point("double")
+
+Pyste will assign default names for each instantiation. In this example, those
+would be "[^Point_int]" and "[^Point_double]", but most of the time users will want to
+rename the instantiations:
+
+    Point("int", "IPoint")         // renames the instantiation
+    double_inst = Point("double")  // another way to do the same
+    rename(double_inst, "DPoint")
+
+Note that you can rename, exclude, set policies, etc, in the [^Template] object
+like you would do with a [^Function] or a [^Class]. This changes affect all
+[*future] instantiations:
+
+    Point = Template("Point", "point.h")
+    Point("float", "FPoint")        // will have x and y as data members
+    rename(Point.x, "X")
+    rename(Point.y, "Y")
+    Point("int", "IPoint")          // will have X and Y as data members
+    Point("double", "DPoint")       // also will have X and Y as data member
+
+If you want to change a option of a particular instantiation, you can do so:
+
+    Point = Template("Point", "point.h")
+    Point("int", "IPoint")          
+    d_inst = Point("double", "DPoint")       
+    rename(d_inst.x, "X")           // only DPoint is affect by this renames,
+    rename(d_inst.y, "Y")           // IPoint stays intact
+
+[blurb [$theme/note.gif] [*What if my template accepts more than one type?]
+[br][br]
+When you want to instantiate a template with more than one type, you can pass
+either a string with the types separated by whitespace, or a list of strings
+'''("int double" or ["int", "double"]''' would both work).
+]
+
+[page:1 Wrappers]
+
+Suppose you have this function:
+
+    std::vector<std::string> names();
+
+But you don't want to export [^std::vector<std::string>], you want this function
+to return a python list of strings. Boost.Python has excellent support for
+that:
+
+    list names_wrapper()
+    {
+        list result;
+        // call original function
+        vector<string> v = names();
+        // put all the strings inside the python list
+        vector<string>::iterator it;
+        for (it = v.begin(); it != v.end(); ++it){
+            result.append(*it);    
+        }
+        return result;
+    }
+    
+    BOOST_PYTHON_MODULE(test)
+    {
+        def("names", &names_wrapper);
+    }
+
+Nice heh? Pyste supports this mechanism too. You declare the [^names_wrapper]
+function in a header named "[^test_wrappers.h]" and in the interface file:
+
+    Include("test_wrappers.h")
+    names = Function("names", "test.h")
+    set_wrapper(names, "names_wrapper")
+
+You can optionally declare the function in the interface file itself:
+
+    names_wrapper = Wrapper("names_wrapper",
+    """
+    list names_wrapper()
+    {
+        // code to call name() and convert the vector to a list...
+    }
+    """)
+    names = Function("names", "test.h")
+    set_wrapper(names, names_wrapper)
+
+The same mechanism can be used with member functions too. Just remember that
+the first parameter of wrappers for member functions is a pointer to the
+class, as in:
+
+    struct C
+    {
+        std::vector<std::string> names();
+    }
+
+    list names_wrapper(C* c)
+    {
+        // same as before, calling c->names() and converting result to a list 
+    }
+
+And then in the interface file:
+
+    C = Class("C", "test.h")
+    set_wrapper(C.names, "names_wrapper")
+
+[blurb 
+[$theme/note.gif]Even though Boost.Python accepts either a pointer or a
+reference to the class in wrappers for member functions as the first parameter,
+Pyste expects them to be a [*pointer]. Doing otherwise will prevent your
+code to compile when you set a wrapper for a virtual member function.
+]
+
+[page:1 Exporting An Entire Header]
+
+Pyste also supports a mechanism to export all declarations found in a header
+file. Suppose again our file, [^hello.h]:
+
+    struct World
+    {
+        World(std::string msg): msg(msg) {} 
+        void set(std::string msg) { this->msg = msg; }
+        std::string greet() { return msg; }
+        std::string msg;
+    };
+
+    enum choice { red, blue };
+    
+    void show(choice c) { std::cout << "value: " << (int)c << std::endl; } 
+
+You can just use the [^AllFromHeader] construct:
+
+    hello = AllFromHeader("hello.h")
+
+this will export all the declarations found in [^hello.h], which is equivalent
+to write:
+
+    Class("World", "hello.h")
+    Enum("choice", "hello.h")
+    Function("show", "hello.h")
+
+Note that you can still use the functions [^rename], [^set_policy], [^exclude], etc. Just access
+the members of the header object like this:
+
+    rename(hello.World.greet, "Greet")
+    exclude(hello.World.set, "Set")
+
+
+[page:1 Smart Pointers]
+
+Pyste for now has manual support for smart pointers. Suppose:
+
+    struct C
+    {
+        int value;
+    };
+
+    boost::shared_ptr<C> newC(int value)
+    {
+        boost::shared_ptr<C> c( new C() );
+        c->value = value;
+        return c;
+    }
+
+    void printC(boost::shared_ptr<C> c)
+    {
+        std::cout << c->value << std::endl;
+    }
+
+To make [^newC] and [^printC] work correctly, you have to tell Pyste that a
+convertor for [^boost::shared_ptr<C>] is needed.
+
+    C = Class('C', 'C.h')
+    use_shared_ptr(C)
+    Function('newC', 'C.h')
+    Function('printC', 'C.h')
+
+For [^std::auto_ptr]'s, use the function [^use_auto_ptr].
+
+This system is temporary, and in the future the converters will automatically be
+exported if needed, without the need to tell Pyste about them explicitly.
+
+[h2 Holders]
+
+If only the converter for the smart pointers is not enough and you need to
+specify the smart pointer as the holder for a class, use the functions
+[^hold_with_shared_ptr] and [^hold_with_auto_ptr]:
+
+    C = Class('C', 'C.h')
+    hold_with_shared_ptr(C)
+    Function('newC', 'C.h')
+    Function('printC', 'C.h') 
+
+[page:1 Global Variables]
+
+To export global variables, use the [^Var] construct:
+
+    Var("myglobal", "foo.h")
+
+Beware of non-const global variables: changes in Python won't reflect in C++!
+If you really must change them in Python, you will have to write some accessor
+functions, and export those.
+
+[page:1 Adding New Methods]
+
+Suppose that you want to add a function to a class, turning it into a member
+function:
+
+    struct World
+    {
+        void set(std::string msg) { this->msg = msg; }
+        std::string msg;
+    };
+
+    std::string greet(World& w)
+    {
+        return w.msg;
+    }
+
+Here, we want to make [^greet] work as a member function of the class [^World]. We do
+that using the [^add_method] construct:
+
+    W = Class("World", "hello.h")
+    add_method(W, "greet")
+
+Notice also that then you can rename it, set its policy, just like a regular
+member function:
+
+    rename(W.greet, 'Greet')
+
+Now from Python:
+
+    >>> import hello
+    >>> w = hello.World()
+    >>> w.set('Ni')
+    >>> w.greet()
+    'Ni'
+    >>> print 'Oh no! The knights who say Ni!'
+    Oh no! The knights who say Ni!
+
+

pyste/doc/renaming_and_excluding.html

@@ -0,0 +1,88 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Renaming and Excluding</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="the_interface_files.html">
+<link rel="next" href="policies.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Renaming and Excluding</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="the_interface_files.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="policies.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<p>
+You can easily rename functions, classes, member functions, attributes, etc. Just use the
+function <tt>rename</tt>, like this:</p>
+<code><pre>
+    <span class=identifier>World </span><span class=special>= </span><span class=identifier>Class</span><span class=special>(</span><span class=string>&quot;World&quot;</span><span class=special>, </span><span class=string>&quot;hello.h&quot;</span><span class=special>)
+    </span><span class=identifier>rename</span><span class=special>(</span><span class=identifier>World</span><span class=special>, </span><span class=string>&quot;IWorld&quot;</span><span class=special>)
+    </span><span class=identifier>show </span><span class=special>= </span><span class=identifier>Function</span><span class=special>(</span><span class=string>&quot;choice&quot;</span><span class=special>, </span><span class=string>&quot;hello.h&quot;</span><span class=special>)
+    </span><span class=identifier>rename</span><span class=special>(</span><span class=identifier>show</span><span class=special>, </span><span class=string>&quot;Show&quot;</span><span class=special>)
+</span></pre></code>
+<p>
+You can rename member functions and attributes using this syntax:</p>
+<code><pre>
+    <span class=identifier>rename</span><span class=special>(</span><span class=identifier>World</span><span class=special>.</span><span class=identifier>greet</span><span class=special>, </span><span class=string>&quot;Greet&quot;</span><span class=special>)
+    </span><span class=identifier>rename</span><span class=special>(</span><span class=identifier>World</span><span class=special>.</span><span class=identifier>set</span><span class=special>, </span><span class=string>&quot;Set&quot;</span><span class=special>)
+    </span><span class=identifier>choice </span><span class=special>= </span><span class=identifier>Enum</span><span class=special>(</span><span class=string>&quot;choice&quot;</span><span class=special>, </span><span class=string>&quot;hello.h&quot;</span><span class=special>)
+    </span><span class=identifier>rename</span><span class=special>(</span><span class=identifier>choice</span><span class=special>.</span><span class=identifier>red</span><span class=special>, </span><span class=string>&quot;Red&quot;</span><span class=special>)
+    </span><span class=identifier>rename</span><span class=special>(</span><span class=identifier>choice</span><span class=special>.</span><span class=identifier>blue</span><span class=special>, </span><span class=string>&quot;Blue&quot;</span><span class=special>)
+</span></pre></code>
+<p>
+You can exclude functions, classes, member functions, attributes, etc, in the same way,
+with the function <tt>exclude</tt>:</p>
+<code><pre>
+    <span class=identifier>exclude</span><span class=special>(</span><span class=identifier>World</span><span class=special>.</span><span class=identifier>greet</span><span class=special>)
+    </span><span class=identifier>exclude</span><span class=special>(</span><span class=identifier>World</span><span class=special>.</span><span class=identifier>msg</span><span class=special>)
+</span></pre></code>
+<p>
+To access the operators of a class, access the member <tt>operator</tt> like this
+(supposing that <tt>C</tt> is a class being exported):</p>
+<code><pre>
+    <span class=identifier>exclude</span><span class=special>(</span><span class=identifier>C</span><span class=special>.</span><span class=keyword>operator</span><span class=special>[</span><span class=literal>'+'</span><span class=special>])
+    </span><span class=identifier>exclude</span><span class=special>(</span><span class=identifier>C</span><span class=special>.</span><span class=keyword>operator</span><span class=special>[</span><span class=literal>'*'</span><span class=special>])
+    </span><span class=identifier>exclude</span><span class=special>(</span><span class=identifier>C</span><span class=special>.</span><span class=keyword>operator</span><span class=special>[</span><span class=literal>'&lt;&lt;'</span><span class=special>])
+</span></pre></code>
+<p>
+The string inside the brackets is the same as the name of the operator in C++.<br></p>
+<a name="virtual_member_functions"></a><h2>Virtual Member Functions</h2><p>
+Pyste automatically generates wrappers for virtual member functions, but you
+may want to disable this behaviour (for performance reasons, or to let the
+code more clean) if you do not plan to override the functions in Python. To do
+this, use the function <tt>final</tt>:</p>
+<code><pre>
+    <span class=identifier>C </span><span class=special>= </span><span class=identifier>Class</span><span class=special>(</span><span class=literal>'C'</span><span class=special>, </span><span class=literal>'C.h'</span><span class=special>)
+    </span><span class=identifier>final</span><span class=special>(</span><span class=identifier>C</span><span class=special>.</span><span class=identifier>foo</span><span class=special>) </span>##<span class=identifier>C</span><span class=special>::</span><span class=identifier>foo </span><span class=identifier>is </span><span class=identifier>a </span><span class=keyword>virtual </span><span class=identifier>member </span><span class=identifier>function
+</span></pre></code>
+<p>
+No virtual wrapper code will be generated for the virtual member function
+C::foo that way.</p>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="the_interface_files.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="policies.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2003 Bruno da Silva de Oliveira<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

pyste/doc/running_pyste.html

@@ -0,0 +1,150 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Running Pyste</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="introduction.html">
+<link rel="next" href="the_interface_files.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Running Pyste</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="introduction.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="the_interface_files.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<p>
+To run Pyste, you will need:</p>
+<ul><li>Python 2.2, available at <a href="http://www.python.org">
+python's website</a>.</li><li>The great <a href="http://effbot.org">
+elementtree</a> library, from Fredrik Lundh.</li><li>The excellent <a href="http://www.gccxml.org">
+GCCXML</a>, from Brad King.</li></ul><p>
+Installation for the tools is available in their respective webpages.</p>
+<table width="80%" border="0" align="center">
+  <tr>
+    <td class="note_box">
+
+<img src="theme/note.gif"></img> <a href="http://www.gccxml.org">
+GCCXML</a> must be accessible in the PATH environment variable, so
+that Pyste can call it. How to do this varies from platform to platform.
+    </td>
+  </tr>
+</table>
+<a name="ok__now_what_"></a><h2>Ok, now what?</h2><p>
+Well, now let's fire it up:</p>
+<code><pre>
+
+&gt;python pyste.py
+
+Pyste version 0.6.5
+
+Usage:
+    pyste [options] --module=&lt;name&gt; interface-files
+
+where options are:
+    -I &lt;path&gt;           add an include path    
+    -D &lt;symbol&gt;         define symbol    
+    --multiple          create various cpps (one for each pyste file), instead
+                        of only one (useful during development)                        
+    --out               specify output filename (default: &lt;module&gt;.cpp)
+                        in --multiple mode, this will be a directory
+    --no-using          do not declare &quot;using namespace boost&quot;;
+                        use explicit declarations instead
+    --pyste-ns=&lt;name&gt;   set the namespace where new types will be declared;
+                        default is the empty namespace
+    --debug             writes the xml for each file parsed in the current
+                        directory
+    -h, --help          print this help and exit
+    -v, --version       print version information      
+                        
+</pre></code><p>
+Options explained:</p>
+<p>
+The <tt>-I</tt> and <tt>-D</tt> are preprocessor flags, which are needed by <a href="http://www.gccxml.org">
+GCCXML</a> to parse
+the header files correctly and by Pyste to find the header files declared in the
+interface files.</p>
+<p>
+<tt>--multiple</tt> tells Pyste to generate multiple cpps for this module (one for
+each header parsed) in the directory named by <tt>--out</tt>, instead of the usual
+single cpp file. This mode is useful during development of a binding, because
+you are constantly changing source files, re-generating the bindings and
+recompiling. This saves a lot of time in compiling.</p>
+<p>
+<tt>--out</tt> names the output file (default: <tt>&lt;module&gt;.cpp</tt>), or in multiple mode,
+names a output directory for the files (default: <tt>&lt;module&gt;</tt>).</p>
+<p>
+<tt>--no-using</tt> tells Pyste to don't declare &quot;<tt>using namespace boost;</tt>&quot; in the
+generated cpp, using the namespace boost::python explicitly in all declarations.
+Use only if you're having a name conflict in one of the files.</p>
+<p>
+Use <tt>--pyste-ns</tt> to change the namespace where new types are declared (for
+instance, the virtual wrappers). Use only if you are having any problems. By
+default, Pyste uses the empty namespace.</p>
+<p>
+<tt>--debug</tt> will write in the current directory a xml file as outputted by <a href="http://www.gccxml.org">
+GCCXML</a>
+for each header parsed. Useful for bug reports.</p>
+<p>
+<tt>-h, --help, -v, --version</tt> are self-explaining, I believe. ;)</p>
+<p>
+So, the usage is simple enough:</p>
+<code><pre>&gt;python pyste.py --module=mymodule file.pyste file2.pyste ...</pre></code><p>
+will generate a file <tt>mymodule.cpp</tt> in the same dir where the command was
+executed. Now you can compile the file using the same instructions of the
+<a href="../../doc/tutorial/doc/building_hello_world.html">
+tutorial</a>. Or, if you prefer:</p>
+<code><pre>&gt;python pyste.py --module=mymodule --multiple file.pyste file2.pyste ...</pre></code><p>
+will create a directory named &quot;mymodule&quot; in the current directory, and will
+generate a bunch of cpp files, one for each header exported. You can then
+compile them all into a single shared library (or dll).</p>
+<a name="wait____how_do_i_set_those_i_and_d_flags_"></a><h2>Wait... how do I set those I and D flags?</h2><p>
+Don't worry: normally <a href="http://www.gccxml.org">
+GCCXML</a> is already configured correctly for your plataform, 
+so the search path to the standard libraries and the standard defines should 
+already be set. You only have to set the paths to other libraries that your code 
+needs, like Boost, for example.</p>
+<p>
+Plus, Pyste automatically uses the contents of the environment variable
+<tt>INCLUDE</tt> if it exists. Visual C++ users should run the <tt>Vcvars32.bat</tt> file,
+which for Visual C++ 6 is normally located at:</p>
+<code><pre>
+    <span class=identifier>C</span><span class=special>:\</span><span class=identifier>Program </span><span class=identifier>Files</span><span class=special>\</span><span class=identifier>Microsoft </span><span class=identifier>Visual </span><span class=identifier>Studio</span><span class=special>\</span><span class=identifier>VC98</span><span class=special>\</span><span class=identifier>bin</span><span class=special>\</span><span class=identifier>Vcvars32</span><span class=special>.</span><span class=identifier>bat
+</span></pre></code>
+<p>
+with that, you should have little trouble setting up the flags.</p>
+<table width="80%" border="0" align="center">
+  <tr>
+    <td class="note_box">
+<img src="theme/note.gif"></img><b>A note about Psyco</b><br><br>
+Although you don't have to install <a href="http://psyco.sourceforge.net/">
+Psyco</a> to use Pyste, if you do, Pyste will make use of it to speed up the wrapper generation. Speed ups of 30% can be achieved, so it's highly recommended.
+    </td>
+  </tr>
+</table>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="introduction.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="the_interface_files.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2003 Bruno da Silva de Oliveira<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

pyste/doc/smart_pointers.html

@@ -0,0 +1,85 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Smart Pointers</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="exporting_an_entire_header.html">
+<link rel="next" href="global_variables.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Smart Pointers</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="exporting_an_entire_header.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="global_variables.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<p>
+Pyste for now has manual support for smart pointers. Suppose:</p>
+<code><pre>
+    <span class=keyword>struct </span><span class=identifier>C
+    </span><span class=special>{
+        </span><span class=keyword>int </span><span class=identifier>value</span><span class=special>;
+    };
+
+    </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>shared_ptr</span><span class=special>&lt;</span><span class=identifier>C</span><span class=special>&gt; </span><span class=identifier>newC</span><span class=special>(</span><span class=keyword>int </span><span class=identifier>value</span><span class=special>)
+    {
+        </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>shared_ptr</span><span class=special>&lt;</span><span class=identifier>C</span><span class=special>&gt; </span><span class=identifier>c</span><span class=special>( </span><span class=keyword>new </span><span class=identifier>C</span><span class=special>() );
+        </span><span class=identifier>c</span><span class=special>-&gt;</span><span class=identifier>value </span><span class=special>= </span><span class=identifier>value</span><span class=special>;
+        </span><span class=keyword>return </span><span class=identifier>c</span><span class=special>;
+    }
+
+    </span><span class=keyword>void </span><span class=identifier>printC</span><span class=special>(</span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>shared_ptr</span><span class=special>&lt;</span><span class=identifier>C</span><span class=special>&gt; </span><span class=identifier>c</span><span class=special>)
+    {
+        </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=identifier>c</span><span class=special>-&gt;</span><span class=identifier>value </span><span class=special>&lt;&lt; </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>endl</span><span class=special>;
+    }
+</span></pre></code>
+<p>
+To make <tt>newC</tt> and <tt>printC</tt> work correctly, you have to tell Pyste that a
+convertor for <tt>boost::shared_ptr&lt;C&gt;</tt> is needed.</p>
+<code><pre>
+    <span class=identifier>C </span><span class=special>= </span><span class=identifier>Class</span><span class=special>(</span><span class=literal>'C'</span><span class=special>, </span><span class=literal>'C.h'</span><span class=special>)
+    </span><span class=identifier>use_shared_ptr</span><span class=special>(</span><span class=identifier>C</span><span class=special>)
+    </span><span class=identifier>Function</span><span class=special>(</span><span class=literal>'newC'</span><span class=special>, </span><span class=literal>'C.h'</span><span class=special>)
+    </span><span class=identifier>Function</span><span class=special>(</span><span class=literal>'printC'</span><span class=special>, </span><span class=literal>'C.h'</span><span class=special>)
+</span></pre></code>
+<p>
+For <tt>std::auto_ptr</tt>'s, use the function <tt>use_auto_ptr</tt>.</p>
+<p>
+This system is temporary, and in the future the converters will automatically be
+exported if needed, without the need to tell Pyste about them explicitly.</p>
+<a name="holders"></a><h2>Holders</h2><p>
+If only the converter for the smart pointers is not enough and you need to
+specify the smart pointer as the holder for a class, use the functions
+<tt>hold_with_shared_ptr</tt> and <tt>hold_with_auto_ptr</tt>:</p>
+<code><pre>
+    <span class=identifier>C </span><span class=special>= </span><span class=identifier>Class</span><span class=special>(</span><span class=literal>'C'</span><span class=special>, </span><span class=literal>'C.h'</span><span class=special>)
+    </span><span class=identifier>hold_with_shared_ptr</span><span class=special>(</span><span class=identifier>C</span><span class=special>)
+    </span><span class=identifier>Function</span><span class=special>(</span><span class=literal>'newC'</span><span class=special>, </span><span class=literal>'C.h'</span><span class=special>)
+    </span><span class=identifier>Function</span><span class=special>(</span><span class=literal>'printC'</span><span class=special>, </span><span class=literal>'C.h'</span><span class=special>) 
+</span></pre></code>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="exporting_an_entire_header.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="global_variables.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2003 Bruno da Silva de Oliveira<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

pyste/doc/templates.html

@@ -0,0 +1,103 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Templates</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="policies.html">
+<link rel="next" href="wrappers.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Templates</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="policies.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="wrappers.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<p>
+Template classes can easily be exported too, but you can't export the template
+itself... you have to export instantiations of it! So, if you want to export a
+<tt>std::vector</tt>, you will have to export vectors of int, doubles, etc.</p>
+<p>
+Suppose we have this code:</p>
+<code><pre>
+    <span class=keyword>template </span><span class=special>&lt;</span><span class=keyword>class </span><span class=identifier>T</span><span class=special>&gt;
+    </span><span class=keyword>struct </span><span class=identifier>Point
+    </span><span class=special>{
+        </span><span class=identifier>T </span><span class=identifier>x</span><span class=special>;
+        </span><span class=identifier>T </span><span class=identifier>y</span><span class=special>;
+    };
+</span></pre></code>
+<p>
+And we want to export <tt>Point</tt>s of int and double:</p>
+<code><pre>
+    <span class=identifier>Point </span><span class=special>= </span><span class=identifier>Template</span><span class=special>(</span><span class=string>&quot;Point&quot;</span><span class=special>, </span><span class=string>&quot;point.h&quot;</span><span class=special>)
+    </span><span class=identifier>Point</span><span class=special>(</span><span class=string>&quot;int&quot;</span><span class=special>)
+    </span><span class=identifier>Point</span><span class=special>(</span><span class=string>&quot;double&quot;</span><span class=special>)
+</span></pre></code>
+<p>
+Pyste will assign default names for each instantiation. In this example, those
+would be &quot;<tt>Point_int</tt>&quot; and &quot;<tt>Point_double</tt>&quot;, but most of the time users will want to
+rename the instantiations:</p>
+<code><pre>
+    <span class=identifier>Point</span><span class=special>(</span><span class=string>&quot;int&quot;</span><span class=special>, </span><span class=string>&quot;IPoint&quot;</span><span class=special>)         // </span><span class=identifier>renames </span><span class=identifier>the </span><span class=identifier>instantiation
+    </span><span class=identifier>double_inst </span><span class=special>= </span><span class=identifier>Point</span><span class=special>(</span><span class=string>&quot;double&quot;</span><span class=special>)  // </span><span class=identifier>another </span><span class=identifier>way </span><span class=identifier>to </span><span class=keyword>do </span><span class=identifier>the </span><span class=identifier>same
+    </span><span class=identifier>rename</span><span class=special>(</span><span class=identifier>double_inst</span><span class=special>, </span><span class=string>&quot;DPoint&quot;</span><span class=special>)
+</span></pre></code>
+<p>
+Note that you can rename, exclude, set policies, etc, in the <tt>Template</tt> object
+like you would do with a <tt>Function</tt> or a <tt>Class</tt>. This changes affect all
+<b>future</b> instantiations:</p>
+<code><pre>
+    <span class=identifier>Point </span><span class=special>= </span><span class=identifier>Template</span><span class=special>(</span><span class=string>&quot;Point&quot;</span><span class=special>, </span><span class=string>&quot;point.h&quot;</span><span class=special>)
+    </span><span class=identifier>Point</span><span class=special>(</span><span class=string>&quot;float&quot;</span><span class=special>, </span><span class=string>&quot;FPoint&quot;</span><span class=special>)        // </span><span class=identifier>will </span><span class=identifier>have </span><span class=identifier>x </span><span class=keyword>and </span><span class=identifier>y </span><span class=identifier>as </span><span class=identifier>data </span><span class=identifier>members
+    </span><span class=identifier>rename</span><span class=special>(</span><span class=identifier>Point</span><span class=special>.</span><span class=identifier>x</span><span class=special>, </span><span class=string>&quot;X&quot;</span><span class=special>)
+    </span><span class=identifier>rename</span><span class=special>(</span><span class=identifier>Point</span><span class=special>.</span><span class=identifier>y</span><span class=special>, </span><span class=string>&quot;Y&quot;</span><span class=special>)
+    </span><span class=identifier>Point</span><span class=special>(</span><span class=string>&quot;int&quot;</span><span class=special>, </span><span class=string>&quot;IPoint&quot;</span><span class=special>)          // </span><span class=identifier>will </span><span class=identifier>have </span><span class=identifier>X </span><span class=keyword>and </span><span class=identifier>Y </span><span class=identifier>as </span><span class=identifier>data </span><span class=identifier>members
+    </span><span class=identifier>Point</span><span class=special>(</span><span class=string>&quot;double&quot;</span><span class=special>, </span><span class=string>&quot;DPoint&quot;</span><span class=special>)       // </span><span class=identifier>also </span><span class=identifier>will </span><span class=identifier>have </span><span class=identifier>X </span><span class=keyword>and </span><span class=identifier>Y </span><span class=identifier>as </span><span class=identifier>data </span><span class=identifier>member
+</span></pre></code>
+<p>
+If you want to change a option of a particular instantiation, you can do so:</p>
+<code><pre>
+    <span class=identifier>Point </span><span class=special>= </span><span class=identifier>Template</span><span class=special>(</span><span class=string>&quot;Point&quot;</span><span class=special>, </span><span class=string>&quot;point.h&quot;</span><span class=special>)
+    </span><span class=identifier>Point</span><span class=special>(</span><span class=string>&quot;int&quot;</span><span class=special>, </span><span class=string>&quot;IPoint&quot;</span><span class=special>)          
+    </span><span class=identifier>d_inst </span><span class=special>= </span><span class=identifier>Point</span><span class=special>(</span><span class=string>&quot;double&quot;</span><span class=special>, </span><span class=string>&quot;DPoint&quot;</span><span class=special>)       
+    </span><span class=identifier>rename</span><span class=special>(</span><span class=identifier>d_inst</span><span class=special>.</span><span class=identifier>x</span><span class=special>, </span><span class=string>&quot;X&quot;</span><span class=special>)           // </span><span class=identifier>only </span><span class=identifier>DPoint </span><span class=identifier>is </span><span class=identifier>affect </span><span class=identifier>by </span><span class=keyword>this </span><span class=identifier>renames</span><span class=special>,
+    </span><span class=identifier>rename</span><span class=special>(</span><span class=identifier>d_inst</span><span class=special>.</span><span class=identifier>y</span><span class=special>, </span><span class=string>&quot;Y&quot;</span><span class=special>)           // </span><span class=identifier>IPoint </span><span class=identifier>stays </span><span class=identifier>intact
+</span></pre></code>
+<table width="80%" border="0" align="center">
+  <tr>
+    <td class="note_box">
+<img src="theme/note.gif"></img> <b>What if my template accepts more than one type?</b>
+<br><br>
+When you want to instantiate a template with more than one type, you can pass
+either a string with the types separated by whitespace, or a list of strings
+(&quot;int double&quot; or [&quot;int&quot;, &quot;double&quot;] would both work).
+    </td>
+  </tr>
+</table>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="policies.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="wrappers.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2003 Bruno da Silva de Oliveira<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

pyste/doc/the_interface_files.html

@@ -0,0 +1,81 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>The Interface Files</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="running_pyste.html">
+<link rel="next" href="renaming_and_excluding.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>The Interface Files</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="running_pyste.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="renaming_and_excluding.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<p>
+The interface files are the heart of Pyste. The user creates one or more
+interface files declaring the classes and functions he wants to export, and then
+invokes Pyste passing the interface files to it. Pyste then generates a single
+cpp file with <a href="../../index.html">
+Boost.Python</a> code, with all the classes and functions exported.</p>
+<p>
+Besides declaring the classes and functions, the user has a number of other
+options, like renaming e excluding classes and member functionis. Those are
+explained later on.</p>
+<a name="basics"></a><h2>Basics</h2><p>
+Suppose we have a class and some functions that we want to expose to Python
+declared in the header <tt>hello.h</tt>:</p>
+<code><pre>
+    <span class=keyword>struct </span><span class=identifier>World
+    </span><span class=special>{
+        </span><span class=identifier>World</span><span class=special>(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>msg</span><span class=special>): </span><span class=identifier>msg</span><span class=special>(</span><span class=identifier>msg</span><span class=special>) {} 
+        </span><span class=keyword>void </span><span class=identifier>set</span><span class=special>(</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>msg</span><span class=special>) { </span><span class=keyword>this</span><span class=special>-&gt;</span><span class=identifier>msg </span><span class=special>= </span><span class=identifier>msg</span><span class=special>; }
+        </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>greet</span><span class=special>() { </span><span class=keyword>return </span><span class=identifier>msg</span><span class=special>; }
+        </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>msg</span><span class=special>;
+    };
+
+    </span><span class=keyword>enum </span><span class=identifier>choice </span><span class=special>{ </span><span class=identifier>red</span><span class=special>, </span><span class=identifier>blue </span><span class=special>};
+    
+    </span><span class=keyword>namespace </span><span class=identifier>test </span><span class=special>{
+    
+    </span><span class=keyword>void </span><span class=identifier>show</span><span class=special>(</span><span class=identifier>choice </span><span class=identifier>c</span><span class=special>) { </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=string>&quot;value: &quot; </span><span class=special>&lt;&lt; (</span><span class=keyword>int</span><span class=special>)</span><span class=identifier>c </span><span class=special>&lt;&lt; </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>endl</span><span class=special>; }
+    
+    }
+</span></pre></code>
+<p>
+We create a file named <tt>hello.pyste</tt> and create instances of the classes
+<tt>Function</tt>, <tt>Class</tt> and <tt>Enum</tt>:</p>
+<code><pre>
+    <span class=identifier>Function</span><span class=special>(</span><span class=string>&quot;test::show&quot;</span><span class=special>, </span><span class=string>&quot;hello.h&quot;</span><span class=special>)
+    </span><span class=identifier>Class</span><span class=special>(</span><span class=string>&quot;World&quot;</span><span class=special>, </span><span class=string>&quot;hello.h&quot;</span><span class=special>)
+    </span><span class=identifier>Enum</span><span class=special>(</span><span class=string>&quot;choice&quot;</span><span class=special>, </span><span class=string>&quot;hello.h&quot;</span><span class=special>)
+</span></pre></code>
+<p>
+That will expose the class, the free function and the enum found in <tt>hello.h</tt>. </p>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="running_pyste.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="renaming_and_excluding.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2003 Bruno da Silva de Oliveira<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

pyste/doc/theme/style.css

@@ -0,0 +1,170 @@
+body
+{
+    background-image: url(bkd.gif);
+    background-color: #FFFFFF;
+    margin: 1em 2em 1em 2em;
+}
+
+h1 { font-family: Verdana, Arial, Helvetica, sans-serif; font-weight: bold; text-align: left;  }
+h2 { font: 140% sans-serif; font-weight: bold; text-align: left;  }
+h3 { font: 120% sans-serif; font-weight: bold; text-align: left;  }
+h4 { font: bold 100% sans-serif; font-weight: bold; text-align: left;  }
+h5 { font: italic 100% sans-serif; font-weight: bold; text-align: left;  }
+h6 { font: small-caps 100% sans-serif; font-weight: bold; text-align: left;  }
+
+pre
+{
+    border-top: gray 1pt solid;
+    border-right: gray 1pt solid;
+    border-left: gray 1pt solid;
+    border-bottom: gray 1pt solid;
+
+    padding-top: 2pt;
+    padding-right: 2pt;
+    padding-left: 2pt;
+    padding-bottom: 2pt;
+
+    display: block;
+    font-family: "courier new", courier, mono;
+    background-color: #eeeeee; font-size: small
+}
+
+code
+{
+    font-family: "Courier New", Courier, mono;
+    font-size: small
+}
+
+tt
+{
+    display: inline;
+    font-family: "Courier New", Courier, mono;
+    color: #000099;
+    font-size: small
+}
+
+p
+{
+    text-align: justify;
+    font-family: Georgia, "Times New Roman", Times, serif
+}
+
+ul
+{
+    list-style-image: url(bullet.gif);
+    font-family: Georgia, "Times New Roman", Times, serif
+}
+
+ol
+{
+    font-family: Georgia, "Times New Roman", Times, serif
+}
+
+a
+{
+    font-weight: bold;
+    color: #003366;
+    text-decoration: none;
+}
+
+a:hover { color: #8080FF; }
+
+.literal        {  color: #666666; font-style: italic}
+.keyword        {  color: #000099}
+.identifier     {}
+.comment        {  font-style: italic; color: #990000}
+.special        {  color: #800040}
+.preprocessor   {  color: #FF0000}
+.string         {  font-style: italic; color: #666666}
+.copyright      {  color: #666666; font-size: small}
+.white_bkd      {  background-color: #FFFFFF}
+.dk_grey_bkd    {  background-color: #999999}
+.quotes         {  color: #666666; font-style: italic; font-weight: bold}
+
+.note_box
+{
+    display: block;
+
+    border-top: gray 1pt solid;
+    border-right: gray 1pt solid;
+    border-left: gray 1pt solid;
+    border-bottom: gray 1pt solid;
+
+    padding-right: 12pt;
+    padding-left: 12pt;
+    padding-bottom: 12pt;
+    padding-top: 12pt;
+
+    font-family: Arial, Helvetica, sans-serif;
+    background-color: #E2E9EF;
+    font-size: small; text-align: justify
+}
+
+.table_title
+{
+    background-color: #648CCA;
+
+    font-family: Verdana, Arial, Helvetica, sans-serif; color: #FFFFFF;
+    font-weight: bold
+; padding-top: 4px; padding-right: 4px; padding-bottom: 4px; padding-left: 4px
+}
+
+.table_cells
+{
+    background-color: #E2E9EF;
+
+    font-family: Geneva, Arial, Helvetica, san-serif;
+    font-size: small
+; padding-top: 4px; padding-right: 4px; padding-bottom: 4px; padding-left: 4px
+}
+
+.toc
+{
+    DISPLAY: block;
+    background-color: #E2E9EF
+    font-family: Arial, Helvetica, sans-serif;
+
+    border-top: gray 1pt solid;
+    border-left: gray 1pt solid;
+    border-bottom: gray 1pt solid;
+    border-right: gray 1pt solid;
+
+    padding-top: 24pt;
+    padding-right: 24pt;
+    padding-left: 24pt;
+    padding-bottom: 24pt;
+}
+
+.toc_title
+{
+    background-color: #648CCA;
+    padding-top: 4px;
+    padding-right: 4px;
+    padding-bottom: 4px;
+    padding-left: 4px;
+    font-family: Geneva, Arial, Helvetica, san-serif;
+    color: #FFFFFF;
+    font-weight: bold
+}
+
+.toc_cells
+{
+    background-color: #E2E9EF;
+    padding-top: 4px;
+    padding-right: 4px;
+    padding-bottom: 4px;
+    padding-left: 4px;
+    font-family: Geneva, Arial, Helvetica, san-serif;
+    font-size: small
+}
+
+div.logo
+{
+	float: right;
+}
+
+.toc_cells_L0 { background-color: #E2E9EF; padding-top: 4px; padding-right: 4px; padding-bottom: 4px; padding-left: 4px; font-family: Geneva, Arial, Helvetica, san-serif; font-size: small }
+.toc_cells_L1 { background-color: #E2E9EF; padding-top: 4px; padding-right: 4px; padding-bottom: 4px; padding-left: 44px; font-family: Geneva, Arial, Helvetica, san-serif; font-size: small }
+.toc_cells_L2 { background-color: #E2E9EF; padding-top: 4px; padding-right: 4px; padding-bottom: 4px; padding-left: 88px; font-family: Geneva, Arial, Helvetica, san-serif; font-size: small }
+.toc_cells_L3 { background-color: #E2E9EF; padding-top: 4px; padding-right: 4px; padding-bottom: 4px; padding-left: 122px; font-family: Geneva, Arial, Helvetica, san-serif; font-size: small }
+.toc_cells_L4 { background-color: #E2E9EF; padding-top: 4px; padding-right: 4px; padding-bottom: 4px; padding-left: 166px; font-family: Geneva, Arial, Helvetica, san-serif; font-size: small }

pyste/doc/wrappers.html

@@ -0,0 +1,124 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Wrappers</title>
+<link rel="stylesheet" href="theme/style.css" type="text/css">
+<link rel="prev" href="templates.html">
+<link rel="next" href="exporting_an_entire_header.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Wrappers</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="templates.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="exporting_an_entire_header.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<p>
+Suppose you have this function:</p>
+<code><pre>
+    <span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>&gt; </span><span class=identifier>names</span><span class=special>();
+</span></pre></code>
+<p>
+But you don't want to export <tt>std::vector&lt;std::string&gt;</tt>, you want this function
+to return a python list of strings. <a href="../../index.html">
+Boost.Python</a> has excellent support for
+that:</p>
+<code><pre>
+    <span class=identifier>list </span><span class=identifier>names_wrapper</span><span class=special>()
+    {
+        </span><span class=identifier>list </span><span class=identifier>result</span><span class=special>;
+        // </span><span class=identifier>call </span><span class=identifier>original </span><span class=identifier>function
+        </span><span class=identifier>vector</span><span class=special>&lt;</span><span class=identifier>string</span><span class=special>&gt; </span><span class=identifier>v </span><span class=special>= </span><span class=identifier>names</span><span class=special>();
+        // </span><span class=identifier>put </span><span class=identifier>all </span><span class=identifier>the </span><span class=identifier>strings </span><span class=identifier>inside </span><span class=identifier>the </span><span class=identifier>python </span><span class=identifier>list
+        </span><span class=identifier>vector</span><span class=special>&lt;</span><span class=identifier>string</span><span class=special>&gt;::</span><span class=identifier>iterator </span><span class=identifier>it</span><span class=special>;
+        </span><span class=keyword>for </span><span class=special>(</span><span class=identifier>it </span><span class=special>= </span><span class=identifier>v</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(); </span><span class=identifier>it </span><span class=special>!= </span><span class=identifier>v</span><span class=special>.</span><span class=identifier>end</span><span class=special>(); ++</span><span class=identifier>it</span><span class=special>){
+            </span><span class=identifier>result</span><span class=special>.</span><span class=identifier>append</span><span class=special>(*</span><span class=identifier>it</span><span class=special>);    
+        }
+        </span><span class=keyword>return </span><span class=identifier>result</span><span class=special>;
+    }
+    
+    </span><span class=identifier>BOOST_PYTHON_MODULE</span><span class=special>(</span><span class=identifier>test</span><span class=special>)
+    {
+        </span><span class=identifier>def</span><span class=special>(</span><span class=string>&quot;names&quot;</span><span class=special>, &amp;</span><span class=identifier>names_wrapper</span><span class=special>);
+    }
+</span></pre></code>
+<p>
+Nice heh? Pyste supports this mechanism too. You declare the <tt>names_wrapper</tt>
+function in a header named &quot;<tt>test_wrappers.h</tt>&quot; and in the interface file:</p>
+<code><pre>
+    <span class=identifier>Include</span><span class=special>(</span><span class=string>&quot;test_wrappers.h&quot;</span><span class=special>)
+    </span><span class=identifier>names </span><span class=special>= </span><span class=identifier>Function</span><span class=special>(</span><span class=string>&quot;names&quot;</span><span class=special>, </span><span class=string>&quot;test.h&quot;</span><span class=special>)
+    </span><span class=identifier>set_wrapper</span><span class=special>(</span><span class=identifier>names</span><span class=special>, </span><span class=string>&quot;names_wrapper&quot;</span><span class=special>)
+</span></pre></code>
+<p>
+You can optionally declare the function in the interface file itself:</p>
+<code><pre>
+    <span class=identifier>names_wrapper </span><span class=special>= </span><span class=identifier>Wrapper</span><span class=special>(</span><span class=string>&quot;names_wrapper&quot;</span><span class=special>,
+    </span><span class=string>&quot;&quot;</span><span class=string>&quot;
+    list names_wrapper()
+    {
+        // code to call name() and convert the vector to a list...
+    }
+    &quot;</span><span class=string>&quot;&quot;</span><span class=special>)
+    </span><span class=identifier>names </span><span class=special>= </span><span class=identifier>Function</span><span class=special>(</span><span class=string>&quot;names&quot;</span><span class=special>, </span><span class=string>&quot;test.h&quot;</span><span class=special>)
+    </span><span class=identifier>set_wrapper</span><span class=special>(</span><span class=identifier>names</span><span class=special>, </span><span class=identifier>names_wrapper</span><span class=special>)
+</span></pre></code>
+<p>
+The same mechanism can be used with member functions too. Just remember that
+the first parameter of wrappers for member functions is a pointer to the
+class, as in:</p>
+<code><pre>
+    <span class=keyword>struct </span><span class=identifier>C
+    </span><span class=special>{
+        </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>&gt; </span><span class=identifier>names</span><span class=special>();
+    }
+
+    </span><span class=identifier>list </span><span class=identifier>names_wrapper</span><span class=special>(</span><span class=identifier>C</span><span class=special>* </span><span class=identifier>c</span><span class=special>)
+    {
+        // </span><span class=identifier>same </span><span class=identifier>as </span><span class=identifier>before</span><span class=special>, </span><span class=identifier>calling </span><span class=identifier>c</span><span class=special>-&gt;</span><span class=identifier>names</span><span class=special>() </span><span class=keyword>and </span><span class=identifier>converting </span><span class=identifier>result </span><span class=identifier>to </span><span class=identifier>a </span><span class=identifier>list 
+    </span><span class=special>}
+</span></pre></code>
+<p>
+And then in the interface file:</p>
+<code><pre>
+    <span class=identifier>C </span><span class=special>= </span><span class=identifier>Class</span><span class=special>(</span><span class=string>&quot;C&quot;</span><span class=special>, </span><span class=string>&quot;test.h&quot;</span><span class=special>)
+    </span><span class=identifier>set_wrapper</span><span class=special>(</span><span class=identifier>C</span><span class=special>.</span><span class=identifier>names</span><span class=special>, </span><span class=string>&quot;names_wrapper&quot;</span><span class=special>)
+</span></pre></code>
+<table width="80%" border="0" align="center">
+  <tr>
+    <td class="note_box">
+
+<img src="theme/note.gif"></img>Even though <a href="../../index.html">
+Boost.Python</a> accepts either a pointer or a
+reference to the class in wrappers for member functions as the first parameter,
+Pyste expects them to be a <b>pointer</b>. Doing otherwise will prevent your
+code to compile when you set a wrapper for a virtual member function.
+    </td>
+  </tr>
+</table>
+<table border="0">
+  <tr>
+    <td width="30"><a href="../index.html"><img src="theme/u_arr.gif" border="0"></a></td>
+    <td width="30"><a href="templates.html"><img src="theme/l_arr.gif" border="0"></a></td>
+    <td width="20"><a href="exporting_an_entire_header.html"><img src="theme/r_arr.gif" border="0"></a></td>
+   </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2003 Bruno da Silva de Oliveira<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

pyste/index.html

@@ -0,0 +1,86 @@
+<html>
+<head>
+<!-- Generated by the Spirit (http://spirit.sf.net) QuickDoc -->
+<title>Pyste Documentation</title>
+<link rel="stylesheet" href="doc/theme/style.css" type="text/css">
+<link rel="next" href="introduction.html">
+</head>
+<body>
+<table width="100%" height="48" border="0" cellspacing="2">
+  <tr>
+    <td><img src="doc/theme/c%2B%2Bboost.gif">
+    </td>
+    <td width="85%">
+      <font size="6" face="Verdana, Arial, Helvetica, sans-serif"><b>Pyste Documentation</b></font>
+    </td>
+  </tr>
+</table>
+<br>
+<table width="80%" border="0" align="center">
+  <tr>
+    <td class="toc_title">Table of contents</td>
+  </tr>
+  <tr>
+    <td class="toc_cells_L0">
+        <a href="doc/introduction.html">Introduction</a>
+    </td>
+  </tr>
+  <tr>
+    <td class="toc_cells_L0">
+        <a href="doc/running_pyste.html">Running Pyste</a>
+    </td>
+  </tr>
+  <tr>
+    <td class="toc_cells_L0">
+        <a href="doc/the_interface_files.html">The Interface Files</a>
+    </td>
+  </tr>
+  <tr>
+    <td class="toc_cells_L1">
+        <a href="doc/renaming_and_excluding.html">Renaming and Excluding</a>
+    </td>
+  </tr>
+  <tr>
+    <td class="toc_cells_L1">
+        <a href="doc/policies.html">Policies</a>
+    </td>
+  </tr>
+  <tr>
+    <td class="toc_cells_L1">
+        <a href="doc/templates.html">Templates</a>
+    </td>
+  </tr>
+  <tr>
+    <td class="toc_cells_L1">
+        <a href="doc/wrappers.html">Wrappers</a>
+    </td>
+  </tr>
+  <tr>
+    <td class="toc_cells_L1">
+        <a href="doc/exporting_an_entire_header.html">Exporting An Entire Header</a>
+    </td>
+  </tr>
+  <tr>
+    <td class="toc_cells_L1">
+        <a href="doc/smart_pointers.html">Smart Pointers</a>
+    </td>
+  </tr>
+  <tr>
+    <td class="toc_cells_L1">
+        <a href="doc/global_variables.html">Global Variables</a>
+    </td>
+  </tr>
+  <tr>
+    <td class="toc_cells_L1">
+        <a href="doc/adding_new_methods.html">Adding New Methods</a>
+    </td>
+  </tr>
+</table>
+<br>
+<hr size="1"><p class="copyright">Copyright &copy; 2003 Bruno da Silva de Oliveira<br>Copyright &copy; 2002-2003 Joel de Guzman<br><br>
+<font size="2">Permission to copy, use, modify, sell and distribute this document
+ is granted provided this copyright notice appears in all copies. This document
+ is provided &quot;as is&quot; without express or implied warranty, and with
+ no claim as to its suitability for any purpose. </font> </p>
+</body>
+</html>

pyste/install/pyste.py

@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+
+from Pyste import pyste
+pyste.main()

pyste/install/setup.py

@@ -0,0 +1,18 @@
+# contributed by Prabhu Ramachandran
+
+from distutils.core import setup
+import sys
+
+setup (name              = "Pyste",
+       version           = "0.9.10",
+       description       = "Pyste - Python Semi-Automatic Exporter",
+       maintainer        = "Bruno da Silva de Oliveira",
+       maintainer_email  = "nicodemus@globalite.com.br",
+       licence           = "Boost License",
+       long_description  = "Pyste is a Boost.Python code generator",
+       url               = "http://www.boost.org/libs/python/pyste/index.html",
+       platforms         = ['Any'],
+       packages          = ['Pyste'],
+       scripts           = ['pyste.py'],
+       package_dir       = {'Pyste': '../src/Pyste'},
+       )

pyste/src/Pyste/.cvsignore

@@ -0,0 +1 @@
+*.pyc

pyste/src/Pyste/ClassExporter.py

@@ -0,0 +1,892 @@
+import exporters
+from Exporter import Exporter
+from declarations import *
+from settings import *
+from policies import *
+from SingleCodeUnit import SingleCodeUnit
+from EnumExporter import EnumExporter
+from utils import makeid, enumerate
+import copy
+import exporterutils
+import re
+
+#==============================================================================
+# ClassExporter
+#==============================================================================
+class ClassExporter(Exporter):
+    'Generates boost.python code to export a class declaration'
+ 
+    def __init__(self, info, parser_tail=None):
+        Exporter.__init__(self, info, parser_tail)
+        # sections of code
+        self.sections = {}
+        # template: each item in the list is an item into the class_<...> 
+        # section.
+        self.sections['template'] = []  
+        # constructor: each item in the list is a parameter to the class_ 
+        # constructor, like class_<C>(...)
+        self.sections['constructor'] = []
+        # inside: everything within the class_<> statement        
+        self.sections['inside'] = []        
+        # scope: items outside the class statement but within its scope.
+        # scope* s = new scope(class<>());
+        # ...
+        # delete s;
+        self.sections['scope'] = []
+        # declarations: outside the BOOST_PYTHON_MODULE macro
+        self.sections['declaration'] = []
+        self.sections['declaration-outside'] = []
+        self.sections['include'] = []
+        # a list of Constructor instances
+        self.constructors = []
+        # a list of code units, generated by nested declarations
+        self.nested_codeunits = []
+
+
+    def ScopeName(self):
+        return makeid(self.class_.FullName()) + '_scope'
+
+
+    def Name(self):
+        return self.info.name
+
+
+    def SetDeclarations(self, declarations):
+        Exporter.SetDeclarations(self, declarations)
+        if self.declarations:
+            decl = self.GetDeclaration(self.info.name)
+            if isinstance(decl, Typedef):
+                self.class_ = self.GetDeclaration(decl.type.name)
+                if not self.info.rename:
+                    self.info.rename = decl.name
+            else:
+                self.class_ = decl
+            self.class_ = copy.deepcopy(self.class_)
+        else:
+            self.class_ = None
+        
+        
+    def ClassBases(self):
+        all_bases = []       
+        for level in self.class_.hierarchy:
+            for base in level:
+                all_bases.append(base)
+        return [self.GetDeclaration(x.name) for x in all_bases] 
+
+    
+    def Order(self):
+        '''Return the TOTAL number of bases that this class has, including the
+        bases' bases.  Do this because base classes must be instantialized
+        before the derived classes in the module definition.  
+        '''
+        num_bases = len(self.ClassBases())
+        return num_bases, self.class_.FullName()
+        
+    
+    def Export(self, codeunit, exported_names):
+        self.InheritMethods(exported_names)
+        self.MakeNonVirtual()
+        if not self.info.exclude:
+            self.ExportBasics()
+            self.ExportBases(exported_names)
+            self.ExportConstructors()
+            self.ExportVariables()
+            self.ExportVirtualMethods(codeunit)
+            self.ExportMethods()
+            self.ExportOperators()
+            self.ExportNestedClasses(exported_names)
+            self.ExportNestedEnums(exported_names)
+            self.ExportSmartPointer()
+            self.ExportOpaquePointerPolicies()
+            self.Write(codeunit)
+            exported_names[self.Name()] = 1
+
+
+    def InheritMethods(self, exported_names):
+        '''Go up in the class hierarchy looking for classes that were not
+        exported yet, and then add their public members to this classes
+        members, as if they were members of this class. This allows the user to
+        just export one type and automatically get all the members from the
+        base classes.
+        '''
+        valid_members = (Method, ClassVariable, NestedClass, ClassEnumeration)
+        fullnames = [x.FullName() for x in self.class_]
+        pointers = [x.PointerDeclaration(True) for x in self.class_ if isinstance(x, Method)]
+        fullnames = dict([(x, None) for x in fullnames])
+        pointers = dict([(x, None) for x in pointers])
+        for level in self.class_.hierarchy:
+            level_exported = False
+            for base in level:
+                base = self.GetDeclaration(base.name)
+                if base.FullName() not in exported_names:
+                    for member in base:
+                        if type(member) in valid_members:
+                            member_copy = copy.deepcopy(member)   
+                            member_copy.class_ = self.class_.FullName()
+                            if isinstance(member_copy, Method):
+                                pointer = member_copy.PointerDeclaration(True)
+                                if pointer not in pointers:
+                                    self.class_.AddMember(member)
+                                    pointers[pointer] = None
+                            elif member_copy.FullName() not in fullnames:
+                                self.class_.AddMember(member)        
+                else:
+                    level_exported = True
+            if level_exported:
+                break
+        def IsValid(member):
+            return isinstance(member, valid_members) and member.visibility == Scope.public
+        self.public_members = [x for x in self.class_ if IsValid(x)] 
+
+
+    def Write(self, codeunit):
+        indent = self.INDENT
+        boost_ns = namespaces.python
+        pyste_ns = namespaces.pyste
+        code = ''
+        # begin a scope for this class if needed
+        nested_codeunits = self.nested_codeunits
+        needs_scope = self.sections['scope'] or nested_codeunits
+        if needs_scope:
+            scope_name = self.ScopeName()
+            code += indent + boost_ns + 'scope* %s = new %sscope(\n' %\
+                (scope_name, boost_ns)
+        # export the template section
+        template_params = ', '.join(self.sections['template'])
+        code += indent + boost_ns + 'class_< %s >' % template_params
+        # export the constructor section
+        constructor_params = ', '.join(self.sections['constructor'])
+        code += '(%s)\n' % constructor_params
+        # export the inside section
+        in_indent = indent*2
+        for line in self.sections['inside']:
+            code += in_indent + line + '\n' 
+        # write the scope section and end it
+        if not needs_scope:
+            code += indent + ';\n'
+        else:
+            code += indent + ');\n'
+            for line in self.sections['scope']:
+                code += indent + line + '\n'
+            # write the contents of the nested classes
+            for nested_unit in nested_codeunits:
+                code += '\n' + nested_unit.Section('module')
+            # close the scope
+            code += indent + 'delete %s;\n' % scope_name
+            
+        # write the code to the module section in the codeunit        
+        codeunit.Write('module', code + '\n')
+        
+        # write the declarations to the codeunit        
+        declarations = '\n'.join(self.sections['declaration'])
+        for nested_unit in nested_codeunits:
+            declarations += nested_unit.Section('declaration')
+        if declarations:
+            codeunit.Write('declaration', declarations + '\n')
+        declarations_outside = '\n'.join(self.sections['declaration-outside'])
+        if declarations_outside:
+            codeunit.Write('declaration-outside', declarations_outside + '\n')
+
+        # write the includes to the codeunit
+        includes = '\n'.join(self.sections['include'])
+        for nested_unit in nested_codeunits:
+            includes += nested_unit.Section('include')
+        if includes:
+            codeunit.Write('include', includes)
+
+
+    def Add(self, section, item):
+        'Add the item into the corresponding section'
+        self.sections[section].append(item)
+
+        
+    def ExportBasics(self):
+        '''Export the name of the class and its class_ statement.'''
+        class_name = self.class_.FullName()
+        self.Add('template', class_name)
+        name = self.info.rename or self.class_.name
+        self.Add('constructor', '"%s"' % name)
+        
+        
+    def ExportBases(self, exported_names):
+        'Expose the bases of the class into the template section'        
+        hierarchy = self.class_.hierarchy
+        exported = []
+        for level in hierarchy:
+            for base in level:
+                if base.visibility == Scope.public and base.name in exported_names:
+                    exported.append(base.name)
+            if exported:
+                break
+        if exported:
+            code = namespaces.python + 'bases< %s > ' %  (', '.join(exported))
+            self.Add('template', code)         
+
+
+    def ExportConstructors(self):
+        '''Exports all the public contructors of the class, plus indicates if the 
+        class is noncopyable.
+        '''
+        py_ns = namespaces.python
+        indent = self.INDENT
+        
+        def init_code(cons):
+            'return the init<>() code for the given contructor'
+            param_list = [p.FullName() for p in cons.parameters]
+            min_params_list = param_list[:cons.minArgs]
+            max_params_list = param_list[cons.minArgs:]
+            min_params = ', '.join(min_params_list)
+            max_params = ', '.join(max_params_list)
+            init = py_ns + 'init< '
+            init += min_params
+            if max_params:
+                if min_params:
+                    init += ', '
+                init += py_ns + ('optional< %s >' % max_params)
+            init += ' >()'    
+            return init
+        
+        constructors = [x for x in self.public_members if isinstance(x, Constructor)]
+        self.constructors = constructors[:]
+        # don't export the copy constructor if the class is abstract
+        if self.class_.abstract:
+            for cons in constructors:
+                if cons.IsCopy():
+                    constructors.remove(cons)
+                    break
+        if not constructors:
+            # declare no_init
+            self.Add('constructor', py_ns + 'no_init') 
+        else:
+            # write the constructor with less parameters to the constructor section
+            smaller = None
+            for cons in constructors:
+                if smaller is None or len(cons.parameters) < len(smaller.parameters):
+                    smaller = cons
+            assert smaller is not None
+            self.Add('constructor', init_code(smaller))
+            constructors.remove(smaller)
+            # write the rest to the inside section, using def()
+            for cons in constructors:
+                code = '.def(%s)' % init_code(cons) 
+                self.Add('inside', code)
+        # check if the class is copyable
+        if not self.class_.HasCopyConstructor() or self.class_.abstract:
+            self.Add('template', namespaces.boost + 'noncopyable')
+            
+        
+    def ExportVariables(self):
+        'Export the variables of the class, both static and simple variables'
+        vars = [x for x in self.public_members if isinstance(x, Variable)]
+        for var in vars:
+            if self.info[var.name].exclude: 
+                continue
+            name = self.info[var.name].rename or var.name
+            fullname = var.FullName() 
+            if var.type.const:
+                def_ = '.def_readonly'
+            else:
+                def_ = '.def_readwrite'
+            code = '%s("%s", &%s)' % (def_, name, fullname)
+            self.Add('inside', code)
+
+    
+    def OverloadName(self, method):
+        'Returns the name of the overloads struct for the given method'
+        name = makeid(method.FullName())
+        overloads = '_overloads_%i_%i' % (method.minArgs, method.maxArgs)    
+        return name + overloads
+
+    
+    def GetAddedMethods(self):
+        added_methods = self.info.__added__
+        result = []
+        if added_methods:
+            for name, rename in added_methods:
+                decl = self.GetDeclaration(name)
+                self.info[name].rename = rename
+                result.append(decl)
+        return result
+
+                
+    def ExportMethods(self):
+        '''Export all the non-virtual methods of this class, plus any function
+        that is to be exported as a method'''
+            
+        declared = {}
+        def DeclareOverloads(m):
+            'Declares the macro for the generation of the overloads'
+            if (isinstance(m, Method) and m.static) or type(m) == Function:
+                func = m.FullName()
+                macro = 'BOOST_PYTHON_FUNCTION_OVERLOADS'
+            else:
+                func = m.name
+                macro = 'BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS' 
+            code = '%s(%s, %s, %i, %i)\n' % (macro, self.OverloadName(m), func, m.minArgs, m.maxArgs)
+            if code not in declared:
+                declared[code] = True
+                self.Add('declaration', code)
+
+
+        def Pointer(m):
+            'returns the correct pointer declaration for the method m'
+            # check if this method has a wrapper set for him
+            wrapper = self.info[m.name].wrapper
+            if wrapper:
+                return '&' + wrapper.FullName()
+            else:
+                return m.PointerDeclaration() 
+
+        def IsExportable(m):
+            'Returns true if the given method is exportable by this routine'
+            ignore = (Constructor, ClassOperator, Destructor)
+            return isinstance(m, Function) and not isinstance(m, ignore) and not m.virtual        
+        
+        methods = [x for x in self.public_members if IsExportable(x)]        
+        methods.extend(self.GetAddedMethods())
+        
+        staticmethods = {}
+        
+        for method in methods:
+            method_info = self.info[method.name]
+            
+            # skip this method if it was excluded by the user
+            if method_info.exclude:
+                continue 
+
+            # rename the method if the user requested
+            name = method_info.rename or method.name
+            
+            # warn the user if this method needs a policy and doesn't have one
+            method_info.policy = exporterutils.HandlePolicy(method, method_info.policy)
+            
+            # check for policies
+            policy = method_info.policy or ''
+            if policy:
+                policy = ', %s%s()' % (namespaces.python, policy.Code())
+            # check for overloads
+            overload = ''
+            if method.minArgs != method.maxArgs:
+                # add the overloads for this method
+                DeclareOverloads(method)
+                overload_name = self.OverloadName(method)
+                overload = ', %s%s()' % (namespaces.pyste, overload_name)
+        
+            # build the .def string to export the method
+            pointer = Pointer(method)
+            code = '.def("%s", %s' % (name, pointer)
+            code += policy
+            code += overload
+            code += ')'
+            self.Add('inside', code)
+            # static method
+            if isinstance(method, Method) and method.static:
+                staticmethods[name] = 1
+            # add wrapper code if this method has one
+            wrapper = method_info.wrapper
+            if wrapper and wrapper.code:
+                self.Add('declaration-outside', wrapper.code)
+        
+        # export staticmethod statements
+        for name in staticmethods:
+            code = '.staticmethod("%s")' % name
+            self.Add('inside', code) 
+
+
+                
+    def MakeNonVirtual(self):
+        '''Make all methods that the user indicated to no_override no more virtual, delegating their
+        export to the ExportMethods routine'''
+        for member in self.class_:
+            if type(member) == Method and member.virtual:
+                member.virtual = not self.info[member.name].no_override 
+
+
+    def ExportVirtualMethods(self, codeunit):        
+        # check if this class has any virtual methods
+        has_virtual_methods = False
+        for member in self.class_:
+            if type(member) == Method and member.virtual:
+                has_virtual_methods = True
+                break
+
+        holder = self.info.holder
+        if has_virtual_methods:
+            generator = _VirtualWrapperGenerator(self.class_, self.ClassBases(), self.info, codeunit)
+            if holder:
+                self.Add('template', holder(generator.FullName()))
+            else:
+                self.Add('template', generator.FullName())
+            for definition in generator.GenerateDefinitions():
+                self.Add('inside', definition)
+            self.Add('declaration', generator.GenerateVirtualWrapper(self.INDENT))
+        else:
+            if holder:
+                self.Add('template', holder(self.class_.FullName()))
+
+    # operators natively supported by boost
+    BOOST_SUPPORTED_OPERATORS = '+ - * / % ^ & ! ~ | < > == != <= >= << >> && || += -='\
+        '*= /= %= ^= &= |= <<= >>='.split()
+    # create a map for faster lookup
+    BOOST_SUPPORTED_OPERATORS = dict(zip(BOOST_SUPPORTED_OPERATORS, range(len(BOOST_SUPPORTED_OPERATORS))))
+
+    # a dict of operators that are not directly supported by boost, but can be exposed
+    # simply as a function with a special name
+    BOOST_RENAME_OPERATORS = {
+        '()' : '__call__',
+    }
+
+    # converters which have a special name in python
+    # it's a map of a regular expression of the converter's result to the
+    # appropriate python name
+    SPECIAL_CONVERTERS = {
+        re.compile(r'(const)?\s*double$') : '__float__',
+        re.compile(r'(const)?\s*float$') : '__float__',
+        re.compile(r'(const)?\s*int$') : '__int__',
+        re.compile(r'(const)?\s*long$') : '__long__',
+        re.compile(r'(const)?\s*char\s*\*?$') : '__str__',
+        re.compile(r'(const)?.*::basic_string<.*>\s*(\*|\&)?$') : '__str__',
+    }
+        
+    
+    def ExportOperators(self):
+        'Export all member operators and free operators related to this class'
+        
+        def GetFreeOperators():
+            'Get all the free (global) operators related to this class'
+            operators = []
+            for decl in self.declarations:
+                if isinstance(decl, Operator):
+                    # check if one of the params is this class
+                    for param in decl.parameters:
+                        if param.name == self.class_.FullName():
+                            operators.append(decl)
+                            break
+            return operators
+
+        def GetOperand(param):
+            'Returns the operand of this parameter (either "self", or "other<type>")'
+            if param.name == self.class_.FullName():
+                return namespaces.python + 'self'
+            else:
+                return namespaces.python + ('other< %s >()' % param.name)
+
+
+        def HandleSpecialOperator(operator):
+            # gatter information about the operator and its parameters
+            result_name = operator.result.name                        
+            param1_name = ''
+            if operator.parameters:
+                param1_name = operator.parameters[0].name
+                
+            # check for str
+            ostream = 'basic_ostream'
+            is_str = result_name.find(ostream) != -1 and param1_name.find(ostream) != -1
+            if is_str:
+                namespace = namespaces.python + 'self_ns::'
+                self_ = namespaces.python + 'self'
+                return '.def(%sstr(%s))' % (namespace, self_)
+
+            # is not a special operator
+            return None
+                
+
+        
+        frees = GetFreeOperators()
+        members = [x for x in self.public_members if type(x) == ClassOperator]
+        all_operators = frees + members
+        operators = [x for x in all_operators if not self.info['operator'][x.name].exclude]
+        
+        for operator in operators:
+            # gatter information about the operator, for use later
+            wrapper = self.info['operator'][operator.name].wrapper
+            if wrapper:
+                pointer = '&' + wrapper.FullName()
+                if wrapper.code:
+                    self.Add('declaration-outside', wrapper.code)
+            else:
+                pointer = operator.PointerDeclaration()                 
+            rename = self.info['operator'][operator.name].rename
+
+            # check if this operator will be exported as a method
+            export_as_method = wrapper or rename or operator.name in self.BOOST_RENAME_OPERATORS
+            
+            # check if this operator has a special representation in boost
+            special_code = HandleSpecialOperator(operator)
+            has_special_representation = special_code is not None
+            
+            if export_as_method:
+                # export this operator as a normal method, renaming or using the given wrapper
+                if not rename:
+                    if wrapper:
+                        rename = wrapper.name
+                    else:
+                        rename = self.BOOST_RENAME_OPERATORS[operator.name]
+                policy = ''
+                policy_obj = self.info['operator'][operator.name].policy
+                if policy_obj:
+                    policy = ', %s()' % policy_obj.Code() 
+                self.Add('inside', '.def("%s", %s%s)' % (rename, pointer, policy))
+            
+            elif has_special_representation:
+                self.Add('inside', special_code)
+                
+            elif operator.name in self.BOOST_SUPPORTED_OPERATORS:
+                # export this operator using boost's facilities
+                op = operator
+                is_unary = isinstance(op, Operator) and len(op.parameters) == 1 or\
+                           isinstance(op, ClassOperator) and len(op.parameters) == 0
+                if is_unary:
+                    self.Add('inside', '.def( %s%sself )' % \
+                        (operator.name, namespaces.python))
+                else:
+                    # binary operator
+                    if len(operator.parameters) == 2:
+                        left_operand = GetOperand(operator.parameters[0])
+                        right_operand = GetOperand(operator.parameters[1])
+                    else:
+                        left_operand = namespaces.python + 'self'
+                        right_operand = GetOperand(operator.parameters[0])
+                    self.Add('inside', '.def( %s %s %s )' % \
+                        (left_operand, operator.name, right_operand))
+
+        # export the converters.
+        # export them as simple functions with a pre-determined name
+
+        converters = [x for x in self.public_members if type(x) == ConverterOperator]
+                
+        def ConverterMethodName(converter):
+            result_fullname = converter.result.FullName()
+            result_name = converter.result.name
+            for regex, method_name in self.SPECIAL_CONVERTERS.items():
+                if regex.match(result_fullname):
+                    return method_name
+            else:
+                # extract the last name from the full name
+                result_name = makeid(result_name)
+                return 'to_' + result_name
+            
+        for converter in converters:
+            info = self.info['operator'][converter.result.FullName()]
+            # check if this operator should be excluded
+            if info.exclude:
+                continue
+            
+            special_code = HandleSpecialOperator(converter)
+            if info.rename or not special_code:
+                # export as method
+                name = info.rename or ConverterMethodName(converter)
+                pointer = converter.PointerDeclaration()
+                policy_code = ''
+                if info.policy:
+                    policy_code = ', %s()' % info.policy.Code()
+                self.Add('inside', '.def("%s", %s%s)' % (name, pointer, policy_code))
+                    
+            elif special_code:
+                self.Add('inside', special_code)
+
+
+
+    def ExportNestedClasses(self, exported_names):
+        nested_classes = [x for x in self.public_members if isinstance(x, NestedClass)]
+        for nested_class in nested_classes:
+            nested_info = self.info[nested_class.name]
+            nested_info.include = self.info.include
+            nested_info.name = nested_class.FullName()
+            exporter = ClassExporter(nested_info)
+            exporter.SetDeclarations(self.declarations)
+            codeunit = SingleCodeUnit(None, None)
+            exporter.Export(codeunit, exported_names)
+            self.nested_codeunits.append(codeunit)
+
+
+    def ExportNestedEnums(self, exported_names):
+        nested_enums = [x for x in self.public_members if isinstance(x, ClassEnumeration)]
+        for enum in nested_enums:
+            enum_info = self.info[enum.name]
+            enum_info.include = self.info.include
+            enum_info.name = enum.FullName()
+            exporter = EnumExporter(enum_info)
+            exporter.SetDeclarations(self.declarations)
+            codeunit = SingleCodeUnit(None, None)
+            exporter.Export(codeunit, exported_names)
+            self.nested_codeunits.append(codeunit)
+
+
+    def ExportSmartPointer(self):
+        smart_ptr = self.info.smart_ptr
+        if smart_ptr:
+            class_name = self.class_.FullName()
+            smart_ptr = smart_ptr % class_name
+            self.Add('scope', '%sregister_ptr_to_python< %s >();' % (namespaces.python, smart_ptr))
+            
+
+    def ExportOpaquePointerPolicies(self):
+        # check all methods for 'return_opaque_pointer' policies
+        methods = [x for x in self.public_members if isinstance(x, Method)]
+        for method in methods:
+            return_opaque_policy = return_value_policy(return_opaque_pointer)
+            if self.info[method.name].policy == return_opaque_policy:
+                macro = exporterutils.EspecializeTypeID(method.result.name) 
+                if macro:
+                    self.Add('declaration-outside', macro)
+
+
+#==============================================================================
+# Virtual Wrapper utils
+#==============================================================================
+
+def _ParamsInfo(m, count=None):
+    if count is None:
+        count = len(m.parameters)
+    param_names = ['p%i' % i for i in range(count)]
+    param_types = [x.FullName() for x in m.parameters[:count]]
+    params = ['%s %s' % (t, n) for t, n in zip(param_types, param_names)]
+    #for i, p in enumerate(m.parameters[:count]):
+    #    if p.default is not None:
+    #        #params[i] += '=%s' % p.default
+    #        params[i] += '=%s' % (p.name + '()')
+    params = ', '.join(params) 
+    return params, param_names, param_types
+
+            
+class _VirtualWrapperGenerator(object):
+    'Generates code to export the virtual methods of the given class'
+
+    def __init__(self, class_, bases, info, codeunit):
+        self.class_ = copy.deepcopy(class_)
+        self.bases = bases[:]
+        self.info = info
+        self.wrapper_name = makeid(class_.FullName()) + '_Wrapper'
+        self.virtual_methods = None
+        self._method_count = {}
+        self.codeunit = codeunit
+        self.GenerateVirtualMethods()
+
+
+    def DefaultImplementationNames(self, method):
+        '''Returns a list of default implementations for this method, one for each
+        number of default arguments. Always returns at least one name, and return from 
+        the one with most arguments to the one with the least.
+        '''
+        base_name = 'default_' + method.name 
+        minArgs = method.minArgs
+        maxArgs = method.maxArgs
+        if minArgs == maxArgs:
+            return [base_name]
+        else:
+            return [base_name + ('_%i' % i) for i in range(minArgs, maxArgs+1)]                
+
+
+    def Declaration(self, method, indent):
+        '''Returns a string with the declarations of the virtual wrapper and
+        its default implementations. This string must be put inside the Wrapper
+        body.        
+        '''
+        pyste = namespaces.pyste
+        python = namespaces.python
+        rename = self.info[method.name].rename or method.name
+        result = method.result.FullName()
+        return_str = 'return '
+        if result == 'void':
+            return_str = ''
+        params, param_names, param_types = _ParamsInfo(method)
+        constantness = ''
+        if method.const:
+            constantness = ' const'
+        
+        # call_method callback
+        decl  = indent + '%s %s(%s)%s%s {\n' % (result, method.name, params, constantness, method.Exceptions())
+        param_names_str = ', '.join(param_names)
+        if param_names_str:
+            param_names_str = ', ' + param_names_str
+        decl += indent*2 + '%s%scall_method< %s >(self, "%s"%s);\n' %\
+            (return_str, python, result, rename, param_names_str)
+        decl += indent + '}\n'
+
+        # default implementations (with overloading)
+        def DefaultImpl(method, param_names):
+            'Return the body of a default implementation wrapper'
+            indent2 = indent * 2
+            wrapper = self.info[method.name].wrapper
+            if not wrapper:
+                # return the default implementation of the class
+                return indent2 + '%s%s(%s);\n' % \
+                    (return_str, method.FullName(), ', '.join(param_names)) 
+            else:
+                if wrapper.code:
+                    self.codeunit.Write('declaration-outside', wrapper.code) 
+                # return a call for the wrapper
+                params = ', '.join(['this'] + param_names)
+                return indent2 + '%s%s(%s);\n' % (return_str, wrapper.FullName(), params)
+                
+        if not method.abstract and method.visibility != Scope.private:
+            minArgs = method.minArgs
+            maxArgs = method.maxArgs
+            impl_names = self.DefaultImplementationNames(method)
+            for impl_name, argNum in zip(impl_names, range(minArgs, maxArgs+1)): 
+                params, param_names, param_types = _ParamsInfo(method, argNum)            
+                decl += '\n'
+                decl += indent + '%s %s(%s)%s {\n' % (result, impl_name, params, constantness)
+                decl += DefaultImpl(method, param_names)
+                decl += indent + '}\n'                
+        return decl
+            
+
+    def MethodDefinition(self, method):
+        '''Returns a list of lines, which should be put inside the class_
+        statement to export this method.'''
+        # dont define abstract methods
+        pyste = namespaces.pyste
+        rename = self.info[method.name].rename or method.name
+        default_names = self.DefaultImplementationNames(method)
+        class_name = self.class_.FullName()
+        wrapper_name = pyste + self.wrapper_name
+        result = method.result.FullName()
+        is_method_unique = method.is_unique
+        constantness = ''
+        if method.const:
+            constantness = ' const'
+        
+        # create a list of default-impl pointers
+        minArgs = method.minArgs
+        maxArgs = method.maxArgs 
+        if method.abstract:
+            default_pointers = []
+        elif is_method_unique:
+            default_pointers = ['&%s::%s' % (wrapper_name, x) for x in default_names]
+        else:
+            default_pointers = []
+            for impl_name, argNum in zip(default_names, range(minArgs, maxArgs+1)):
+                param_list = [x.FullName() for x in method.parameters[:argNum]]
+                params = ', '.join(param_list)             
+                signature = '%s (%s::*)(%s)%s' % (result, wrapper_name, params, constantness)
+                default_pointer = '(%s)&%s::%s' % (signature, wrapper_name, impl_name)
+                default_pointers.append(default_pointer)
+            
+        # get the pointer of the method
+        pointer = method.PointerDeclaration()
+        if method.abstract:
+            pointer = namespaces.python + ('pure_virtual(%s)' % pointer)
+
+        # Add policy to overloaded methods also
+        policy = self.info[method.name].policy or ''
+        if policy:
+            policy = ', %s%s()' % (namespaces.python, policy.Code())
+
+        # generate the defs
+        definitions = []
+        # basic def
+        if default_pointers:
+            definitions.append('.def("%s", %s, %s%s)' % (rename, pointer, default_pointers[-1], policy))
+            for default_pointer in default_pointers[:-1]:
+                definitions.append('.def("%s", %s%s)' % (rename, default_pointer, policy))
+        else:
+            definitions.append('.def("%s", %s%s)' % (rename, pointer, policy))
+        return definitions
+
+    
+    def FullName(self):
+        return namespaces.pyste + self.wrapper_name
+
+
+    def GenerateVirtualMethods(self):
+        '''To correctly export all virtual methods, we must also make wrappers
+        for the virtual methods of the bases of this class, as if the methods
+        were from this class itself.
+        This method creates the instance variable self.virtual_methods.
+        '''        
+        def IsVirtual(m):
+            if type(m) is Method:
+                pure_virtual = m.abstract and m.virtual
+                virtual = m.virtual and m.visibility != Scope.private
+                return virtual or pure_virtual
+            else:
+                return False
+                
+        # extract the virtual methods, avoiding duplications. The duplication
+        # must take in account the full signature without the class name, so 
+        # that inherited members are correctly excluded if the subclass overrides
+        # them.
+        def MethodSig(method):
+            if method.const:
+                const = ' const'
+            else:
+                const = ''
+            if method.result:
+                result = method.result.FullName()
+            else:
+                result = ''
+            params = ', '.join([x.FullName() for x in method.parameters]) 
+            return '%s %s(%s)%s%s' % (
+                result, method.name, params, const, method.Exceptions())  
+
+        already_added = {}
+        self.virtual_methods = []
+        for member in self.class_:
+            if IsVirtual(member):
+                already_added[MethodSig(member)] = None
+                self.virtual_methods.append(member)
+
+        for base in self.bases:
+            base_methods = [copy.deepcopy(x) for x in base if IsVirtual(x)]
+            for base_method in base_methods:
+                self.class_.AddMember(base_method)
+                
+        all_methods = [x for x in self.class_ if IsVirtual(x)]
+        
+        for member in all_methods:
+            sig = MethodSig(member)
+            if IsVirtual(member) and not sig in already_added:
+                self.virtual_methods.append(member)
+                already_added[sig] = 0
+            
+    
+    def Constructors(self):
+        return self.class_.Constructors(publics_only=True)
+    
+        
+    def GenerateDefinitions(self):
+        defs = []
+        for method in self.virtual_methods:
+            exclude = self.info[method.name].exclude
+            # generate definitions only for public methods and non-abstract methods
+            if method.visibility == Scope.public and not exclude:
+                defs.extend(self.MethodDefinition(method))
+        return defs
+
+        
+    def GenerateVirtualWrapper(self, indent):
+        'Return the wrapper for this class'
+        
+        # generate the class code
+        class_name = self.class_.FullName()
+        code = 'struct %s: %s\n' % (self.wrapper_name, class_name)
+        code += '{\n'
+        # generate constructors (with the overloads for each one)
+        for cons in self.Constructors(): # only public constructors
+            minArgs = cons.minArgs
+            maxArgs = cons.maxArgs
+            # from the min number of arguments to the max number, generate
+            # all version of the given constructor
+            cons_code = ''
+            for argNum in range(minArgs, maxArgs+1):
+                params, param_names, param_types = _ParamsInfo(cons, argNum)
+                if params:
+                    params = ', ' + params
+                cons_code += indent + '%s(PyObject* self_%s):\n' % \
+                    (self.wrapper_name, params)
+                cons_code += indent*2 + '%s(%s), self(self_) {}\n\n' % \
+                    (class_name, ', '.join(param_names))
+            code += cons_code
+        # generate the body
+        body = []
+        for method in self.virtual_methods:
+            if not self.info[method.name].exclude:
+                body.append(self.Declaration(method, indent))            
+        body = '\n'.join(body) 
+        code += body + '\n'
+        # add the self member
+        code += indent + 'PyObject* self;\n'
+        code += '};\n'
+        return code 

pyste/src/Pyste/CodeExporter.py

@@ -0,0 +1,21 @@
+from Exporter import Exporter
+
+#==============================================================================
+# CodeExporter
+#==============================================================================
+class CodeExporter(Exporter):
+
+    def __init__(self, info):
+        Exporter.__init__(self, info)
+
+
+    def Name(self):
+        return self.info.code
+
+
+    def Export(self, codeunit, exported_names):
+        codeunit.Write(self.info.section, self.info.code)        
+
+
+    def WriteInclude(self, codeunit):
+        pass

pyste/src/Pyste/CppParser.py

@@ -0,0 +1,233 @@
+from GCCXMLParser import ParseDeclarations
+import tempfile
+import shutil
+import os
+import sys
+import os.path
+import settings
+import shutil
+import shelve
+from cPickle import dump, load
+
+#==============================================================================
+# exceptions
+#==============================================================================
+class CppParserError(Exception): pass
+
+#==============================================================================
+# CppParser
+#==============================================================================
+class CppParser:
+    'Parses a header file and returns a list of declarations'
+    
+    def __init__(self, includes=None, defines=None, cache_dir=None, version=None):
+        'includes and defines ar the directives given to gcc'
+        if includes is None:
+            includes = []
+        if defines is None:
+            defines = []
+        self.includes = includes
+        self.defines = defines
+        self.version = version
+        #if cache_dir is None:
+        #    cache_dir = tempfile.mktemp()
+        #    self.delete_cache = True
+        #else:
+        #    self.delete_cache = False
+        self.delete_cache = False
+        self.cache_dir = cache_dir
+        self.cache_files = []
+        self.mem_cache = {}
+        # create the cache dir
+        if cache_dir:
+            try:
+                os.makedirs(cache_dir)
+            except OSError: pass  
+
+
+    def __del__(self):
+        self.Close()
+
+        
+    def _IncludeParams(self, filename):
+        includes = self.includes[:]
+        filedir = os.path.dirname(filename)
+        if not filedir:
+            filedir = '.'
+        includes.insert(0, filedir)
+        includes = ['-I "%s"' % self.Unixfy(x) for x in includes]
+        return ' '.join(includes)
+
+
+    def _DefineParams(self):
+        defines = ['-D "%s"' % x for x in self.defines]
+        return ' '.join(defines)
+    
+    
+    def FindHeader(self, header):
+        if os.path.isfile(header):
+            return header
+        for path in self.includes:
+            filename = os.path.join(path, header)  
+            if os.path.isfile(filename):
+                return filename
+        else:
+            name = os.path.basename(header)
+            raise RuntimeError, 'Header file "%s" not found!' % name
+    
+            
+    def AppendTail(self, filename, tail):
+        '''Creates a temporary file, appends the text tail to it, and returns
+        the filename of the file.
+        '''
+        temp = tempfile.mktemp('.h') 
+        shutil.copyfile(filename, temp)
+        f = file(temp, 'a')
+        f.write('\n\n'+tail)
+        f.close()   
+        return temp
+
+
+    def Unixfy(self, path):
+        return path.replace('\\', '/')
+
+
+    def ParseWithGCCXML(self, header, tail):
+        '''Parses the given header using gccxml and GCCXMLParser.
+        '''
+        header = self.FindHeader(header) 
+        if tail:
+            filename = self.AppendTail(header, tail)
+        else:
+            filename = header
+        xmlfile = tempfile.mktemp('.xml')
+        try:            
+            # get the params
+            includes = self._IncludeParams(filename)
+            defines = self._DefineParams()
+            # call gccxml
+            cmd = 'gccxml %s %s %s -fxml=%s'
+            filename = self.Unixfy(filename)
+            xmlfile = self.Unixfy(xmlfile)
+            status = os.system(cmd % (includes, defines, filename, xmlfile))
+            if status != 0 or not os.path.isfile(xmlfile):
+                raise CppParserError, 'Error executing gccxml'
+            # parse the resulting xml
+            declarations = ParseDeclarations(xmlfile)
+            # make the declarations' location to point to the original file
+            if tail:
+                for decl in declarations:
+                    decl_filename = os.path.normpath(os.path.normcase(decl.location[0]))
+                    filename = os.path.normpath(os.path.normcase(filename))
+                    if decl_filename == filename:
+                        decl.location = header, decl.location[1]
+            # return the declarations                         
+            return declarations
+        finally:
+            if settings.DEBUG and os.path.isfile(xmlfile):
+                filename = os.path.basename(header)
+                filename = os.path.splitext(filename)[0] + '.xml'
+                shutil.copy(xmlfile, filename)
+            # delete the temporary files
+            try:
+                os.remove(xmlfile)
+                if tail:
+                    os.remove(filename)
+            except OSError: pass                
+
+            
+    def Parse(self, header, interface, tail=None):
+        '''Parses the given filename related to the given interface and returns
+        the (declarations, headerfile). The header returned is normally the
+        same as the given to this method (except that it is the full path),
+        except if tail is not None: in this case, the header is copied to a temp
+        filename and the tail code is appended to it before being passed on to
+        gccxml.  This temp filename is then returned.
+        '''        
+        if tail is None:
+            tail = ''
+        tail.strip()
+        declarations = self.GetCache(header, interface, tail)
+        if declarations is None:
+            declarations = self.ParseWithGCCXML(header, tail)
+            self.CreateCache(header, interface, tail, declarations)
+        return declarations, header
+
+
+    def CacheFileName(self, interface):
+        interface_name = os.path.basename(interface)
+        cache_file = os.path.splitext(interface_name)[0] + '.pystec'
+        cache_file = os.path.join(self.cache_dir, cache_file) 
+        return cache_file
+        
+
+    def GetCache(self, header, interface, tail):
+        key = (header, interface, tail)
+        # try memory cache first
+        if key in self.mem_cache:
+            return self.mem_cache[key]
+        
+        # get the cache from the disk
+        if self.cache_dir is None:
+            return None 
+        header = self.FindHeader(header) 
+        cache_file = self.CacheFileName(interface)    
+        if os.path.isfile(cache_file):
+            f = file(cache_file, 'rb')
+            try:
+                version = load(f)
+                if version != self.version:
+                    return None
+                cache = load(f)
+                if cache.has_key(key):
+                    self.cache_files.append(cache_file)
+                    return cache[key]
+                else:
+                    return None
+            finally:
+                f.close()
+        else:
+            return None
+
+
+    def CreateCache(self, header, interface, tail, declarations):
+        key = (header, interface, tail)
+        
+        # our memory cache only holds one item
+        self.mem_cache.clear() 
+        self.mem_cache[key] = declarations
+
+        # save the cache in the disk
+        if self.cache_dir is None:
+            return
+        header = self.FindHeader(header) 
+        cache_file = self.CacheFileName(interface)
+        if os.path.isfile(cache_file):
+            f = file(cache_file, 'rb')
+            try:
+                version = load(f)
+                cache = load(f)
+            finally:
+                f.close()
+        else:
+            cache = {}
+        cache[key] = declarations
+        self.cache_files.append(cache_file)
+        f = file(cache_file, 'wb')
+        try:
+            dump(self.version, f, 1)
+            dump(cache, f, 1)
+        finally:
+            f.close()
+        return cache_file 
+
+
+    def Close(self):
+        if self.delete_cache and self.cache_files:
+            for filename in self.cache_files:
+                try:
+                    os.remove(filename)
+                except OSError: 
+                    pass
+            self.cache_files = []
+            shutil.rmtree(self.cache_dir)

pyste/src/Pyste/EnumExporter.py

@@ -0,0 +1,90 @@
+from Exporter import Exporter
+from settings import *
+import utils
+
+#==============================================================================
+# EnumExporter 
+#==============================================================================
+class EnumExporter(Exporter):
+    'Exports enumerators'
+
+    def __init__(self, info):
+        Exporter.__init__(self, info)
+
+
+    def SetDeclarations(self, declarations):
+        Exporter.SetDeclarations(self, declarations)
+        if self.declarations:
+            self.enum = self.GetDeclaration(self.info.name)
+        else:
+            self.enum = None
+
+    TYPE_COUNT = 0
+    
+    def Export(self, codeunit, exported_names):
+        if not self.info.exclude:
+            indent = self.INDENT
+            in_indent = self.INDENT*2
+            rename = self.info.rename or self.enum.name
+            full_name = self.enum.FullName()
+            unnamed_enum = False
+            if rename.startswith('$_') or rename.startswith('._'):
+                unnamed_enum = True
+                self.ExportUniqueInt(codeunit)
+                full_name = namespaces.pyste + 'UniqueInt<%d>' % EnumExporter.TYPE_COUNT
+                EnumExporter.TYPE_COUNT += 1
+                rename = "unnamed"
+            code = indent + namespaces.python
+            code += 'enum_< %s >("%s")\n' % (full_name, rename)
+            for name in self.enum.values:         
+                rename = self.info[name].rename or name
+                value_fullname = self.enum.ValueFullName(name)
+                code += in_indent + '.value("%s", %s)\n' % (rename, value_fullname)
+            if self.info.export_values or unnamed_enum:
+                code += in_indent + '.export_values()\n'
+            code += indent + ';\n\n'
+            codeunit.Write('module', code)
+            exported_names[self.enum.FullName()] = 1
+
+
+    UNIQUE_INT_EXPORTED = False
+    
+    def ExportUniqueInt(self, codeunit):
+        if not EnumExporter.UNIQUE_INT_EXPORTED:
+            write = lambda s: codeunit.Write('declaration', s)
+            write('// Unique type for unnamed enums\n')
+            write('template<int num>\n')
+            write('struct UniqueInt {\n')
+            write('   int v;\n')
+            write('   enum { value=num };\n')
+            write('   UniqueInt(int v_):\n') 
+            write('       v(v_)\n')
+            write('   {}\n')
+            write('   operator int() const\n')
+            write('   { return v; }\n')
+            write('};\n')
+            EnumExporter.UNIQUE_INT_EXPORTED = True
+            
+
+    #def Export(self, codeunit, exported_names):
+    #    if not self.info.exclude:
+    #        indent = self.INDENT
+    #        in_indent = self.INDENT*2
+    #        rename = self.info.rename or self.enum.name
+    #        full_name = self.enum.FullName()
+    #        if rename == "$_0" or rename == '._0':
+    #            full_name = "int"
+    #            rename = "unnamed"
+    #        code = indent + namespaces.python
+    #        code += 'enum_< %s >("%s")\n' % (full_name, rename)
+    #        for name in self.enum.values:         
+    #            rename = self.info[name].rename or name
+    #            value_fullname = self.enum.ValueFullName(name)
+    #            code += in_indent + '.value("%s", %s)\n' % (rename, value_fullname)
+    #        code += indent + ';\n\n'
+    #        codeunit.Write('module', code)
+    #        exported_names[self.Name()] = 1
+
+
+    def Name(self):
+        return self.info.name

pyste/src/Pyste/Exporter.py

@@ -0,0 +1,89 @@
+import os.path
+
+#==============================================================================
+# Exporter
+#==============================================================================
+class Exporter(object):
+    'Base class for objects capable to generate boost.python code.'
+
+    INDENT = ' ' * 4
+    
+    def __init__(self, info, parser_tail=None):
+        self.info = info
+        self.parser_tail = parser_tail
+        self.interface_file = None
+        self.declarations = []
+    
+
+    def Name(self):
+        raise NotImplementedError(self.__class__.__name__)
+
+
+    def Tail(self):
+        return self.parser_tail
+
+        
+    def Parse(self, parser):
+        self.parser = parser
+        header = self.info.include
+        tail = self.parser_tail
+        declarations, parser_header = parser.parse(header, tail)
+        self.parser_header = parser_header
+        self.SetDeclarations(declarations)
+
+
+    def SetParsedHeader(self, parsed_header):
+        self.parser_header = parsed_header 
+
+
+    def SetDeclarations(self, declarations):
+        self.declarations = declarations
+
+        
+    def GenerateCode(self, codeunit, exported_names):
+        self.WriteInclude(codeunit)
+        self.Export(codeunit, exported_names)        
+
+
+    def WriteInclude(self, codeunit):
+        codeunit.Write('include', '#include <%s>\n' % self.info.include)
+        
+        
+    def Export(self, codeunit, exported_names):
+        'subclasses must override this to do the real work'
+        pass
+    
+                    
+    def GetDeclarations(self, fullname):
+        decls = []
+        for decl in self.declarations:
+            if decl.FullName() == fullname:
+                decls.append(decl)
+        if not decls:
+            raise RuntimeError, 'no %s declaration found!' % fullname
+        return decls
+
+
+    def GetDeclaration(self, fullname):
+        decls = self.GetDeclarations(fullname)
+        #assert len(decls) == 1
+        return decls[0]
+
+
+    def Order(self):
+        '''Returns a string that uniquely identifies this instance. All
+        exporters will be sorted by Order before being exported.
+        '''
+        return 0, self.info.name
+
+
+    def Header(self):
+        return self.info.include
+
+
+    def __eq__(self, other):
+        return type(self) is type(other) and self.Name() == other.Name() \
+            and self.interface_file == other.interface_file
+
+    def __ne__(self, other):
+        return not self == other

pyste/src/Pyste/FunctionExporter.py

@@ -0,0 +1,87 @@
+from Exporter import Exporter
+from policies import *
+from declarations import *
+from settings import *
+import utils
+import exporterutils
+
+
+#==============================================================================
+# FunctionExporter
+#==============================================================================
+class FunctionExporter(Exporter):
+    'Generates boost.python code to export the given function.'
+    
+    def __init__(self, info, tail=None):
+        Exporter.__init__(self, info, tail)
+        
+
+    def Export(self, codeunit, exported_names):
+        if not self.info.exclude:
+            decls = self.GetDeclarations(self.info.name)
+            for decl in decls:
+                self.info.policy = exporterutils.HandlePolicy(decl, self.info.policy)
+                self.ExportDeclaration(decl, len(decls) == 1, codeunit)
+                self.ExportOpaquePointer(decl, codeunit)
+            self.GenerateOverloads(decls, codeunit)  
+            exported_names[self.Name()] = 1
+
+
+    def ExportDeclaration(self, decl, unique, codeunit):
+        name = self.info.rename or decl.name
+        defs = namespaces.python + 'def("%s", ' % name
+        wrapper = self.info.wrapper
+        if wrapper:
+            pointer = '&' + wrapper.FullName()
+        else:
+            pointer = decl.PointerDeclaration()
+        defs += pointer            
+        defs += self.PolicyCode()                            
+        overload = self.OverloadName(decl)
+        if overload:
+            defs += ', %s()' % (namespaces.pyste + overload)
+        defs += ');'
+        codeunit.Write('module', self.INDENT + defs + '\n')  
+        # add the code of the wrapper
+        if wrapper and wrapper.code:
+            codeunit.Write('declaration', wrapper.code + '\n')
+            
+
+    def OverloadName(self, decl):
+        if decl.minArgs != decl.maxArgs:
+            return '%s_overloads_%i_%i' % \
+                (decl.name, decl.minArgs, decl.maxArgs)
+        else:
+            return ''
+
+        
+    def GenerateOverloads(self, declarations, codeunit):
+        codes = {}
+        for decl in declarations:
+            overload = self.OverloadName(decl)
+            if overload and overload not in codes:
+                code = 'BOOST_PYTHON_FUNCTION_OVERLOADS(%s, %s, %i, %i)' %\
+                    (overload, decl.FullName(), decl.minArgs, decl.maxArgs)
+                codeunit.Write('declaration', code + '\n')
+                codes[overload] = None
+        
+
+    def PolicyCode(self):
+        policy = self.info.policy
+        if policy is not None:
+            assert isinstance(policy, Policy)
+            return ', %s()' % policy.Code() 
+        else:
+            return ''
+
+
+    def ExportOpaquePointer(self, function, codeunit):
+        if self.info.policy == return_value_policy(return_opaque_pointer):
+            typename = function.result.name
+            macro = exporterutils.EspecializeTypeID(typename)  
+            if macro:
+                codeunit.Write('declaration-outside', macro)
+
+
+    def Name(self):
+        return self.info.name

pyste/src/Pyste/GCCXMLParser.py

@@ -0,0 +1,461 @@
+from declarations import *
+from elementtree.ElementTree import ElementTree
+from xml.parsers.expat import ExpatError
+from copy import deepcopy
+from utils import enumerate
+
+
+#==============================================================================
+# Exceptions
+#==============================================================================
+class InvalidXMLError(Exception): pass
+
+class ParserError(Exception): pass
+
+class InvalidContextError(ParserError): pass
+
+
+#==============================================================================
+# GCCXMLParser
+#==============================================================================
+class GCCXMLParser(object):
+    'Parse a GCC_XML file and extract the top-level declarations.'
+    
+    interested_tags = {'Class':0, 'Function':0, 'Variable':0, 'Enumeration':0}
+    
+    def Parse(self, filename):
+        self.elements = self.GetElementsFromXML(filename)
+        # high level declarations
+        self.declarations = []
+        self._names = {}
+        # parse the elements
+        for id in self.elements:
+            element, decl = self.elements[id]
+            if decl is None: 
+                try:
+                    self.ParseElement(id, element)
+                except InvalidContextError:
+                    pass # ignore those nodes with invalid context 
+                         # (workaround gccxml bug)
+         
+
+    def Declarations(self):
+        return self.declarations
+
+
+    def AddDecl(self, decl):
+        if decl.FullName() in self._names:
+            decl.is_unique= False
+            for d in self.declarations:
+                if d.FullName() == decl.FullName():
+                    d.is_unique = False
+        self._names[decl.FullName()] = 0
+        self.declarations.append(decl)
+
+        
+    def ParseElement(self, id, element):
+        method = 'Parse' + element.tag
+        if hasattr(self, method):
+            func = getattr(self, method)
+            func(id, element)
+        else:
+            self.ParseUnknown(id, element)
+
+            
+    def GetElementsFromXML(self,filename):
+        'Extracts a dictionary of elements from the gcc_xml file.'
+        
+        tree = ElementTree()
+        try:
+            tree.parse(filename)
+        except ExpatError:
+            raise InvalidXMLError, 'Not a XML file: %s' % filename
+
+        root = tree.getroot()
+        if root.tag != 'GCC_XML':
+            raise InvalidXMLError, 'Not a valid GCC_XML file'
+
+        # build a dictionary of id -> element, None
+        elementlist = root.getchildren()
+        elements = {}
+        for element in elementlist:
+            id = element.get('id')
+            if id:
+                elements[id] = element, None
+        return elements
+
+
+    def GetDecl(self, id):
+        if id not in self.elements:
+            if id == '_0':
+                raise InvalidContextError, 'Invalid context found in the xml file.'
+            else: 
+                msg = 'ID not found in elements: %s' % id
+                raise ParserError, msg
+
+        elem, decl = self.elements[id]
+        if decl is None:
+            self.ParseElement(id, elem)
+            elem, decl = self.elements[id]
+            if decl is None:
+                raise ParserError, 'Could not parse element: %s' % elem.tag
+        return decl
+    
+
+    def GetType(self, id):
+        def Check(id, feature):
+            pos = id.find(feature)
+            if pos != -1:
+                id = id[:pos] + id[pos+1:]
+                return True, id
+            else:
+                return False, id
+        const, id = Check(id, 'c')
+        volatile, id = Check(id, 'v')
+        restricted, id = Check(id, 'r')
+        decl = self.GetDecl(id)
+        if isinstance(decl, Type):
+            res = deepcopy(decl)
+            if const:
+                res.const = const
+            if volatile: 
+                res.volatile = volatile
+            if restricted:
+                res.restricted = restricted
+        else:
+            res = Type(decl.FullName(), const)
+            res.volatile = volatile
+            res.restricted = restricted
+        return res            
+        
+                
+    def GetLocation(self, location):
+        file, line = location.split(':')
+        file = self.GetDecl(file)
+        return file, int(line)
+
+        
+    def Update(self, id, decl):
+        element, _ = self.elements[id]
+        self.elements[id] = element, decl
+
+        
+    def ParseUnknown(self, id, element):
+        name = '__Unknown_Element_%s' % id
+        decl = Unknown(name)
+        self.Update(id, decl)
+        
+        
+    def ParseNamespace(self, id, element):
+        namespace = element.get('name')
+        context = element.get('context')
+        if context:
+            outer = self.GetDecl(context)
+            if not outer.endswith('::'):
+                outer += '::'
+            namespace = outer + namespace
+        if namespace.startswith('::'):
+            namespace = namespace[2:]
+        self.Update(id, namespace)
+
+
+    def ParseFile(self, id, element):
+        filename = element.get('name')
+        self.Update(id, filename)
+
+        
+    def ParseVariable(self, id, element):
+        # in gcc_xml, a static Field is declared as a Variable, so we check
+        # this and call the Field parser.
+        context = self.GetDecl(element.get('context'))
+        if isinstance(context, Class):
+            self.ParseField(id, element)
+            elem, decl = self.elements[id]
+            decl.static = True
+        else:
+            namespace = context
+            name = element.get('name')                    
+            type_ = self.GetType(element.get('type'))
+            location = self.GetLocation(element.get('location'))
+            variable = Variable(type_, name, namespace)
+            variable.location = location
+            self.AddDecl(variable)
+            self.Update(id, variable)
+        
+
+    def GetArguments(self, element):
+        args = []
+        for child in element:
+            if child.tag == 'Argument':
+                type = self.GetType(child.get('type'))
+                type.default = child.get('default')                
+                args.append(type)
+        return args
+
+    
+    def GetExceptions(self, exception_list):
+        if exception_list is None:
+            return None
+
+        exceptions = []
+        for t in exception_list.split():
+            exceptions.append(self.GetType(t))
+
+        return exceptions
+
+
+    def ParseFunction(self, id, element, functionType=Function):
+        '''functionType is used because a Operator is identical to a normal 
+        function, only the type of the function changes.'''
+        name = element.get('name')
+        returns = self.GetType(element.get('returns'))
+        namespace = self.GetDecl(element.get('context'))
+        location = self.GetLocation(element.get('location'))
+        params = self.GetArguments(element)
+        incomplete = bool(int(element.get('incomplete', 0)))
+        throws = self.GetExceptions(element.get('throw', None))
+        function = functionType(name, namespace, returns, params, throws) 
+        function.location = location
+        self.AddDecl(function)
+        self.Update(id, function)
+
+
+    def ParseOperatorFunction(self, id, element):
+        self.ParseFunction(id, element, Operator)
+
+        
+    def GetHierarchy(self, bases):       
+        '''Parses the string "bases" from the xml into a list of tuples of Base
+        instances. The first tuple is the most direct inheritance, and then it
+        goes up in the hierarchy. 
+        '''
+
+        if bases is None:
+            return []
+        base_names = bases.split()
+        this_level = []      
+        next_levels = []
+        for base in base_names:
+            # get the visibility
+            split = base.split(':')
+            if len(split) == 2:
+                visib = split[0]
+                base = split[1]
+            else:
+                visib = Scope.public                            
+            decl = self.GetDecl(base) 
+            if not isinstance(decl, Class):
+                # on windows, there are some classes which "bases" points to an
+                # "Unimplemented" tag, but we are not interested in this classes
+                # anyway
+                continue
+            base = Base(decl.FullName(), visib)
+            this_level.append(base)
+            # normalize with the other levels
+            for index, level in enumerate(decl.hierarchy):
+                if index < len(next_levels):
+                    next_levels[index] = next_levels[index] + level
+                else:
+                    next_levels.append(level)
+        hierarchy = []
+        if this_level:
+            hierarchy.append(tuple(this_level))
+        if next_levels:
+            hierarchy.extend(next_levels)
+        return hierarchy
+
+        
+    def GetMembers(self, member_list):
+        # members must be a string with the ids of the members
+        if member_list is None:
+            return []
+        members = []
+        for member in member_list.split():
+            decl = self.GetDecl(member)
+            if type(decl) in Class.ValidMemberTypes():
+                if type(decl) is str:
+                    print decl
+                members.append(decl) 
+        return members
+
+
+    def ParseClass(self, id, element):
+        name = element.get('name')
+        abstract = bool(int(element.get('abstract', '0')))
+        location = self.GetLocation(element.get('location'))
+        context = self.GetDecl(element.get('context'))
+        incomplete = bool(int(element.get('incomplete', 0)))
+        if isinstance(context, str): 
+            class_ = Class(name, context, [], abstract)
+        else:
+            # a nested class
+            visib = element.get('access', Scope.public)
+            class_ = NestedClass(
+                name, context.FullName(), visib, [], abstract)
+        class_.incomplete = incomplete
+        # we have to add the declaration of the class before trying        
+        # to parse its members and bases, to avoid recursion.
+        self.AddDecl(class_)
+        class_.location = location
+        self.Update(id, class_)       
+        # now we can get the members and the bases
+        class_.hierarchy = self.GetHierarchy(element.get('bases'))        
+        if class_.hierarchy:
+            class_.bases = class_.hierarchy[0]
+        members = self.GetMembers(element.get('members'))
+        for member in members:
+            if type(member) is str:
+                print member
+            class_.AddMember(member)
+
+
+    def ParseStruct(self, id, element):
+        self.ParseClass(id, element)
+
+
+    def ParseFundamentalType(self, id, element):
+        name = element.get('name')
+        type_ = FundamentalType(name)
+        self.Update(id, type_)
+
+
+    def ParseArrayType(self, id, element):
+        type = self.GetType(element.get('type'))
+        min = element.get('min')
+        max = element.get('max')
+        array = ArrayType(type.name, type.const, min, max)
+        self.Update(id, array)
+
+        
+    def ParseReferenceType(self, id, element):
+        type = self.GetType(element.get('type'))
+        expand = not isinstance(type, FunctionType)
+        ref = ReferenceType(type.name, type.const, None, expand, type.suffix)
+        self.Update(id, ref)
+        
+        
+    def ParsePointerType(self, id, element):
+        type = self.GetType(element.get('type'))
+        expand = not isinstance(type, FunctionType)
+        ref = PointerType(type.name, type.const, None, expand, type.suffix)
+        self.Update(id, ref)
+        
+        
+    def ParseFunctionType(self, id, element):
+        result = self.GetType(element.get('returns'))
+        args = self.GetArguments(element)
+        func = FunctionType(result, args)
+        self.Update(id, func)
+
+
+    def ParseMethodType(self, id, element):
+        class_ = self.GetDecl(element.get('basetype')).FullName()
+        result = self.GetType(element.get('returns'))
+        args = self.GetArguments(element)
+        method = MethodType(result, args, class_)
+        self.Update(id, method)
+
+        
+    def ParseField(self, id, element):
+        name = element.get('name')
+        visib = element.get('access', Scope.public)
+        classname = self.GetDecl(element.get('context')).FullName()
+        type_ = self.GetType(element.get('type'))
+        static = bool(int(element.get('extern', '0')))
+        location = self.GetLocation(element.get('location'))
+        var = ClassVariable(type_, name, classname, visib, static)
+        var.location = location
+        self.Update(id, var)
+
+
+    def ParseMethod(self, id, element, methodType=Method):
+        name = element.get('name')
+        result = self.GetType(element.get('returns'))
+        classname = self.GetDecl(element.get('context')).FullName()
+        visib = element.get('access', Scope.public)
+        static = bool(int(element.get('static', '0')))
+        virtual = bool(int(element.get('virtual', '0')))
+        abstract = bool(int(element.get('pure_virtual', '0')))
+        const = bool(int(element.get('const', '0')))
+        location = self.GetLocation(element.get('location'))
+        throws = self.GetExceptions(element.get('throw', None)) 
+        params = self.GetArguments(element)
+        method = methodType(
+            name, classname, result, params, visib, virtual, abstract, static, const, throws)
+        method.location = location
+        self.Update(id, method)
+
+
+    def ParseOperatorMethod(self, id, element):
+        self.ParseMethod(id, element, ClassOperator)
+
+        
+    def ParseConstructor(self, id, element):
+        name = element.get('name')
+        visib = element.get('access', Scope.public)
+        classname = self.GetDecl(element.get('context')).FullName()
+        location = self.GetLocation(element.get('location'))
+        params = self.GetArguments(element)
+        ctor = Constructor(name, classname, params, visib)
+        ctor.location = location
+        self.Update(id, ctor)
+
+
+    def ParseDestructor(self, id, element):
+        name = element.get('name')
+        visib = element.get('access', Scope.public)
+        classname = self.GetDecl(element.get('context')).FullName()
+        virtual = bool(int(element.get('virtual', '0')))
+        location = self.GetLocation(element.get('location'))
+        des = Destructor(name, classname, visib, virtual)
+        des.location = location
+        self.Update(id, des)
+
+
+    def ParseConverter(self, id, element):
+        self.ParseMethod(id, element, ConverterOperator)
+
+
+    def ParseTypedef(self, id, element):
+        name = element.get('name')
+        type = self.GetType(element.get('type'))        
+        context = self.GetDecl(element.get('context'))
+        if isinstance(context, Class):
+            context = context.FullName()
+        typedef = Typedef(type, name, context)
+        self.Update(id, typedef)
+        self.AddDecl(typedef)
+
+
+    def ParseEnumeration(self, id, element):
+        name = element.get('name')
+        location = self.GetLocation(element.get('location'))
+        context = self.GetDecl(element.get('context'))
+        incomplete = bool(int(element.get('incomplete', 0))) 
+        if isinstance(context, str):
+            enum = Enumeration(name, context)
+        else:
+            visib = element.get('access', Scope.public)
+            enum = ClassEnumeration(name, context.FullName(), visib)
+        self.AddDecl(enum)
+        enum.location = location
+        for child in element:
+            if child.tag == 'EnumValue':
+                name = child.get('name')
+                value = int(child.get('init'))
+                enum.values[name] = value
+        enum.incomplete = incomplete
+        self.Update(id, enum)
+
+
+
+def ParseDeclarations(filename):
+    'Returns a list of the top declarations found in the gcc_xml file.'
+        
+    parser = GCCXMLParser() 
+    parser.Parse(filename)
+    return parser.Declarations()
+
+
+if __name__ == '__main__':
+    ParseDeclarations(r'D:\Programming\Libraries\boost-cvs\boost\libs\python\pyste\example\test.xml')

pyste/src/Pyste/HeaderExporter.py

@@ -0,0 +1,76 @@
+from Exporter import Exporter
+from ClassExporter import ClassExporter
+from FunctionExporter import FunctionExporter
+from EnumExporter import EnumExporter
+from VarExporter import VarExporter
+from infos import *
+from declarations import *
+import os.path
+import exporters
+import MultipleCodeUnit
+
+#==============================================================================
+# HeaderExporter
+#==============================================================================
+class HeaderExporter(Exporter):
+    'Exports all declarations found in the given header'
+
+    def __init__(self, info, parser_tail=None):
+        Exporter.__init__(self, info, parser_tail)
+
+
+    def WriteInclude(self, codeunit):
+        pass
+
+
+    def IsInternalName(self, name):
+        '''Returns true if the given name looks like a internal compiler
+        structure'''
+        return name.startswith('_')
+        
+
+    def Export(self, codeunit, exported_names):
+        header = os.path.normpath(self.parser_header)
+        for decl in self.declarations:
+            # check if this declaration is in the header
+            location = os.path.normpath(decl.location[0])
+            if location == header and not self.IsInternalName(decl.name):
+                # ok, check the type of the declaration and export it accordingly
+                self.HandleDeclaration(decl, codeunit, exported_names)
+            
+
+    def HandleDeclaration(self, decl, codeunit, exported_names):
+        '''Dispatch the declaration to the appropriate method, that must create
+        a suitable info object for a Exporter, create a Exporter, set its
+        declarations and append it to the list of exporters.
+        ''' 
+        dispatch_table = {
+            Class : ClassExporter,
+            Enumeration : EnumExporter,
+            Function : FunctionExporter,
+            Variable : VarExporter,
+        }
+        
+        exporter_class = dispatch_table.get(type(decl))
+        if exporter_class is not None:
+            self.HandleExporter(decl, exporter_class, codeunit, exported_names)
+
+            
+    def HandleExporter(self, decl, exporter_type, codeunit, exported_names):
+        # only export complete declarations
+        if not decl.incomplete:
+            info = self.info[decl.name]
+            info.name = decl.FullName()
+            info.include = self.info.include
+            exporter = exporter_type(info)
+            exporter.SetDeclarations(self.declarations)
+            exporter.SetParsedHeader(self.parser_header)
+            if isinstance(codeunit, MultipleCodeUnit.MultipleCodeUnit):
+                codeunit.SetCurrent(self.interface_file, exporter.Name())
+            else:
+                codeunit.SetCurrent(exporter.Name())
+            exporter.GenerateCode(codeunit, exported_names)
+
+
+    def Name(self):
+        return self.info.include

pyste/src/Pyste/MultipleCodeUnit.py

@@ -0,0 +1,130 @@
+from SingleCodeUnit import SingleCodeUnit
+import os
+import utils
+from SmartFile import SmartFile
+
+
+#==============================================================================
+# MultipleCodeUnit
+#==============================================================================
+class MultipleCodeUnit(object):
+    '''
+    Represents a bunch of cpp files, where each cpp file represents a header
+    to be exported by pyste. Another cpp, named <module>.cpp is created too.
+    '''
+
+    def __init__(self, modulename, outdir):
+        self.modulename = modulename
+        self.outdir = outdir
+        self.codeunits = {}  # maps from a (filename, function) to a SingleCodeUnit
+        self.functions = []
+        self._current = None
+        self.all = SingleCodeUnit(None, None)
+
+    
+    def _FunctionName(self, interface_file):
+        name = os.path.splitext(interface_file)[0]
+        return 'Export_%s' % utils.makeid(name)
+    
+
+    def _FileName(self, interface_file):
+        filename = os.path.basename(interface_file)
+        filename = '_%s.cpp' % os.path.splitext(filename)[0] 
+        return os.path.join(self.outdir, filename)
+
+    
+    def SetCurrent(self, interface_file, export_name):
+        'Changes the current code unit'
+        if export_name is None:
+            self._current = None
+        elif export_name is '__all__':
+            self._current = self.all
+        else:
+            filename = self._FileName(interface_file)
+            function = self._FunctionName(interface_file)
+            try:
+                codeunit = self.codeunits[filename]
+            except KeyError:
+                codeunit = SingleCodeUnit(None, filename)
+                codeunit.module_definition = 'void %s()' % function
+                self.codeunits[filename] = codeunit
+                if function not in self.functions:
+                    self.functions.append(function)
+            self._current = codeunit
+
+
+    def Current(self):
+        return self._current
+
+    current = property(Current, SetCurrent)
+        
+            
+    def Write(self, section, code):
+        if self._current is not None:
+            self.current.Write(section, code)
+
+
+    def Section(self, section):
+        if self._current is not None: 
+            return self.current.Section(section)
+
+
+    def _CreateOutputDir(self):
+        try:
+            os.mkdir(self.outdir)
+        except OSError: pass # already created
+
+        
+    def Save(self):
+        # create the directory where all the files will go
+        self._CreateOutputDir();
+        # order all code units by filename, and merge them all
+        codeunits = {} # filename => list of codeunits
+
+        # While ordering all code units by file name, the first code
+        # unit in the list of code units is used as the main unit
+        # which dumps all the include, declaration and
+        # declaration-outside sections at the top of the file.
+        for filename, codeunit in self.codeunits.items(): 
+            if filename not in codeunits:
+                # this codeunit is the main codeunit.
+                codeunits[filename] = [codeunit]
+                codeunit.Merge(self.all)
+            else:
+                main_unit = codeunits[filename][0]
+                for section in ('include', 'declaration', 'declaration-outside'):
+                    main_unit.code[section] = main_unit.code[section] + codeunit.code[section]
+                    codeunit.code[section] = ''
+                codeunits[filename].append(codeunit)
+
+        # Now write all the codeunits appending them correctly.
+        for file_units in codeunits.values():
+            append = False
+            for codeunit in file_units:
+                codeunit.Save(append)
+                if not append:
+                    append = True
+                    
+
+    def GenerateMain(self, interfaces):                    
+        # generate the main cpp
+        filename = os.path.join(self.outdir, '_main.cpp')
+        fout = SmartFile(filename, 'w')
+        fout.write(utils.left_equals('Include'))
+        fout.write('#include <boost/python/module.hpp>\n\n')
+        fout.write(utils.left_equals('Exports'))
+        functions = [self._FunctionName(x) for x in interfaces]
+        for function in functions:
+            fout.write('void %s();\n' % function)
+        fout.write('\n')
+        fout.write(utils.left_equals('Module'))
+        fout.write('BOOST_PYTHON_MODULE(%s)\n' % self.modulename)
+        fout.write('{\n')
+        indent = ' ' * 4
+        for function in functions:
+            fout.write(indent)
+            fout.write('%s();\n' % function)
+        fout.write('}\n')
+        
+    
+        

pyste/src/Pyste/SingleCodeUnit.py

@@ -0,0 +1,98 @@
+from settings import namespaces
+import settings
+from utils import remove_duplicated_lines, left_equals
+from SmartFile import SmartFile
+
+
+#==============================================================================
+# SingleCodeUnit
+#==============================================================================
+class SingleCodeUnit:
+    '''
+    Represents a cpp file, where other objects can write in one of the     
+    predefined sections.
+    The avaiable sections are:
+        include - The include area of the cpp file
+        declaration - The part before the module definition
+        module - Inside the BOOST_PYTHON_MODULE macro
+    '''
+    
+    def __init__(self, modulename, filename):
+        self.modulename = modulename
+        self.filename = filename
+        # define the avaiable sections
+        self.code = {}
+        # include section
+        self.code['include'] = '#include <boost/python.hpp>\n'
+        # declaration section (inside namespace)        
+        self.code['declaration'] = ''
+        # declaration (outside namespace)
+        self.code['declaration-outside'] = ''
+        # inside BOOST_PYTHON_MACRO
+        self.code['module'] = ''
+        # create the default module definition
+        self.module_definition = 'BOOST_PYTHON_MODULE(%s)' % modulename
+
+
+    def Write(self, section, code):
+        'write the given code in the section of the code unit'
+        if section not in self.code:
+            raise RuntimeError, 'Invalid CodeUnit section: %s' % section
+        self.code[section] += code
+        
+
+    def Merge(self, other):
+        for section in ('include', 'declaration', 'declaration-outside', 'module'):
+            self.code[section] = self.code[section] + other.code[section]    
+
+        
+    def Section(self, section):
+        return self.code[section]
+
+
+    def SetCurrent(self, *args):
+        pass
+
+
+    def Current(self):
+        pass 
+
+    
+    def Save(self, append=False):
+        'Writes this code unit to the filename'
+        space = '\n\n'
+        if not append:
+            flag = 'w'
+        else:
+            flag = 'a'
+        fout = SmartFile(self.filename, flag)
+        # includes
+        if self.code['include']:
+            includes = remove_duplicated_lines(self.code['include'])
+            fout.write('\n' + left_equals('Includes'))        
+            fout.write(includes)
+            fout.write(space)
+        # using
+        if settings.USING_BOOST_NS and not append:
+            fout.write(left_equals('Using'))
+            fout.write('using namespace boost::python;\n\n')
+        # declarations
+        declaration = self.code['declaration']
+        declaration_outside = self.code['declaration-outside']
+        if declaration_outside or declaration:
+            fout.write(left_equals('Declarations'))
+            if declaration_outside:
+                fout.write(declaration_outside + '\n\n')
+            if declaration:
+                pyste_namespace = namespaces.pyste[:-2]            
+                fout.write('namespace %s {\n\n' % pyste_namespace)
+                fout.write(declaration) 
+                fout.write('\n}// namespace %s\n' % pyste_namespace)
+                fout.write(space)
+        # module
+        fout.write(left_equals('Module'))
+        fout.write(self.module_definition + '\n')
+        fout.write('{\n')
+        fout.write(self.code['module']) 
+        fout.write('}\n\n')
+        fout.close()

pyste/src/Pyste/SmartFile.py

@@ -0,0 +1,55 @@
+import os
+import md5
+
+#==============================================================================
+# SmartFile
+#==============================================================================
+class SmartFile(object):
+    '''
+    A file-like object used for writing files. The given file will only be
+    actually written to disk if there's not a file with the same name, or if
+    the existing file is *different* from the file to be written.
+    '''
+
+    def __init__(self, filename, mode='w'):
+        self.filename = filename
+        self.mode = mode
+        self._contents = []
+        self._closed = False
+
+
+    def __del__(self):
+        if not self._closed:
+            self.close()
+
+
+    def write(self, string):
+        self._contents.append(string)
+
+
+    def _dowrite(self, contents):
+        f = file(self.filename, self.mode)
+        f.write(contents)
+        f.close()
+        
+        
+    def _GetMD5(self, string):
+        return md5.new(string).digest()
+        
+    
+    def close(self):
+        # if the filename doesn't exist, write the file right away
+        this_contents = ''.join(self._contents)
+        if not os.path.isfile(self.filename):
+            self._dowrite(this_contents)
+        else:
+            # read the contents of the file already in disk
+            f = file(self.filename)
+            other_contents = f.read()
+            f.close()
+            # test the md5 for both files 
+            this_md5 = self._GetMD5(this_contents)
+            other_md5 = self._GetMD5(other_contents)
+            if this_md5 != other_md5:
+                self._dowrite(this_contents)
+        self._closed = True

pyste/src/Pyste/VarExporter.py

@@ -0,0 +1,35 @@
+from Exporter import Exporter
+from settings import *
+import utils
+
+#==============================================================================
+# VarExporter
+#==============================================================================
+class VarExporter(Exporter):
+    '''Exports a global variable.
+    '''
+
+    def __init__(self, info):
+        Exporter.__init__(self, info)
+
+
+    def Export(self, codeunit, exported_names):
+        if self.info.exclude: return
+        decl = self.GetDeclaration(self.info.name)
+        if not decl.type.const: 
+            msg = '---> Warning: The global variable "%s" is non-const:\n' \
+                  '              changes in Python will not reflect in C++.'
+            print msg % self.info.name
+            print
+        rename = self.info.rename or self.info.name
+        code = self.INDENT + namespaces.python
+        code += 'scope().attr("%s") = %s;\n' % (rename, self.info.name)
+        codeunit.Write('module', code)
+
+
+    def Order(self):
+        return 0, self.info.name
+
+
+    def Name(self):
+        return self.info.name

pyste/src/Pyste/declarations.py

@@ -0,0 +1,648 @@
+'''
+Defines classes that represent declarations found in C++ header files.
+    
+'''
+
+# version indicates the version of the declarations. Whenever a declaration
+# changes, this variable should be updated, so that the caches can be rebuilt
+# automatically
+version = '1.0'
+
+#==============================================================================
+# Declaration
+#==============================================================================
+class Declaration(object):
+    '''Base class for all declarations.
+    @ivar name: The name of the declaration.
+    @ivar namespace: The namespace of the declaration.
+    '''
+
+    def __init__(self, name, namespace):
+        '''
+        @type name: string
+        @param name: The name of this declaration
+        @type namespace: string
+        @param namespace: the full namespace where this declaration resides.
+        '''
+        self.name = name
+        self.namespace = namespace
+        self.location = '', -1  # (filename, line)
+        self.incomplete = False
+        self.is_unique = True
+
+
+    def FullName(self):
+        '''
+        Returns the full qualified name: "boost::inner::Test"
+        @rtype: string
+        @return: The full name of the declaration.
+        '''
+        namespace = self.namespace or ''
+        if namespace and not namespace.endswith('::'):
+            namespace += '::'
+        return namespace + self.name
+    
+    
+    def __repr__(self):        
+        return '<Declaration %s at %s>' % (self.FullName(), id(self))
+
+
+    def __str__(self):
+        return 'Declaration of %s' % self.FullName()
+    
+    
+#==============================================================================
+# Class
+#==============================================================================
+class Class(Declaration):
+    '''
+    Represents a C++ class or struct. Iteration through it yields its members.
+
+    @type abstract: bool
+    @ivar abstract: if the class has any abstract methods.
+
+    @type bases: tuple
+    @ivar bases: tuple with L{Base} instances, representing the most direct
+    inheritance.
+
+    @type hierarchy: list
+    @ivar hierarchy: a list of tuples of L{Base} instances, representing
+    the entire hierarchy tree of this object. The first tuple is the parent 
+    classes, and the other ones go up in the hierarchy.
+    '''
+
+    def __init__(self, name, namespace, members, abstract):
+        Declaration.__init__(self, name, namespace)
+        self.__members = members
+        self.__member_names = {}
+        self.abstract = abstract
+        self.bases = ()
+        self.hierarchy = ()
+        self.operator = {}
+
+
+    def __iter__(self):
+        '''iterates through the class' members.
+        '''
+        return iter(self.__members)            
+
+
+    def Constructors(self, publics_only=True):
+        '''Returns a list of the constructors for this class.
+        @rtype: list
+        '''
+        constructors = []
+        for member in self:
+            if isinstance(member, Constructor):
+                if publics_only and member.visibility != Scope.public:
+                    continue
+                constructors.append(member)
+        return constructors
+
+    
+    def HasCopyConstructor(self):
+        '''Returns true if this class has a public copy constructor.
+        @rtype: bool
+        '''
+        for cons in self.Constructors():
+            if cons.IsCopy():
+                return True
+        return False
+
+
+    def HasDefaultConstructor(self):
+        '''Returns true if this class has a public default constructor.
+        @rtype: bool
+        '''
+        for cons in self.Constructors():
+            if cons.IsDefault():
+                return True
+        return False
+
+
+    def AddMember(self, member):
+        if member.name in self.__member_names:
+            member.is_unique = False
+            for m in self:
+                if m.name == member.name:
+                    m.is_unique = False
+        else:
+            member.is_unique = True
+        self.__member_names[member.name] = 1
+        self.__members.append(member)
+        if isinstance(member, ClassOperator):
+            self.operator[member.name] = member
+
+
+    def ValidMemberTypes():
+        return (NestedClass, Method, Constructor, Destructor, ClassVariable, 
+                ClassOperator, ConverterOperator, ClassEnumeration)   
+    ValidMemberTypes = staticmethod(ValidMemberTypes)
+
+                          
+#==============================================================================
+# NestedClass
+#==============================================================================
+class NestedClass(Class):
+    '''The declaration of a class/struct inside another class/struct.
+    
+    @type class: string
+    @ivar class: fullname of the class where this class is contained.
+
+    @type visibility: L{Scope} 
+    @ivar visibility: the visibility of this class.
+    '''
+
+    def __init__(self, name, class_, visib, members, abstract):
+        Class.__init__(self, name, None, members, abstract)
+        self.class_ = class_
+        self.visibility = visib
+
+
+    def FullName(self):
+        '''The full name of this class, like ns::outer::inner.
+        @rtype: string
+        '''
+        return '%s::%s' % (self.class_, self.name)
+    
+
+#==============================================================================
+# Scope    
+#==============================================================================
+class Scope:    
+    '''Used to represent the visibility of various members inside a class.
+    @cvar public: public visibility
+    @cvar private: private visibility
+    @cvar protected: protected visibility
+    '''
+    public = 'public'
+    private = 'private'
+    protected = 'protected'
+    
+ 
+#==============================================================================
+# Base    
+#==============================================================================
+class Base:
+    '''Represents a base class of another class.
+    @ivar _name: the full name of the base class.
+    @ivar _visibility: the visibility of the derivation.
+    '''
+
+    def __init__(self, name, visibility=Scope.public):
+        self.name = name
+        self.visibility = visibility
+
+    
+#==============================================================================
+# Function    
+#==============================================================================
+class Function(Declaration):
+    '''The declaration of a function.
+    @ivar _result: instance of L{Type} or None.
+    @ivar _parameters: list of L{Type} instances.
+    @ivar _throws: exception specifiers or None 
+    '''
+
+    def __init__(self, name, namespace, result, params, throws=None): 
+        Declaration.__init__(self, name, namespace)
+        # the result type: instance of Type, or None (constructors)            
+        self.result = result
+        # the parameters: instances of Type
+        self.parameters = params
+        # the exception specification
+        self.throws     = throws 
+
+
+    def Exceptions(self):
+        if self.throws is None:
+            return ""
+        else:
+            return " throw(%s)" % ', '.join (self.throws) 
+
+
+    def PointerDeclaration(self, force=False):
+        '''Returns a declaration of a pointer to this function.
+        @param force: If True, returns a complete pointer declaration regardless
+        if this function is unique or not.
+        '''
+        if self.is_unique and not force:
+            return '&%s' % self.FullName()
+        else:
+            result = self.result.FullName()
+            params = ', '.join([x.FullName() for x in self.parameters]) 
+            return '(%s (*)(%s))&%s' % (result, params, self.FullName())
+
+    
+    def MinArgs(self):
+        min = 0
+        for arg in self.parameters:
+            if arg.default is None:
+                min += 1
+        return min
+
+    minArgs = property(MinArgs)
+    
+
+    def MaxArgs(self):
+        return len(self.parameters)
+
+    maxArgs = property(MaxArgs)
+
+    
+    
+#==============================================================================
+# Operator
+#==============================================================================
+class Operator(Function):
+    '''The declaration of a custom operator. Its name is the same as the 
+    operator name in C++, ie, the name of the declaration "operator+(..)" is
+    "+".
+    '''
+    
+    def FullName(self):
+        namespace = self.namespace or ''
+        if not namespace.endswith('::'):
+            namespace += '::'
+        return namespace + 'operator' + self.name 
+
+
+#==============================================================================
+# Method
+#==============================================================================
+class Method(Function):
+    '''The declaration of a method.
+    
+    @ivar _visibility: the visibility of this method.
+    @ivar _virtual: if this method is declared as virtual.
+    @ivar _abstract: if this method is virtual but has no default implementation.
+    @ivar _static: if this method is static.
+    @ivar _class: the full name of the class where this method was declared.
+    @ivar _const: if this method is declared as const.
+    @ivar _throws: list of exception specificiers or None
+    '''
+
+    def __init__(self, name, class_, result, params, visib, virtual, abstract, static, const, throws=None): 
+        Function.__init__(self, name, None, result, params, throws)
+        self.visibility = visib
+        self.virtual = virtual
+        self.abstract = abstract
+        self.static = static
+        self.class_ = class_
+        self.const = const
+
+    
+    def FullName(self):
+        return self.class_ + '::' + self.name
+
+
+    def PointerDeclaration(self, force=False):
+        '''Returns a declaration of a pointer to this member function.
+        @param force: If True, returns a complete pointer declaration regardless
+        if this function is unique or not. 
+        '''
+        if self.static:
+            # static methods are like normal functions
+            return Function.PointerDeclaration(self, force)
+        if self.is_unique and not force:
+            return '&%s' % self.FullName()
+        else:
+            result = self.result.FullName()
+            params = ', '.join([x.FullName() for x in self.parameters]) 
+            const = ''
+            if self.const:
+                const = 'const'            
+            return '(%s (%s::*)(%s) %s%s)&%s' %\
+                (result, self.class_, params, const, self.Exceptions(), self.FullName())  
+
+
+#==============================================================================
+# Constructor
+#==============================================================================
+class Constructor(Method):
+    '''A class' constructor.
+    '''
+
+    def __init__(self, name, class_, params, visib):
+        Method.__init__(self, name, class_, None, params, visib, False, False, False, False)
+
+
+    def IsDefault(self):
+        '''Returns True if this constructor is a default constructor.
+        '''
+        return len(self.parameters) == 0 and self.visibility == Scope.public
+
+
+    def IsCopy(self):
+        '''Returns True if this constructor is a copy constructor.
+        '''
+        if len(self.parameters) != 1:
+            return False
+        param = self.parameters[0]
+        class_as_param = self.parameters[0].name == self.class_
+        param_reference = isinstance(param, ReferenceType) 
+        is_public = self.visibility = Scope.public
+        return param_reference and class_as_param and param.const and is_public
+        
+
+    def PointerDeclaration(self, force=False):
+        return ''
+
+
+#==============================================================================
+# Destructor
+#==============================================================================
+class Destructor(Method):
+    'The destructor of a class.'
+
+    def __init__(self, name, class_, visib, virtual):
+        Method.__init__(self, name, class_, None, [], visib, virtual, False, False, False)
+
+    def FullName(self):
+        return self.class_ + '::~' + self.name
+
+
+    def PointerDeclaration(self, force=False):
+        return ''
+
+
+
+#==============================================================================
+# ClassOperator
+#==============================================================================
+class ClassOperator(Method):
+    'A custom operator in a class.'
+    
+    def FullName(self):
+        return self.class_ + '::operator ' + self.name
+
+
+
+#==============================================================================
+# ConverterOperator
+#==============================================================================
+class ConverterOperator(ClassOperator):
+    'An operator in the form "operator OtherClass()".'
+    
+    def FullName(self):
+        return self.class_ + '::operator ' + self.result.FullName()
+
+    
+
+#==============================================================================
+# Type
+#==============================================================================
+class Type(Declaration):
+    '''Represents the type of a variable or parameter.
+    @ivar _const: if the type is constant.
+    @ivar _default: if this type has a default value associated with it.
+    @ivar _volatile: if this type was declared with the keyword volatile.
+    @ivar _restricted: if this type was declared with the keyword restricted.
+    @ivar _suffix: Suffix to get the full type name. '*' for pointers, for
+    example.
+    '''
+
+    def __init__(self, name, const=False, default=None, suffix=''):
+        Declaration.__init__(self, name, None)
+        # whatever the type is constant or not
+        self.const = const
+        # used when the Type is a function argument
+        self.default = default
+        self.volatile = False
+        self.restricted = False
+        self.suffix = suffix
+
+    def __repr__(self):
+        if self.const:
+            const = 'const '
+        else:
+            const = ''
+        return '<Type ' + const + self.name + '>'
+
+
+    def FullName(self):
+        if self.const:
+            const = 'const '
+        else:
+            const = ''
+        return const + self.name + self.suffix
+
+
+#==============================================================================
+# ArrayType
+#==============================================================================
+class ArrayType(Type):
+    '''Represents an array.
+    @ivar min: the lower bound of the array, usually 0. Can be None.
+    @ivar max: the upper bound of the array. Can be None.
+    '''
+
+    def __init__(self, name, const, min, max): 
+        'min and max can be None.'
+        Type.__init__(self, name, const)
+        self.min = min
+        self.max = max        
+
+
+
+#==============================================================================
+# ReferenceType    
+#==============================================================================
+class ReferenceType(Type): 
+    '''A reference type.'''
+
+    def __init__(self, name, const=False, default=None, expandRef=True, suffix=''):
+        Type.__init__(self, name, const, default)
+        if expandRef:
+            self.suffix = suffix + '&'
+        
+        
+#==============================================================================
+# PointerType
+#==============================================================================
+class PointerType(Type):
+    'A pointer type.'
+    
+    def __init__(self, name, const=False, default=None, expandPointer=False, suffix=''):
+        Type.__init__(self, name, const, default)
+        if expandPointer:
+            self.suffix = suffix + '*'
+   
+
+#==============================================================================
+# FundamentalType
+#==============================================================================
+class FundamentalType(Type): 
+    'One of the fundamental types, like int, void, etc.'
+
+    def __init__(self, name, const=False, default=None): 
+        Type.__init__(self, name, const, default)
+
+
+
+#==============================================================================
+# FunctionType
+#==============================================================================
+class FunctionType(Type):
+    '''A pointer to a function.
+    @ivar _result: the return value
+    @ivar _parameters: a list of Types, indicating the parameters of the function.
+    @ivar _name: the name of the function.
+    '''
+
+    def __init__(self, result, parameters):  
+        Type.__init__(self, '', False)
+        self.result = result
+        self.parameters = parameters
+        self.name = self.FullName()
+
+
+    def FullName(self):
+        full = '%s (*)' % self.result.FullName()
+        params = [x.FullName() for x in self.parameters]
+        full += '(%s)' % ', '.join(params)        
+        return full
+    
+    
+#==============================================================================
+# MethodType
+#==============================================================================
+class MethodType(FunctionType):
+    '''A pointer to a member function of a class.
+    @ivar _class: The fullname of the class that the method belongs to.
+    '''
+
+    def __init__(self, result, parameters, class_):  
+        self.class_ = class_
+        FunctionType.__init__(self, result, parameters)
+
+
+    def FullName(self):
+        full = '%s (%s::*)' % (self.result.FullName(), self.class_)
+        params = [x.FullName() for x in self.parameters]
+        full += '(%s)' % ', '.join(params)
+        return full
+    
+     
+#==============================================================================
+# Variable
+#==============================================================================
+class Variable(Declaration):
+    '''Represents a global variable.
+
+    @type _type: L{Type}
+    @ivar _type: The type of the variable.
+    '''
+    
+    def __init__(self, type, name, namespace):
+        Declaration.__init__(self, name, namespace)
+        self.type = type
+
+
+#==============================================================================
+# ClassVariable
+#==============================================================================
+class ClassVariable(Variable):
+    '''Represents a class variable.
+
+    @type _visibility: L{Scope}
+    @ivar _visibility: The visibility of this variable within the class.
+
+    @type _static: bool
+    @ivar _static: Indicates if the variable is static.
+
+    @ivar _class: Full name of the class that this variable belongs to.
+    '''
+
+    def __init__(self, type, name, class_, visib, static):
+        Variable.__init__(self, type, name, None)
+        self.visibility = visib
+        self.static = static
+        self.class_ = class_
+    
+
+    def FullName(self):
+        return self.class_ + '::' + self.name
+
+        
+#==============================================================================
+# Enumeration    
+#==============================================================================
+class Enumeration(Declaration):
+    '''Represents an enum.
+
+    @type _values: dict of str => int
+    @ivar _values: holds the values for this enum.
+    '''
+    
+    def __init__(self, name, namespace):
+        Declaration.__init__(self, name, namespace)
+        self.values = {} # dict of str => int
+
+
+    def ValueFullName(self, name):
+        '''Returns the full name for a value in the enum.
+        '''
+        assert name in self.values
+        namespace = self.namespace
+        if namespace:
+            namespace += '::'
+        return namespace + name
+
+
+#==============================================================================
+# ClassEnumeration
+#==============================================================================
+class ClassEnumeration(Enumeration):
+    '''Represents an enum inside a class.
+
+    @ivar _class: The full name of the class where this enum belongs.
+    @ivar _visibility: The visibility of this enum inside his class.
+    '''
+
+    def __init__(self, name, class_, visib):
+        Enumeration.__init__(self, name, None)
+        self.class_ = class_
+        self.visibility = visib
+
+
+    def FullName(self):
+        return '%s::%s' % (self.class_, self.name)
+
+
+    def ValueFullName(self, name):
+        assert name in self.values
+        return '%s::%s' % (self.class_, name)
+
+    
+#==============================================================================
+# Typedef
+#==============================================================================
+class Typedef(Declaration):
+    '''A Typedef declaration.
+
+    @type _type: L{Type}
+    @ivar _type: The type of the typedef.
+
+    @type _visibility: L{Scope}
+    @ivar _visibility: The visibility of this typedef.
+    '''
+
+    def __init__(self, type, name, namespace):
+        Declaration.__init__(self, name, namespace)
+        self.type = type
+        self.visibility = Scope.public
+
+
+
+
+                          
+#==============================================================================
+# Unknown        
+#==============================================================================
+class Unknown(Declaration):
+    '''A declaration that Pyste does not know how to handle.
+    '''
+
+    def __init__(self, name):
+        Declaration.__init__(self, name, None)

pyste/src/Pyste/exporters.py

@@ -0,0 +1,5 @@
+
+# a list of Exporter instances
+exporters = []
+
+current_interface = None # the current interface file being processed