diff -urN boost_1_32_0.orig/Jamfile boost_1_32_0/Jamfile
--- boost_1_32_0.orig/Jamfile	Thu Aug 12 02:13:36 2004
+++ boost_1_32_0/Jamfile	Wed Apr 13 21:13:46 2005
@@ -113,6 +113,7 @@
 # object code libraries
 local lib-locate = [ MATCH "^--libdir=(.*)" : $(ARGV) ] ;
 lib-locate ?= $(exec-locate)/lib ;
+gLIB_INSTALL_DIR ?= $(lib-locate) ;
 
 # where to build
 local all-locate = [ MATCH "^--builddir=(.*)" : $(ARGV) ] ;
diff -urN boost_1_32_0.orig/boost/test/detail/wrap_stringstream.hpp boost_1_32_0/boost/test/detail/wrap_stringstream.hpp
--- boost_1_32_0.orig/boost/test/detail/wrap_stringstream.hpp	Sun Sep 19 05:22:12 2004
+++ boost_1_32_0/boost/test/detail/wrap_stringstream.hpp	Wed Apr 13 21:13:46 2005
@@ -117,7 +117,7 @@
 
 //____________________________________________________________________________//
 
-#if !defined(BOOST_NO_STD_LOCALE) && BOOST_WORKAROUND(BOOST_MSVC, >= 1310)
+#if !defined(BOOST_NO_STD_LOCALE) && ( !defined(BOOST_MSVC) || BOOST_WORKAROUND(BOOST_MSVC, >= 1310))
 
 template <typename CharT>
 inline basic_wrap_stringstream<CharT>&
diff -urN boost_1_32_0.orig/libs/python/build/Jamfile boost_1_32_0/libs/python/build/Jamfile
--- boost_1_32_0.orig/libs/python/build/Jamfile	Mon Jul 26 11:33:26 2004
+++ boost_1_32_0/libs/python/build/Jamfile	Wed Apr 13 21:13:46 2005
@@ -63,6 +63,7 @@
       $(bpl-linkflags)
         <msvc-stlport><release>$(msvc-stlport-workarounds)
         <darwin><*><linkflags>-bind_at_load
+	<gcc><*><linkflags>"-undefined dynamic_lookup -flat_namespace"
       ;
 
   template extension
diff -urN boost_1_32_0.orig/libs/test/build/Jamfile boost_1_32_0/libs/test/build/Jamfile
--- boost_1_32_0.orig/libs/test/build/Jamfile	Tue Jul 20 06:51:08 2004
+++ boost_1_32_0/libs/test/build/Jamfile	Wed Apr 13 21:13:46 2005
@@ -56,13 +56,16 @@
 if ! $(NT)
 {
 dll boost_prg_exec_monitor    : <template>boost_test_lib
-                                ../src/$(PRG_EXEC_MON_SOURCES).cpp ;
+                                ../src/$(PRG_EXEC_MON_SOURCES).cpp 
+			: <gcc><*><linkflags>"-undefined dynamic_lookup" ;
 
 dll boost_test_exec_monitor   : <template>boost_test_lib
-                                ../src/$(TEST_EXEC_MON_SOURCES).cpp ; 
+                                ../src/$(TEST_EXEC_MON_SOURCES).cpp 
+			: <gcc><*><linkflags>"-undefined dynamic_lookup" ;
 
 dll boost_unit_test_framework : <template>boost_test_lib
-                                ../src/$(UTF_SOURCES).cpp ;
+                                ../src/$(UTF_SOURCES).cpp 
+			: <gcc><*><linkflags>"-undefined dynamic_lookup" ;
 }
 
 install test lib
diff -urN boost_1_32_0.orig/tools/build/v1/allyourbase.jam boost_1_32_0/tools/build/v1/allyourbase.jam
--- boost_1_32_0.orig/tools/build/v1/allyourbase.jam	Sun Nov  7 11:55:58 2004
+++ boost_1_32_0/tools/build/v1/allyourbase.jam	Wed Apr 13 21:13:46 2005
@@ -2108,7 +2108,7 @@
 actions HardLink
 {
     $(RM) "$(<)" 2$(NULL_OUT) $(NULL_OUT)
-    $(LN) "$(>)" "$(<)" $(NULL_OUT)
+    $(LN) -s $(>:D=) "$(<)" $(NULL_OUT)
 }
 
 actions Install
diff -urN boost_1_32_0.orig/tools/build/v1/boost-base.jam boost_1_32_0/tools/build/v1/boost-base.jam
--- boost_1_32_0.orig/tools/build/v1/boost-base.jam	Thu Oct 28 16:07:53 2004
+++ boost_1_32_0/tools/build/v1/boost-base.jam	Wed Apr 13 21:13:46 2005
@@ -2594,7 +2594,7 @@
     if <threading>multi in $(properties) { thread-tag = mt ; }
     
     local runtime-tag = ;
-    if <runtime-link>static in $(properties) { runtime-tag += s ; }
+    #if <runtime-link>static in $(properties) { runtime-tag += s ; }
     if <runtime-build>debug in $(properties) { runtime-tag += g ; }
     if [ MATCH .*(debug-python).* : $(variant) ] { runtime-tag += y ; }
     else { if [ MATCH .*(debug).* : $(variant) ] { runtime-tag += d ; } }
@@ -2651,8 +2651,8 @@
         version-tag = $(version-tag:J="_") ;
     }
     
-    tags += $(toolset-tag:J=) ;
-    tags += $(thread-tag:J=) ;
+    #tags += $(toolset-tag:J=) ;
+    #tags += $(thread-tag:J=) ;
     tags += $(runtime-tag:J=) ;
     tags += $(version-tag) ;
     
diff -urN boost_1_32_0.orig/tools/build/v1/gcc-tools.jam boost_1_32_0/tools/build/v1/gcc-tools.jam
--- boost_1_32_0.orig/tools/build/v1/gcc-tools.jam	Tue Oct 19 11:12:58 2004
+++ boost_1_32_0/tools/build/v1/gcc-tools.jam	Wed Apr 13 21:15:16 2005
@@ -120,8 +120,8 @@
         # MacOS X, doesn't need any threading options set
         # -lpthread is linked to by default.
         # There is no gcc/g++, we need to use cc/c++ instead:
-        .GCC ?= cc ;
-        .GXX ?= c++ ;
+        #.GCC ?= cc ;
+        #.GXX ?= c++ ;
         }
     case *BSD :
         {
@@ -342,7 +342,7 @@
 }
 else
 {
-    flags gcc LINKFLAGS <target-type>$(SHARED_TYPES) : -shared ;
+    flags gcc LINKFLAGS <target-type>$(SHARED_TYPES) : -dynamiclib ;
 }
 
 flags gcc LIBPATH <library-path> ;
@@ -445,7 +445,7 @@
     $(.SET_EXIT)
     $(SHELL_SET)$(gSHELL_LIBPATH)=$(LINK_LIBPATH)$(gAPPEND_LD_LIBRARY_PATH)
     $(SHELL_EXPORT)$(gSHELL_LIBPATH)
-    "$(.GXX[1]:R=$(GCC_BIN_DIR))" $(.GXX[2-]) "$(DLL_LINK_FLAGS)" "$(IMPLIB_COMMAND)$(<[2])" $(LINKFLAGS) -o "$(<[1])$(OUTTAG)" -L"$(LIBPATH:T)" -L"$(STDLIBPATH:T)" "$(>)" "$(NEEDLIBS)" "$(NEEDLIBS)" "$(IMPLIB_FLAGS)$(NEEDIMPS)" -l$(FINDLIBS) $(LNOPT)$(RPATH_LINK). $(LNOPT)$(SONAME)$(<[1]:D=)$(SOTAG)
+    "$(.GXX[1]:R=$(GCC_BIN_DIR))" $(.GXX[2-]) "$(DLL_LINK_FLAGS)" "$(IMPLIB_COMMAND)$(<[2])" $(LINKFLAGS) -o "$(<[1])$(OUTTAG)" -install_name "$(<[1]:D=$(gLIB_INSTALL_DIR))" -compatibility_version $(DLLVERSION) -current_version $(DLLVERSION) -L"$(LIBPATH:T)" -L"$(STDLIBPATH:T)" "$(>)" "$(NEEDLIBS)" "$(NEEDLIBS)" "$(IMPLIB_FLAGS)$(NEEDIMPS)" -l$(FINDLIBS) $(LNOPT)$(RPATH_LINK). $(LNOPT)$(SONAME)$(<[1]:D=)$(SOTAG)
     $(ACTION_1)$(LN)$(_)-fs$(_)"$(<[1]:D=)$(OUTTAG)"$(_)"$(<[1])"
 }
 
@@ -474,7 +474,7 @@
 actions gcc-C++-action
 {
     $(.SET_EXIT)
-    "$(.GXX[1]:R=$(GCC_BIN_DIR))" $(.GXX[2-]) -c -Wall -ftemplate-depth-255 -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) $(C++FLAGS) -I"$(HDRS)" -I$(_)"$(STDHDRS)" -I$(_)"$(SYSHDRS)" -o "$(<)" "$(>)"
+    "$(.GXX[1]:R=$(GCC_BIN_DIR))" $(.GXX[2-]) -c -Wall -fabi-version=1 -Wno-long-double -ftemplate-depth-255 -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) $(C++FLAGS) -I"$(HDRS)" -I$(_)"$(STDHDRS)" -I$(_)"$(SYSHDRS)" -o "$(<)" "$(>)"
     "$(.OBJCOPY[1])"$(_)$(OBJCOPY_FLAGS)$(_)"$(<)"
 }
 
diff -urN boost_1_32_0.orig/tools/build/v1/gcc-tools.jam~ boost_1_32_0/tools/build/v1/gcc-tools.jam~
--- boost_1_32_0.orig/tools/build/v1/gcc-tools.jam~	Wed Dec 31 19:00:00 1969
+++ boost_1_32_0/tools/build/v1/gcc-tools.jam~	Wed Apr 13 21:13:46 2005
@@ -0,0 +1,491 @@
+# Copyright (c) 2001 David Abrahams.
+# Copyright (c) 2002-2003 Rene Rivera.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+
+# The following #// line will be used by the regression test table generation
+# program as the column heading for HTML tables. Must not include version number.
+#//<a href="http://gcc.gnu.org/">GNU<br>GCC</a>
+
+# compute directories for invoking GCC
+#
+# The gcc toolset can be user-configured using the following
+# variables:
+#
+# GCC_ROOT_DIRECTORY
+#       The directory in which GCC was installed. Defaults to
+#       unset. Usually, there is no need to set this variable at
+#       all. However, if G++ is not in the path it is usually
+#       sufficient to configure this one variable. More fine-grained
+#       configuration is available by setting the following:
+#
+# GCC_BIN_DIRECTORY
+#       the directory prefix used to find the gcc executables. Defaults to
+#       $(GCC_ROOT_DIRECTORY)/bin/, or "" if GCC_ROOT_DIRECTORY is
+#       not set.
+#
+# GCC_INCLUDE_DIRECTORY
+#       the directory in which to find system includes. Defaults to
+#       empty.
+#
+# GCC_STDLIB_DIRECTORY
+#       the directory in which to find the standard library
+#       objects associated with this build of gcc. Defaults to
+#       $(GCC_ROOT_DIRECTORY)/lib. 
+#
+# GXX
+#       The name by which g++ is invoked. You can also use this in
+#       lieu of setting the <cxxflags> property to force options such
+#       as "-V3.0.4" into the g++ command line: "-sGXX=g++ -V3.0.4".
+#
+# GCC
+#       Similar to GXX, the name by which gcc is invoked for "C"
+#       language targets.
+
+# singleton variables...
+set-as-singleton GCC_ROOT_DIRECTORY GCC_BIN_DIRECTORY GCC_INCLUDE_DIRECTORY GCC_STDLIB_DIRECTORY ;
+
+flags gcc GCC_BIN_DIRECTORY : $(GCC_BIN_DIRECTORY) ;
+flags gcc GCC_INCLUDE_DIRECTORY : $(GCC_INCLUDE_DIRECTORY) ;
+flags gcc GCC_STDLIB_DIRECTORY : $(GCC_STDLIB_DIRECTORY) ;
+
+GCC_BIN_DIRECTORY ?= $(GCC_ROOT_DIRECTORY)$(SLASH)bin ;
+GCC_BIN_DIRECTORY ?= "" ; # Don't clobber tool names if GCC_ROOT_DIRECTORY not set
+GCC_STDLIB_DIRECTORY ?= $(GCC_ROOT_DIRECTORY)$(SLASH)lib ;
+
+# Make sure this gets set "on" the target
+flags gcc GCC_BIN_DIR : $(GCC_BIN_DIRECTORY) ;
+
+flags gcc LINKFLAGS <runtime-link>static : -static ;
+flags gcc CFLAGS <debug-symbols>on : -g ;
+flags gcc LINKFLAGS <debug-symbols>on : -g ;
+flags gcc CFLAGS <optimization>off : -O0 ;
+flags gcc CFLAGS <optimization>speed : -O3 ;
+
+# Other optimizations we might want for GCC
+# -fforce-mem -fomit-frame-pointer
+# -foptimize-sibling-calls -finline-functions -ffast-math -finline-limit=10000
+
+flags gcc CFLAGS <optimization>space : -Os ;
+flags gcc CFLAGS <inlining>off : -fno-inline ;
+flags gcc CFLAGS <inlining>on : -Wno-inline ;
+flags gcc CFLAGS <inlining>full : -finline-functions -Wno-inline ;
+
+flags gcc .GXX : $(GXX) ;
+flags gcc .GCC : $(GCC) ;
+
+#
+# set threading options for various platforms:
+#
+local on-windows ;
+
+if $(NT)
+{
+    on-windows = 1 ;
+}
+else if $(UNIX)
+{
+    switch $(JAMUNAME)
+    {
+        case CYGWIN* :
+        {
+            on-windows = 1 ;
+        }
+    }
+}
+
+flags gcc ON_WINDOWS : $(on-windows) ;
+
+if $(on-windows)
+{
+    flags gcc CFLAGS <threading>multi : -mthreads ;
+    flags gcc LINKFLAGS <threading>multi : -mthreads ;
+}
+else if $(UNIX)
+{
+    switch $(JAMUNAME)
+    {
+    case SunOS* :
+        {
+        flags gcc CFLAGS <threading>multi : -pthreads ;
+        flags gcc LINKFLAGS <threading>multi : -pthreads ;
+        flags gcc FINDLIBS <threading>multi : rt ;
+        }
+    case BeOS :
+        {
+        # BeOS has no threading options, don't set anything here.
+        }
+    case Darwin :
+        {
+        # MacOS X, doesn't need any threading options set
+        # -lpthread is linked to by default.
+        # There is no gcc/g++, we need to use cc/c++ instead:
+        #.GCC ?= cc ;
+        #.GXX ?= c++ ;
+        }
+    case *BSD :
+        {
+        flags gcc CFLAGS <threading>multi : -pthread ;
+        flags gcc LINKFLAGS <threading>multi : -pthread ;
+        # there is no -lrt on BSD
+        }
+    case DragonFly :
+        {
+        flags gcc CFLAGS <threading>multi : -pthread ;
+        flags gcc LINKFLAGS <threading>multi : -pthread ;
+        # there is no -lrt on BSD - DragonFly is a FreeBSD variant,
+        # which anoyingly doesn't say it's a *BSD.
+        }
+    case IRIX :
+        {
+        # gcc on IRIX does not support multi-threading, don't set anything here.
+        }
+    case HP_UX :
+        {
+        # gcc on HP-UX does not support multi-threading, don't set anything here
+        }
+    case * :
+        {
+        flags gcc CFLAGS <threading>multi : -pthread ;
+        flags gcc LINKFLAGS <threading>multi : -pthread ;
+        flags gcc FINDLIBS <threading>multi : rt ;
+        }
+    }
+}
+
+# Some possibly supported, or not, linker flags. The support depends on the OS linker.
+#
+flags gcc RPATH_LINK  ;
+flags gcc SONAME ;
+
+# Set/reset options for the linker of the platform.
+#
+if $(UNIX)
+{
+    switch $(JAMUNAME)
+    {
+    case SunOS* :
+        {
+        NO_GNU_LN = true ; # sun seems not to use the GNU linker with gcc
+        flags gcc OBJCOPY_FLAGS <debug-symbols>on : "--set-section-flags .debug_str=contents" ;
+        }
+    case Linux :
+        {
+        RPATH_LINK = -Wl,-rpath-link, ;
+        SONAME = -Wl,-soname, ;
+        flags gcc OBJCOPY_FLAGS <debug-symbols>on : "--set-section-flags .debug_str=contents,debug" ;
+        }
+    case OpenBSD :
+        {
+        SONAME = -Wl,-soname, ;
+        }
+    case AIX* :
+        {
+        NO_GNU_LN = true ;
+        IMPLIB_FLAGS = "-Wl,-bI:" ;
+        }
+    }
+}
+
+
+# Set architecture/instruction-set options.
+#
+# x86 and compatible
+.ARCH = <architecture>x86 <architecture>native ;
+flags gcc CFLAGS <architecture>x86/<instruction-set>default : -mcpu=i386 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>i386 : -mcpu=i386 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>i486 : -mcpu=i486 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>i586 : -mcpu=i586 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>i686 : -mcpu=i686 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>pentium : -mcpu=pentium ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>pentium-mmx : -mcpu=pentium-mmx ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>pentiumpro : -mcpu=pentiumpro ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>pentium2 : -mcpu=pentium2 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>pentium3 : -mcpu=pentium3 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>pentium4 : -mcpu=pentium4 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>k6 : -mcpu=k6 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>k6-2 : -mcpu=k6-2 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>k6-3 : -mcpu=k6-3 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>athlon : -mcpu=athlon ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>athlon-tbird : -mcpu=athlon-tbird ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>athlon-4 : -mcpu=athlon-4 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>athlon-xp : -mcpu=athlon-xp ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>athlon-mp : -mcpu=athlon-mp ;
+# Sparc
+.ARCH = <architecture>sparc <architecture>native ;
+flags gcc CFLAGS <architecture>sparc/<instruction-set>default : -mcpu=v7 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>v7 : -mcpu=v7 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>cypress : -mcpu=cypress ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>v8 : -mcpu=v8 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>supersparc : -mcpu=supersparc ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>sparclite : -mcpu=sparclite ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>hypersparc : -mcpu=hypersparc ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>sparclite86x : -mcpu=sparclite86x ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>f930 : -mcpu=f930 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>f934 : -mcpu=f934 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>sparclet : -mcpu=sparclet ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>tsc701 : -mcpu=tsc701 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>v9 : -mcpu=v9 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>ultrasparc : -mcpu=ultrasparc ;
+flags gcc CFLAGS <architecture>sparc/<address-model>64 : -m64 ;
+flags gcc LINKFLAGS <architecture>sparc/<address-model>64 : -m64 ;
+# RS/6000 & PowerPC
+.ARCH = <architecture>power <architecture>native ;
+flags gcc CFLAGS <architecture>power/<instruction-set>default : -mcpu=power ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>rios : -mcpu=rios ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>rios1 : -mcpu=rios1 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>rsc : -mcpu=rsc ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>rios2 : -mcpu=rios2 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>rs64a : -mcpu=rs64a ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>601 : -mcpu=601 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>602 : -mcpu=602 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>603 : -mcpu=603 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>603e : -mcpu=603e ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>604 : -mcpu=604 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>604e : -mcpu=604e ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>620 : -mcpu=620 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>630 : -mcpu=630 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>740 : -mcpu=740 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>750 : -mcpu=750 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>power : -mcpu=power ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>power2 : -mcpu=power2 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>powerpc : -mcpu=powerpc ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>power64 : -mcpu=power64 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>403 : -mcpu=403 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>505 : -mcpu=505 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>801 : -mcpu=801 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>821 : -mcpu=821 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>823 : -mcpu=823 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>860 : -mcpu=860 ;
+flags gcc CFLAGS $(.ARCH)/<instruction-set>power-common : -mcpu=common ;
+flags gcc CFLAGS <architecture>power/<address-model>64 : -mpowerpc64 ;
+# MIPS-1-2-3-4
+flags gcc MIPS <architecture>mips1 <architecture>mips2 <architecture>mips3 <architecture>mips4 : TRUE ;
+flags gcc MIPS
+    <instruction-set>r2000 <instruction-set>r3000 <instruction-set>r3900
+    <instruction-set>r4000 <instruction-set>r4100 <instruction-set>r4300
+    <instruction-set>r4400 <instruction-set>r4600 <instruction-set>r4650
+    <instruction-set>r5000 <instruction-set>r6000 <instruction-set>r8000
+    <instruction-set>orion
+    : TRUE ;
+if $(MIPS)
+{
+    flags gcc CFLAGS <architecture>mips1 : -mips1 ;
+    flags gcc CFLAGS <architecture>mips2 : -mips2 ;
+    flags gcc CFLAGS <architecture>mips3 : -mips3 ;
+    flags gcc CFLAGS <architecture>mips4 : -mips4 ;
+    flags gcc CFLAGS <instruction-set>r2000 : -mcpu=r2000 ;
+    flags gcc CFLAGS <instruction-set>r3000 : -mcpu=r3000 ;
+    flags gcc CFLAGS <instruction-set>r3900 : -mcpu=r3900 ;
+    flags gcc CFLAGS <instruction-set>r4000 : -mcpu=r4000 ;
+    flags gcc CFLAGS <instruction-set>r4100 : -mcpu=r4100 ;
+    flags gcc CFLAGS <instruction-set>r4300 : -mcpu=r4300 ;
+    flags gcc CFLAGS <instruction-set>r4400 : -mcpu=r4400 ;
+    flags gcc CFLAGS <instruction-set>r4600 : -mcpu=r4600 ;
+    flags gcc CFLAGS <instruction-set>r4650 : -mcpu=r4650 ;
+    flags gcc CFLAGS <instruction-set>r5000 : -mcpu=r5000 ;
+    flags gcc CFLAGS <instruction-set>r6000 : -mcpu=r6000 ;
+    flags gcc CFLAGS <instruction-set>r8000 : -mcpu=r8000 ;
+    flags gcc CFLAGS <instruction-set>orion : -mcpu=orion ;
+    #   ...addressing model options
+    flags gcc ADDRESS_MODEL_INVALID <address-model>16 : TRUE ;
+    if $(ADDRESS_MODEL_INVALID)
+    {
+        EXIT "Error: Invalid addressing model for MIPS architecture (16)." ;
+    }
+    flags gcc CFLAGS <address-model>default : -mgp32 ;
+    flags gcc CFLAGS <address-model>32 : -mgp32 ;
+    flags gcc CFLAGS <address-model>64 : -mgp64 -mlong64 ;
+}
+
+#
+# define compiler names if not set:
+.GCC ?= gcc ;
+.GXX ?= g++ ;
+
+
+flags gcc CFLAGS <profiling>on : -pg ;
+flags gcc LINKFLAGS <profiling>on : -pg ;
+
+flags gcc C++FLAGS <rtti>off : -fno-rtti ;
+flags gcc C++FLAGS <vtable-thunks>on : -fvtable-thunks ;
+flags gcc C++FLAGS <vtable-thunks>off : -fvtable-thunks=0 ;
+
+flags gcc CFLAGS <cflags> ;
+flags gcc C++FLAGS <cxxflags> ;
+flags gcc DEFINES <define> ;
+flags gcc UNDEFS <undef> ;
+flags gcc HDRS <include> ;
+flags gcc SYSHDRS <sysinclude> ;
+flags gcc LINKFLAGS <linkflags> ;
+flags gcc LINKFLAGS <debug-symbols>off : -s ;
+flags gcc ARFLAGS <arflags> ;
+
+flags gcc STDHDRS : $(GCC_INCLUDE_DIRECTORY) ;
+flags gcc STDLIBPATH : $(GCC_STDLIB_DIRECTORY) ;
+
+if ! $(ARFLAGS)
+{
+    flags gcc ARFLAGS : "" ;
+}
+
+if ! $(on-windows) # The compiler complains about -fPIC on NT
+{
+    flags gcc CFLAGS <shared-linkable>true : -fPIC ;
+    flags gcc LINKFLAGS <shared-linkable>true : -fPIC ;
+}
+
+
+if $(BETOOLS)
+{
+    flags gcc LINKFLAGS <target-type>$(SHARED_TYPES) : -nostart ;
+}
+else
+{
+    flags gcc LINKFLAGS <target-type>$(SHARED_TYPES) : -dynamiclib ;
+}
+
+flags gcc LIBPATH <library-path> ;
+flags gcc NEEDLIBS <library-file> ;
+flags gcc FINDLIBS <find-library> ;
+
+flags gcc DLLVERSION <dllversion> ;
+DLLVERSION = $(DLLVERSION[1]) ;
+DLLVERSION ?= $(BOOST_VERSION) ;
+
+flags gcc TARGET_TYPE <target-type> ;
+
+# allow for "ar" to be part of the compiler distribution, for
+# example in mingw and cygwin
+flags gcc .AR : [ GLOB $(GCC_BIN_DIRECTORY) $(PATH) : ar ar.exe ] ;
+.AR ?= ar ;
+
+# used to manipulate the object files produced by GCC to
+# prevent the merging of debug symbols (which happens to be n^2 slow)
+flags gcc .OBJCOPY : [ GLOB $(GCC_BIN_DIRECTORY) $(PATH) : objcopy ] ;
+
+if ! $(on-windows)
+{
+    flags gcc .SET_EXIT : "set -e" ;
+}
+
+#### Link ####
+
+rule Link-action
+{
+    _ on $(<) = " " ;
+    # if we don't have a GNU linker then we can't pass any GNU-ld specific flags:
+    if $(NO_GNU_LN)
+    {
+        LNOPT on $(<) = ;
+    }
+    else
+    {
+        LNOPT on $(<) = "" ;
+    }
+    # do we use sonames or not?
+    if $(DLLVERSION) && $(TARGET_TYPE) in $(SHARED_TYPES) && ( $(OS) = LINUX || $(OS) = OPENBSD ) && ! $(NO_GNU_LN)
+    {
+        OUTTAG on $(<) = ".$(DLLVERSION)" ;
+        SOTAG on $(<) = ".$(DLLVERSION)" ;
+        ACTION_1 on $(<) = "" ;
+    }
+    else
+    {
+        OUTTAG on $(<) = "" ;
+        SOTAG on $(<) = ;
+        ACTION_1 on $(<) = ;
+    }
+
+    if [ on $(<) return $(ON_WINDOWS) ]
+    {
+        # On Win32, choose different image bases for load-time efficiency
+        DLL_LINK_FLAGS on $(<) += "-Wl,--enable-auto-image-base" ;
+    }
+
+    if $(<[2]) && [ on $(<) return $(ON_WINDOWS) ]
+    {
+        # Allow gcc-nocygwin to avoid this flag
+        if ! $(GCC_NO_EXPORT_ALL)
+        {
+            DLL_LINK_FLAGS on $(<) += "-Wl,--export-all-symbols" ;
+        }
+
+        # This will appear before the import library name when building a DLL, but
+        # will be "multiplied away" otherwise. The --exclude-symbols directive
+        # proved to be neccessary with some versions of Cygwin.
+        DLL_LINK_FLAGS on $(<) += "-Wl,--exclude-symbols,_bss_end__:_bss_start__:_data_end__:_data_start__" ;
+
+        # set the link command to generate an import library
+        if ! $(NO_GNU_LN)
+        {
+            IMPLIB_COMMAND on $(<) = "-Wl,--out-implib," ;
+        }
+    }
+
+    DEPENDS $(<) : $(NEEDLIBS) $(NEEDIMPS) ;
+    gRUN_LD_LIBRARY_PATH($(<)) += $(STDLIBPATH:T) ;
+    
+    # Workaround GCC's lack of command-files and NT's line-length limitation.
+    if $(NT) {
+        JAMSHELL on $(<) = % ;
+    }
+
+    gcc-Link-action $(<) : $(>) ;
+
+    if $(DLLVERSION) && $(TARGET_TYPE) in $(SHARED_TYPES) && ( $(OS) = LINUX || $(OS) = OPENBSD ) && ! $(NO_GNU_LN)
+    {
+        return "$(<[1]).$(DLLVERSION)" ;
+    }
+}
+
+# for gcc, we repeat all libraries so that dependencies are always resolved
+actions gcc-Link-action bind NEEDLIBS NEEDIMPS
+{
+    $(.SET_EXIT)
+    $(SHELL_SET)$(gSHELL_LIBPATH)=$(LINK_LIBPATH)$(gAPPEND_LD_LIBRARY_PATH)
+    $(SHELL_EXPORT)$(gSHELL_LIBPATH)
+    "$(.GXX[1]:R=$(GCC_BIN_DIR))" $(.GXX[2-]) "$(DLL_LINK_FLAGS)" "$(IMPLIB_COMMAND)$(<[2])" $(LINKFLAGS) -o "$(<[1])$(OUTTAG)" -install_name "$(<[1]:D=$(gLIB_INSTALL_DIR))" -compatibility_version $(DLLVERSION) -current_version $(DLLVERSION) -L"$(LIBPATH:T)" -L"$(STDLIBPATH:T)" "$(>)" "$(NEEDLIBS)" "$(NEEDLIBS)" "$(IMPLIB_FLAGS)$(NEEDIMPS)" -l$(FINDLIBS) $(LNOPT)$(RPATH_LINK). $(LNOPT)$(SONAME)$(<[1]:D=)$(SOTAG)
+    $(ACTION_1)$(LN)$(_)-fs$(_)"$(<[1]:D=)$(OUTTAG)"$(_)"$(<[1])"
+}
+
+#### Cc #####
+
+rule Cc-action
+{
+    _ on $(<) = " " ;
+    gcc-Cc-action $(<) : $(>) ;
+}
+
+actions gcc-Cc-action
+{
+    $(.SET_EXIT)
+    "$(.GCC[1]:R=$(GCC_BIN_DIR))" $(.GCC[2-]) -c -Wall -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) -I"$(HDRS)" -I$(_)"$(STDHDRS)" -I$(_)"$(SYSHDRS)" -o "$(<)" "$(>)"
+    "$(.OBJCOPY[1])"$(_)$(OBJCOPY_FLAGS)$(_)"$(<)"
+}
+
+#### C++ ####
+rule C++-action
+{
+    _ on $(<) = " " ;
+    gcc-C++-action $(<) : $(>) ;
+}
+
+actions gcc-C++-action
+{
+    $(.SET_EXIT)
+    "$(.GXX[1]:R=$(GCC_BIN_DIR))" $(.GXX[2-]) -c -Wall -Wno-long-double -ftemplate-depth-255 -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) $(C++FLAGS) -I"$(HDRS)" -I$(_)"$(STDHDRS)" -I$(_)"$(SYSHDRS)" -o "$(<)" "$(>)"
+    "$(.OBJCOPY[1])"$(_)$(OBJCOPY_FLAGS)$(_)"$(<)"
+}
+
+#### Archive ####
+
+rule Archive-action
+{
+    gcc-Archive-action $(<) : $(>) ;
+}
+
+actions updated together piecemeal gcc-Archive-action
+{
+    "$(.AR[1])" ru$(ARFLAGS:J=) "$(<)" "$(>)"
+}
diff -urN boost_1_32_0.orig/tools/build/v1/python.jam boost_1_32_0/tools/build/v1/python.jam
--- boost_1_32_0.orig/tools/build/v1/python.jam	Tue Oct 19 08:13:08 2004
+++ boost_1_32_0/tools/build/v1/python.jam	Wed Apr 13 21:13:46 2005
@@ -63,10 +63,10 @@
     CYGWIN_PYTHON_DEBUG_DLL_PATH ?= $(CYGWIN_PYTHON_DEBUG_ROOT)/bin ;
     CYGWIN_PYTHON_DEBUG_LIB_PATH ?= $(CYGWIN_PYTHON_DEBUG_ROOT)/lib/python$(CYGWIN_PYTHON_DEBUG_VERSION)/config ;
 }
-else if $(UNIX) && $(OS) = MACOSX
-{
-    PYTHON_EMBEDDED_LIBRARY = ;
-}
+#else if $(UNIX) && $(OS) = MACOSX
+#{
+#    PYTHON_EMBEDDED_LIBRARY = ;
+#}
 else
 {
     PYTHON_EMBEDDED_LIBRARY = python$(PYTHON_VERSION) dl util ;
@@ -89,32 +89,32 @@
     PYTHON_IMPORT_LIB ?= [ GLOB $(PYTHON_LIB_PATH) : libpython$(PYTHON_VERSION_NODOT).* ] ;
     PYTHON_DEBUG_IMPORT_LIB ?= [ GLOB $(PYTHON_LIB_PATH) : libpython$(PYTHON_VERSION_NODOT).* ] ;
 }
-else if $(UNIX) && $(OS) = MACOSX
-{
-    if ! $(PYTHON_ROOT)
-    {
-        if [ GLOB /System/Library/Frameworks : Python.framework ]
-        {
-            PYTHON_ROOT ?= /System/Library/Frameworks/Python.framework/Versions/$(PYTHON_VERSION) ;
-        }
-        else
-        {
-            PYTHON_ROOT ?= /Library/Frameworks/Python.framework/Versions/$(PYTHON_VERSION) ;
-        }
-    }
-    PYTHON_ROOT = $(PYTHON_ROOT:J=" ") ;
-    PYTHON_INCLUDES ?= $(PYTHON_ROOT)/include/python$(PYTHON_VERSION) ;
-    PYTHON_FRAMEWORK ?= $(PYTHON_ROOT) ;
-    while $(PYTHON_FRAMEWORK:D=) && $(PYTHON_FRAMEWORK:D=) != Python.framework
-    {
-        PYTHON_FRAMEWORK = $(PYTHON_FRAMEWORK:D) ;
-    }
-    PYTHON_FRAMEWORK = $(PYTHON_FRAMEWORK:D)/Python ;
-
-    PYTHON_PROPERTIES ?=
-      <sysinclude>$(PYTHON_INCLUDES)
-      ;
-}
+#else if $(UNIX) && $(OS) = MACOSX
+#{
+#    if ! $(PYTHON_ROOT)
+#    {
+#        if [ GLOB /System/Library/Frameworks : Python.framework ]
+#        {
+#            PYTHON_ROOT ?= /System/Library/Frameworks/Python.framework/Versions/$(PYTHON_VERSION) ;
+#        }
+#        else
+#        {
+#            PYTHON_ROOT ?= /Library/Frameworks/Python.framework/Versions/$(PYTHON_VERSION) ;
+#        }
+#    }
+#    PYTHON_ROOT = $(PYTHON_ROOT:J=" ") ;
+#    PYTHON_INCLUDES ?= $(PYTHON_ROOT)/include/python$(PYTHON_VERSION) ;
+#    PYTHON_FRAMEWORK ?= $(PYTHON_ROOT) ;
+#    while $(PYTHON_FRAMEWORK:D=) && $(PYTHON_FRAMEWORK:D=) != Python.framework
+#    {
+#        PYTHON_FRAMEWORK = $(PYTHON_FRAMEWORK:D) ;
+#    }
+#    PYTHON_FRAMEWORK = $(PYTHON_FRAMEWORK:D)/Python ;
+#
+#    PYTHON_PROPERTIES ?=
+#      <sysinclude>$(PYTHON_INCLUDES)
+#      ;
+#}
 else if $(UNIX)
 {
     PYTHON_ROOT ?= /usr/local ;
