diff -ruN /usr/ports/devel/ice.orig/Makefile /usr/ports/devel/ice/Makefile
--- /usr/ports/devel/ice.orig/Makefile	2011-11-07 04:24:50.000000000 +0000
+++ /usr/ports/devel/ice/Makefile	2012-02-15 01:04:19.653642388 +0000
@@ -7,7 +7,7 @@
 
 PORTNAME=	Ice
 PORTVERSION=	3.4.2
-PORTREVISION=	1
+PORTREVISION=	2
 CATEGORIES=	devel
 MASTER_SITES=	http://download.zeroc.com/Ice/3.4/
 
diff -ruN /usr/ports/devel/ice.orig/files/patch-cpp-clang_and_gcc47 /usr/ports/devel/ice/files/patch-cpp-clang_and_gcc47
--- /usr/ports/devel/ice.orig/files/patch-cpp-clang_and_gcc47	1970-01-01 00:00:00.000000000 +0000
+++ /usr/ports/devel/ice/files/patch-cpp-clang_and_gcc47	2012-02-15 01:04:07.753323752 +0000
@@ -0,0 +1,1432 @@
+diff --git cpp.old/allTests.py cpp/allTests.py
+index 33b7d88..8a5effd 100755
+--- cpp/allTests.py
++++ cpp.orig/allTests.py
+@@ -25,6 +25,7 @@ from scripts import *
+ # List of all basic tests.
+ #
+ tests = [ 
++
+     ("IceUtil/condvar", ["once", "win32only"]),
+     ("IceUtil/thread",  ["once"]),
+     ("IceUtil/unicode", ["once"]),
+@@ -62,7 +63,7 @@ tests = [
+     ("Ice/servantLocator", ["core"]),
+     ("Ice/interceptor", ["core"]),
+     ("Ice/stringConverter", ["core"]),
+-    ("Ice/udp", ["core"]),
++    ("Ice/udp", ["core", "nofreebsdjail"]),
+     ("Ice/defaultServant", ["core"]),
+     ("Ice/defaultValue", ["core"]),
+     ("Ice/invoke", ["core", "novc6"]),
+@@ -106,8 +107,8 @@ tests = [
+ #
+ if TestUtil.isWin32() or os.getuid() == 0:
+     tests += [
+-        ("IceUtil/priority", ["core", "nodarwin"]),
+-        ("Ice/threadPoolPriority", ["core", "nodarwin"])
++        ("IceUtil/priority", ["core", "nodarwin", "nofreebsd"]),
++        ("Ice/threadPoolPriority", ["core", "nodarwin", "nofreebsd"])
+         ]
+ 
+ if __name__ == "__main__":
+diff --git cpp.old/include/Freeze/Map.h cpp/include/Freeze/Map.h
+index 2ec759d..263e8fa 100644
+--- cpp/include/Freeze/Map.h
++++ cpp.orig/include/Freeze/Map.h
+@@ -426,7 +426,7 @@ public:
+ 
+     ConstIterator(MapHelper& mapHelper, const Ice::CommunicatorPtr& communicator) :
+         _helper(IteratorHelper::create(mapHelper, true)), 
+-        _communicator(_communicator),
++        _communicator(communicator),
+         _refValid(false)
+     {
+     }
+diff --git cpp.old/include/Ice/Buffer.h cpp/include/Ice/Buffer.h
+index 6f7ebab..bbde0df 100644
+--- cpp/include/Ice/Buffer.h
++++ cpp.orig/include/Ice/Buffer.h
+@@ -10,6 +10,7 @@
+ #ifndef ICEE_BUFFER_H
+ #define ICEE_BUFFER_H
+ 
++#include <cstddef>
+ #include <Ice/Config.h>
+ 
+ namespace IceInternal
+diff --git cpp.old/include/Ice/ConnectionIF.h cpp/include/Ice/ConnectionIF.h
+index ca954c0..81ceb01 100644
+--- cpp/include/Ice/ConnectionIF.h
++++ cpp.orig/include/Ice/ConnectionIF.h
+@@ -17,13 +17,13 @@ namespace Ice
+ {
+ 
+ class ConnectionI;
++ICE_API Ice::LocalObject* upCast(Ice::ConnectionI*);
+ 
+ }
+ 
+ namespace IceInternal
+ {
+ 
+-ICE_API Ice::LocalObject* upCast(Ice::ConnectionI*);
+ 
+ enum AsyncStatus
+ {
+diff --git cpp.old/include/Ice/IconvStringConverter.h cpp/include/Ice/IconvStringConverter.h
+index 017fb1e..68aa54b 100644
+--- cpp/include/Ice/IconvStringConverter.h
++++ cpp.orig/include/Ice/IconvStringConverter.h
+@@ -225,10 +225,16 @@ IconvStringConverter<charT>::cleanupKey(void* val)
+ template<typename charT> /*static*/ void
+ IconvStringConverter<charT>::close(std::pair<iconv_t, iconv_t> cdp)
+ {
+-    int rs = iconv_close(cdp.first);
++#ifndef NDEBUG
++    int rs = 
++#endif
++    iconv_close(cdp.first);
+     assert(rs == 0);
+ 
+-    rs = iconv_close(cdp.second);
++#ifndef NDEBUG
++    rs = 
++#endif
++    iconv_close(cdp.second);
+     assert(rs == 0);
+ }
+  
+diff --git cpp.old/include/Ice/IncomingAsyncF.h cpp/include/Ice/IncomingAsyncF.h
+index 7d9228a..d861180 100644
+--- cpp/include/Ice/IncomingAsyncF.h
++++ cpp.orig/include/Ice/IncomingAsyncF.h
+@@ -28,12 +28,6 @@ namespace Ice
+ 
+ class AMD_Object_ice_invoke;
+ class AMD_Array_Object_ice_invoke;
+-
+-}
+-
+-namespace IceInternal
+-{
+-
+ ICE_API IceUtil::Shared* upCast(::Ice::AMD_Object_ice_invoke*);
+ ICE_API IceUtil::Shared* upCast(::Ice::AMD_Array_Object_ice_invoke*);
+ 
+diff --git cpp.old/include/Ice/LocalObjectF.h cpp/include/Ice/LocalObjectF.h
+index 69a28d3..6e613b7 100644
+--- cpp/include/Ice/LocalObjectF.h
++++ cpp.orig/include/Ice/LocalObjectF.h
+@@ -18,12 +18,6 @@ namespace Ice
+ {
+ 
+ class LocalObject;
+-
+-}
+-
+-namespace IceInternal
+-{
+-
+ ICE_API IceUtil::Shared* upCast(::Ice::LocalObject*);
+ 
+ }
+diff --git cpp.old/include/Ice/ObjectF.h cpp/include/Ice/ObjectF.h
+index eaabadd..2baff11 100644
+--- cpp/include/Ice/ObjectF.h
++++ cpp.orig/include/Ice/ObjectF.h
+@@ -17,19 +17,8 @@ namespace Ice
+ {
+ 
+ class Object;
+-
+-}
+-
+-namespace IceInternal
+-{
+-
+ ICE_API IceUtil::Shared* upCast(::Ice::Object*);
+ 
+-}
+-
+-namespace Ice
+-{
+-
+ typedef IceInternal::Handle< Object > ObjectPtr;
+ 
+ void ICE_API __patch__ObjectPtr(void*, ObjectPtr&);
+diff --git cpp.old/include/Ice/OutgoingAsyncF.h cpp/include/Ice/OutgoingAsyncF.h
+index 0e9398c..334ca7a 100644
+--- cpp/include/Ice/OutgoingAsyncF.h
++++ cpp.orig/include/Ice/OutgoingAsyncF.h
+@@ -19,13 +19,13 @@ namespace Ice
+ 
+ class AsyncResult;
+ typedef IceInternal::Handle<AsyncResult> AsyncResultPtr;
++ICE_API IceUtil::Shared* upCast(::Ice::AsyncResult*);
+ 
+ }
+ 
+ namespace IceInternal
+ {
+ 
+-ICE_API IceUtil::Shared* upCast(::Ice::AsyncResult*);
+ 
+ class OutgoingAsync;
+ ICE_API IceUtil::Shared* upCast(OutgoingAsync*);
+diff --git cpp.old/include/Ice/Proxy.h cpp/include/Ice/Proxy.h
+index 250c700..0ae9e72 100644
+--- cpp/include/Ice/Proxy.h
++++ cpp.orig/include/Ice/Proxy.h
+@@ -38,6 +38,8 @@ namespace Ice
+ 
+ class Locator;
+ class Router;
++ICE_API ::IceProxy::Ice::Object* upCast(::IceProxy::Ice::Locator*);
++ICE_API ::IceProxy::Ice::Object* upCast(::IceProxy::Ice::Router*);
+ 
+ }
+ 
+@@ -46,8 +48,6 @@ class Router;
+ namespace IceInternal
+ {
+ 
+-ICE_API ::IceProxy::Ice::Object* upCast(::IceProxy::Ice::Locator*);
+-ICE_API ::IceProxy::Ice::Object* upCast(::IceProxy::Ice::Router*);
+ 
+ class LocalExceptionWrapper;
+ 
+@@ -1172,7 +1172,7 @@ public:
+ 
+     TwowayCallbackNC(const TPtr& instance, bool cb, Exception excb, Sent sentcb) : CallbackNC<T>(instance, excb, sentcb)
+     {
+-        checkCallback(instance, cb || excb != 0);
++        this->checkCallback(instance, cb || excb != 0);
+     }
+ };
+ 
+@@ -1188,7 +1188,7 @@ public:
+ 
+     TwowayCallback(const TPtr& instance, bool cb, Exception excb, Sent sentcb) : Callback<T, CT>(instance, excb, sentcb)
+     {
+-        checkCallback(instance, cb || excb != 0);
++        this->checkCallback(instance, cb || excb != 0);
+     }
+ };
+ 
+@@ -1209,7 +1209,7 @@ public:
+     OnewayCallbackNC(const TPtr& instance, Response cb, Exception excb, Sent sentcb) : 
+         CallbackNC<T>(instance, excb, sentcb), response(cb)
+     {
+-        checkCallback(instance, cb != 0 || excb != 0);
++        this->checkCallback(instance, cb != 0 || excb != 0);
+     }
+ 
+     virtual void __completed(const ::Ice::AsyncResultPtr& result) const
+@@ -1254,7 +1254,7 @@ public:
+     OnewayCallback(const TPtr& instance, Response cb, Exception excb, Sent sentcb) : 
+         Callback<T, CT>(instance, excb, sentcb),  response(cb)
+     {
+-        checkCallback(instance, cb != 0 || excb != 0);
++        this->checkCallback(instance, cb != 0 || excb != 0);
+     }
+ 
+     virtual void __completed(const ::Ice::AsyncResultPtr& result) const
+diff --git cpp.old/include/Ice/ProxyF.h cpp/include/Ice/ProxyF.h
+index 27b7ec6..67b2b05 100644
+--- cpp/include/Ice/ProxyF.h
++++ cpp.orig/include/Ice/ProxyF.h
+@@ -22,6 +22,11 @@ namespace Ice
+ {
+ 
+ class Object;
++inline ::IceProxy::Ice::Object* 
++upCast(::IceProxy::Ice::Object* o)
++{
++    return o;
++}
+ 
+ }
+ 
+@@ -34,6 +39,11 @@ namespace Ice
+ {
+ 
+ class Object;
++inline ::IceDelegate::Ice::Object*
++upCast(::IceDelegate::Ice::Object* o)
++{
++    return o;
++}
+ 
+ }
+ 
+@@ -47,6 +57,12 @@ namespace Ice
+ 
+ class Object;
+ 
++inline ::IceDelegateM::Ice::Object*
++upCast(::IceDelegateM::Ice::Object* o)
++{
++    return o;
++}
++
+ }
+ 
+ }
+@@ -58,36 +74,12 @@ namespace Ice
+ {
+ 
+ class Object;
+-
+-}
+-
+-}
+-
+-namespace IceInternal
+-{
+-
+-inline ::IceProxy::Ice::Object* 
+-upCast(::IceProxy::Ice::Object* o)
+-{
+-    return o;
+-}
+-
+-inline ::IceDelegate::Ice::Object*
+-upCast(::IceDelegate::Ice::Object* o)
+-{
+-    return o;
+-}
+-
+ inline ::IceDelegateD::Ice::Object*
+ upCast(::IceDelegateD::Ice::Object* o)
+ {
+     return o;
+ }
+ 
+-inline ::IceDelegateM::Ice::Object*
+-upCast(::IceDelegateM::Ice::Object* o)
+-{
+-    return o;
+ }
+ 
+ }
+diff --git cpp.old/include/Ice/Stream.h cpp/include/Ice/Stream.h
+index 40cd611..36ab56b 100644
+--- cpp/include/Ice/Stream.h
++++ cpp.orig/include/Ice/Stream.h
+@@ -17,6 +17,12 @@
+ #include <Ice/Proxy.h>
+ #include <IceUtil/Shared.h>
+ 
++namespace IceInternal
++{
++    // Forward declaration required for writer specializations.
++    void delegateThrowMarshalException(const char*, int, const ::std::string&);
++}
++
+ namespace Ice
+ {
+     
+@@ -45,9 +51,6 @@ enum StreamTraitType
+     StreamTraitTypeUnknown
+ };
+ 
+-// Forward declaration required for writer specializations.
+-class MarshalException;
+-
+ //
+ // Base trait template. This doesn't actually do anything -- we just
+ // use it as a template that we can specialize.
+@@ -542,7 +545,7 @@ struct StreamWriter<StreamTraitTypeByteEnum>
+     {
+         if(static_cast<int>(v) < 0 || static_cast<int>(v) >= StreamTrait<T>::enumLimit)
+         {
+-            throw MarshalException(__FILE__, __LINE__, "enumerator out of range");
++            IceInternal::delegateThrowMarshalException(__FILE__, __LINE__, "enumerator out of range");
+         }
+         outS->write(static_cast<Byte>(v));
+     }
+@@ -558,7 +561,7 @@ struct StreamReader<StreamTraitTypeByteEnum>
+         inS->read(val);
+         if(val > StreamTrait<T>::enumLimit)
+         {
+-            throw MarshalException(__FILE__, __LINE__, "enumerator out of range");
++            IceInternal::delegateThrowMarshalException(__FILE__, __LINE__, "enumerator out of range");
+         }
+         v = static_cast<T>(val);
+     }
+@@ -573,7 +576,7 @@ struct StreamWriter<StreamTraitTypeShortEnum>
+     {
+         if(static_cast<int>(v) < 0 || static_cast<int>(v) >= StreamTrait<T>::enumLimit)
+         {
+-            throw MarshalException(__FILE__, __LINE__, "enumerator out of range");
++            IceInternal::delegateThrowMarshalException(__FILE__, __LINE__, "enumerator out of range");
+         }
+         outS->write(static_cast<Short>(v));
+     }
+@@ -589,7 +592,7 @@ struct StreamReader<StreamTraitTypeShortEnum>
+         inS->read(val);
+         if(val < 0 || val > StreamTrait<T>::enumLimit)
+         {
+-            throw MarshalException(__FILE__, __LINE__, "enumerator out of range");
++            IceInternal::delegateThrowMarshalException(__FILE__, __LINE__, "enumerator out of range");
+         }
+         v = static_cast<T>(val);
+     }
+@@ -603,7 +606,7 @@ struct StreamWriter<StreamTraitTypeIntEnum>
+     {
+         if(static_cast<int>(v) < 0 || static_cast<int>(v) >= StreamTrait<T>::enumLimit)
+         {
+-            throw MarshalException(__FILE__, __LINE__, "enumerator out of range");
++            IceInternal::delegateThrowMarshalException(__FILE__, __LINE__, "enumerator out of range");
+         }
+         outS->write(static_cast<Int>(v));
+     }
+@@ -619,7 +622,7 @@ struct StreamReader<StreamTraitTypeIntEnum>
+         inS->read(val);
+         if(val < 0 || val > StreamTrait<T>::enumLimit)
+         {
+-            throw MarshalException(__FILE__, __LINE__, "enumerator out of range");
++            IceInternal::delegateThrowMarshalException(__FILE__, __LINE__, "enumerator out of range");
+         }
+         v = static_cast<T>(val);
+     }
+diff --git cpp.old/include/Ice/StreamF.h cpp/include/Ice/StreamF.h
+index d94ba2b..f114206 100644
+--- cpp/include/Ice/StreamF.h
++++ cpp.orig/include/Ice/StreamF.h
+@@ -19,12 +19,6 @@ namespace Ice
+ 
+ class InputStream;
+ class OutputStream;
+-
+-}
+-
+-namespace IceInternal
+-{
+-
+ ICE_API IceUtil::Shared* upCast(::Ice::InputStream*);
+ ICE_API IceUtil::Shared* upCast(::Ice::OutputStream*);
+ 
+diff --git cpp.old/include/IceUtil/Mutex.h cpp/include/IceUtil/Mutex.h
+index 2726c74..5d72113 100644
+--- cpp/include/IceUtil/Mutex.h
++++ cpp.orig/include/IceUtil/Mutex.h
+@@ -251,8 +251,11 @@ Mutex::init(MutexProtocol protocol)
+ inline
+ Mutex::~Mutex()
+ {
++#ifndef NDEBUG
+     int rc = 0;
+-    rc = pthread_mutex_destroy(&_mutex);
++    rc = 
++#endif    
++    pthread_mutex_destroy(&_mutex);
+     assert(rc == 0);
+ }
+ 
+diff --git cpp.old/src/Freeze/MapDb.cpp cpp/src/Freeze/MapDb.cpp
+index ad573cf..397151e 100644
+--- cpp/src/Freeze/MapDb.cpp
++++ cpp.orig/src/Freeze/MapDb.cpp
+@@ -229,7 +229,11 @@ Freeze::MapDb::MapDb(const ConnectionIPtr& connection,
+ #ifndef NDEBUG
+                 bool inserted = 
+ #endif
+-                    _indices.insert(IndexMap::value_type(indexBase->name(), indexI.get())).second;
++                    _indices.insert(IndexMap::value_type(indexBase->name(), indexI.get()))
++#ifndef NDEBUG                    
++                    .second
++#endif
++                ;
+                 assert(inserted);
+                 
+                 indexBase->_impl = indexI.release();
+diff --git cpp.old/src/Freeze/MapI.cpp cpp/src/Freeze/MapI.cpp
+index c7f0719..820cef8 100644
+--- cpp/src/Freeze/MapI.cpp
++++ cpp.orig/src/Freeze/MapI.cpp
+@@ -749,8 +749,11 @@ Freeze::IteratorHelperI::set(const Value& value)
+ 
+     try
+     {
++#ifndef NDEBUG
+         int err;
+-        err = _dbc->put(&dbKey, &dbValue, DB_CURRENT);
++        err = 
++#endif
++        _dbc->put(&dbKey, &dbValue, DB_CURRENT);
+         assert(err == 0);
+     }
+     catch(const ::DbDeadlockException& dx)
+@@ -1023,7 +1026,11 @@ Freeze::MapHelperI::MapHelperI(const ConnectionIPtr& connection,
+ #ifndef NDEBUG
+         bool inserted =
+ #endif 
+-            _indices.insert(IndexMap::value_type(indexBase->name(), indexBase)).second;
++            _indices.insert(IndexMap::value_type(indexBase->name(), indexBase))
++#ifndef NDEBUG
++            .second
++#endif
++            ;
+         assert(inserted);
+         indexBase->_map = this;
+     }
+@@ -1360,8 +1367,11 @@ Freeze::MapHelperI::clear()
+         try
+         {
+             u_int32_t count;
++#ifndef NDEBUG
+             int err;
+-            err = _db->truncate(txn, &count, txn != 0 ? 0 : DB_AUTO_COMMIT);
++            err = 
++#endif            
++            _db->truncate(txn, &count, txn != 0 ? 0 : DB_AUTO_COMMIT);
+             assert(err == 0);
+             break;
+         }
+diff --git cpp.old/src/Freeze/SharedDbEnv.cpp cpp/src/Freeze/SharedDbEnv.cpp
+index 1365e7f..8cadc0c 100644
+--- cpp/src/Freeze/SharedDbEnv.cpp
++++ cpp.orig/src/Freeze/SharedDbEnv.cpp
+@@ -336,8 +336,11 @@ void Freeze::SharedDbEnv::__decRef()
+         // Remove from map
+         //
+      
++#ifndef NDEBUG
+         size_t one;
+-        one = sharedDbEnvMap->erase(key);
++        one = 
++#endif
++        sharedDbEnvMap->erase(key);
+         assert(one == 1);
+ 
+         if(sharedDbEnvMap->size() == 0)
+diff --git cpp.old/src/Ice/ConnectionI.cpp cpp/src/Ice/ConnectionI.cpp
+index 2d942ca..00539f3 100644
+--- cpp/src/Ice/ConnectionI.cpp
++++ cpp.orig/src/Ice/ConnectionI.cpp
+@@ -31,7 +31,7 @@ using namespace std;
+ using namespace Ice;
+ using namespace IceInternal;
+ 
+-Ice::LocalObject* IceInternal::upCast(ConnectionI* p) { return p; }
++Ice::LocalObject* Ice::upCast(ConnectionI* p) { return p; }
+ 
+ namespace
+ {
+@@ -600,6 +600,7 @@ Ice::ConnectionI::sendAsyncRequest(const OutgoingAsyncPtr& out, bool compress, b
+     }
+     catch(const LocalException& ex)
+     {
++        status = IceInternal::AsyncStatusQueued; // this is only to apeace the compiler
+         setState(StateClosed, ex);
+         assert(_exception.get());
+         _exception->ice_throw();
+@@ -971,6 +972,7 @@ Ice::ConnectionI::flushAsyncBatchRequests(const BatchOutgoingAsyncPtr& outAsync)
+     }
+     catch(const Ice::LocalException& ex)
+     {
++        status = IceInternal::AsyncStatusQueued; // this is only to apeace the compiler
+         setState(StateClosed, ex);
+         assert(_exception.get());
+         _exception->ice_throw();
+diff --git cpp.old/src/Ice/IncomingAsync.cpp cpp/src/Ice/IncomingAsync.cpp
+index ca108ee..91c0580 100644
+--- cpp/src/Ice/IncomingAsync.cpp
++++ cpp.orig/src/Ice/IncomingAsync.cpp
+@@ -24,7 +24,7 @@ using namespace Ice;
+ using namespace IceInternal;
+ 
+ IceUtil::Shared* IceInternal::upCast(IncomingAsync* p) { return p; }
+-IceUtil::Shared* IceInternal::upCast(AMD_Object_ice_invoke* p) { return p; }
++IceUtil::Shared* Ice::upCast(AMD_Object_ice_invoke* p) { return p; }
+ 
+ namespace
+ {
+diff --git cpp.old/src/Ice/LocalObject.cpp cpp/src/Ice/LocalObject.cpp
+index 77bee3d..ee74c0b 100644
+--- cpp/src/Ice/LocalObject.cpp
++++ cpp.orig/src/Ice/LocalObject.cpp
+@@ -13,7 +13,7 @@ using namespace std;
+ using namespace Ice;
+ using namespace IceInternal;
+ 
+-IceUtil::Shared* IceInternal::upCast(LocalObject* obj) { return obj; }
++IceUtil::Shared* Ice::upCast(LocalObject* obj) { return obj; }
+ 
+ bool
+ Ice::LocalObject::operator==(const LocalObject& r) const
+diff --git cpp.old/src/Ice/Object.cpp cpp/src/Ice/Object.cpp
+index fa7793a..9705ce9 100644
+--- cpp/src/Ice/Object.cpp
++++ cpp.orig/src/Ice/Object.cpp
+@@ -19,7 +19,7 @@ using namespace std;
+ using namespace Ice;
+ using namespace IceInternal;
+ 
+-IceUtil::Shared* IceInternal::upCast(Object* p) { return p; }
++IceUtil::Shared* Ice::upCast(Object* p) { return p; }
+ 
+ bool
+ Ice::Object::operator==(const Object& r) const
+diff --git cpp.old/src/Ice/OutgoingAsync.cpp cpp/src/Ice/OutgoingAsync.cpp
+index 527d29c..d707321 100644
+--- cpp/src/Ice/OutgoingAsync.cpp
++++ cpp.orig/src/Ice/OutgoingAsync.cpp
+@@ -30,7 +30,7 @@ using namespace std;
+ using namespace Ice;
+ using namespace IceInternal;
+ 
+-IceUtil::Shared* IceInternal::upCast(AsyncResult* p) { return p; }
++IceUtil::Shared* Ice::upCast(AsyncResult* p) { return p; }
+ 
+ IceUtil::Shared* IceInternal::upCast(OutgoingAsyncMessageCallback* p) { return p; }
+ IceUtil::Shared* IceInternal::upCast(OutgoingAsync* p) { return p; }
+diff --git cpp.old/src/Ice/ProxyFactory.cpp cpp/src/Ice/ProxyFactory.cpp
+index c68b3e3..db0fe72 100644
+--- cpp/src/Ice/ProxyFactory.cpp
++++ cpp.orig/src/Ice/ProxyFactory.cpp
+@@ -229,6 +229,7 @@ IceInternal::ProxyFactory::checkRetryAfterException(const LocalException& ex,
+     } 
+     else if(cnt > static_cast<int>(_retryIntervals.size()))
+     {
++        interval = 0; // apeace compiler
+         if(traceLevels->retry >= 1)
+         {
+             Trace out(logger, traceLevels->retryCat);
+diff --git cpp.old/src/Ice/Service.cpp cpp/src/Ice/Service.cpp
+index dd28221..cc95541 100644
+--- cpp/src/Ice/Service.cpp
++++ cpp.orig/src/Ice/Service.cpp
+@@ -2136,17 +2136,26 @@ Ice::Service::runDaemon(int argc, char* argv[], const InitializationData& initDa
+             //
+             // Associate stdin, stdout and stderr with /dev/null.
+             //
++#ifndef NDEBUG
+             int fd;
+-            fd = open("/dev/null", O_RDWR);
++            fd = 
++#endif
++            open("/dev/null", O_RDWR);
+             assert(fd == 0);
+             if(stdOut.empty())
+             {
+-                fd = dup2(0, 1);
++#ifndef NDEBUG
++                fd = 
++#endif
++                dup2(0, 1);
+                 assert(fd == 1);
+             }
+             if(stdErr.empty())
+             {
+-                fd = dup2(1, 2);
++#ifndef NDEBUG
++                fd = 
++#endif
++                dup2(1, 2);
+                 assert(fd == 2);
+             }
+         }
+diff --git cpp.old/src/Ice/Stream.cpp cpp/src/Ice/Stream.cpp
+index 9924da0..2ecdc08 100644
+--- cpp/src/Ice/Stream.cpp
++++ cpp.orig/src/Ice/Stream.cpp
+@@ -8,10 +8,19 @@
+ // **********************************************************************
+ 
+ #include <Ice/Stream.h>
++#include <Ice/LocalException.h>
+ 
+ using namespace std;
+ using namespace Ice;
+ using namespace IceInternal;
+ 
+-IceUtil::Shared* IceInternal::upCast(InputStream* p) { return p; }
+-IceUtil::Shared* IceInternal::upCast(OutputStream* p) { return p; }
++IceUtil::Shared* Ice::upCast(InputStream* p) { return p; }
++IceUtil::Shared* Ice::upCast(OutputStream* p) { return p; }
++
++namespace IceInternal
++{
++  void delegateThrowMarshalException(const char* file, int line , const ::std::string& message)
++  {
++    throw Ice::MarshalException(file, line, message);
++  }
++}
+diff --git cpp.old/src/IceGrid/AdminCallbackRouter.cpp cpp/src/IceGrid/AdminCallbackRouter.cpp
+index e4d21ef..ce63c9f 100644
+--- cpp/src/IceGrid/AdminCallbackRouter.cpp
++++ cpp.orig/src/IceGrid/AdminCallbackRouter.cpp
+@@ -49,7 +49,12 @@ IceGrid::AdminCallbackRouter::addMapping(const string& category, const Connectio
+ #ifndef NDEBUG
+     bool inserted =
+ #endif
+-        _categoryToConnection.insert(map<string, ConnectionPtr>::value_type(category, con)).second;
++        _categoryToConnection.insert(map<string, ConnectionPtr>::value_type(category, con))
++#ifndef NDEBUG
++        .second
++#endif
++        ;
++
+     
+     assert(inserted == true);
+ }
+diff --git cpp.old/src/IceGrid/DescriptorHelper.cpp cpp/src/IceGrid/DescriptorHelper.cpp
+index 9126c2f..0bc0111 100644
+--- cpp/src/IceGrid/DescriptorHelper.cpp
++++ cpp.orig/src/IceGrid/DescriptorHelper.cpp
+@@ -198,15 +198,6 @@ updateSeqElts(const Seq& seq, const Seq& update, const Ice::StringSeq& remove, G
+     return result;
+ }
+ 
+-template<typename Dict> Dict
+-getDictUpdatedElts(const Dict& ldict, const Dict& rdict)
+-{
+-#if defined(_MSC_VER) && (_MSC_VER < 1300)
+-    return getDictUpdatedEltsWithEq(ldict, rdict, equal_to<Dict::mapped_type>());
+-#else
+-    return getDictUpdatedEltsWithEq(ldict, rdict, equal_to<typename Dict::mapped_type>());
+-#endif
+-}
+ 
+ template<typename EqFunc, typename Dict> Dict
+ getDictUpdatedEltsWithEq(const Dict& ldict, const Dict& rdict, EqFunc eq)
+@@ -223,6 +214,16 @@ getDictUpdatedEltsWithEq(const Dict& ldict, const Dict& rdict, EqFunc eq)
+     return result;
+ }
+ 
++template<typename Dict> Dict
++getDictUpdatedElts(const Dict& ldict, const Dict& rdict)
++{
++#if defined(_MSC_VER) && (_MSC_VER < 1300)
++    return getDictUpdatedEltsWithEq(ldict, rdict, equal_to<Dict::mapped_type>());
++#else
++    return getDictUpdatedEltsWithEq(ldict, rdict, equal_to<typename Dict::mapped_type>());
++#endif
++}
++
+ template <typename Dict> Ice::StringSeq
+ getDictRemovedElts(const Dict& ldict, const Dict& rdict)
+ {
+diff --git cpp.old/src/IceGrid/ReplicaCache.cpp cpp/src/IceGrid/ReplicaCache.cpp
+index 53ad03e..154853d 100644
+--- cpp/src/IceGrid/ReplicaCache.cpp
++++ cpp.orig/src/IceGrid/ReplicaCache.cpp
+@@ -40,7 +40,7 @@ ReplicaCache::add(const string& name, const ReplicaSessionIPtr& session)
+     Lock sync(*this);
+     
+     ReplicaEntryPtr entry;
+-    while(entry = getImpl(name))
++    while((entry = getImpl(name)))
+     {
+         ReplicaSessionIPtr session = entry->getSession();
+         if(session->isDestroyed())
+diff --git cpp.old/src/IceGrid/SessionI.h cpp/src/IceGrid/SessionI.h
+index 3c67e20..f5c1b2e 100644
+--- cpp/src/IceGrid/SessionI.h
++++ cpp.orig/src/IceGrid/SessionI.h
+@@ -35,7 +35,7 @@ typedef IceUtil::Handle<Allocatable> AllocatablePtr;
+ class SessionI;
+ typedef IceUtil::Handle<SessionI> SessionIPtr;
+ 
+-class BaseSessionI : virtual Ice::Object, public IceUtil::Mutex
++class BaseSessionI : virtual public Ice::Object, public IceUtil::Mutex
+ {
+ public:
+ 
+diff --git cpp.old/src/IceSSL/Instance.cpp cpp/src/IceSSL/Instance.cpp
+index 5eb4c58..585620c 100644
+--- cpp/src/IceSSL/Instance.cpp
++++ cpp.orig/src/IceSSL/Instance.cpp
+@@ -38,7 +38,7 @@ using namespace std;
+ using namespace Ice;
+ using namespace IceSSL;
+ 
+-IceUtil::Shared* IceInternal::upCast(IceSSL::Instance* p) { return p; }
++IceUtil::Shared* IceSSL::upCast(IceSSL::Instance* p) { return p; }
+ 
+ namespace
+ {
+diff --git cpp.old/src/IceSSL/InstanceF.h cpp/src/IceSSL/InstanceF.h
+index d08a3a9..b03d995 100644
+--- cpp/src/IceSSL/InstanceF.h
++++ cpp.orig/src/IceSSL/InstanceF.h
+@@ -18,13 +18,13 @@ namespace IceSSL
+ {
+ 
+ class Instance;
++IceUtil::Shared* upCast(IceSSL::Instance*);
+ 
+ }
+ 
+ namespace IceInternal
+ {
+ 
+-IceUtil::Shared* upCast(IceSSL::Instance*);
+ 
+ }
+ 
+diff --git cpp.old/src/IceSSL/TrustManager.cpp cpp/src/IceSSL/TrustManager.cpp
+index 0ec6e28..c4549b9 100644
+--- cpp/src/IceSSL/TrustManager.cpp
++++ cpp.orig/src/IceSSL/TrustManager.cpp
+@@ -20,7 +20,7 @@
+ using namespace std;
+ using namespace IceSSL;
+ 
+-IceUtil::Shared* IceInternal::upCast(IceSSL::TrustManager* p) { return p; }
++IceUtil::Shared* IceSSL::upCast(IceSSL::TrustManager* p) { return p; }
+ 
+ TrustManager::TrustManager(const Ice::CommunicatorPtr& communicator) :
+     _communicator(communicator)
+diff --git cpp.old/src/IceSSL/TrustManagerF.h cpp/src/IceSSL/TrustManagerF.h
+index 346775c..e1af0d1 100644
+--- cpp/src/IceSSL/TrustManagerF.h
++++ cpp.orig/src/IceSSL/TrustManagerF.h
+@@ -18,13 +18,13 @@ namespace IceSSL
+ {
+ 
+ class TrustManager;
++IceUtil::Shared* upCast(IceSSL::TrustManager*);
+ 
+ }
+ 
+ namespace IceInternal
+ {
+ 
+-IceUtil::Shared* upCast(IceSSL::TrustManager*);
+ 
+ }
+ 
+diff --git cpp.old/src/IceSSL/Util.cpp cpp/src/IceSSL/Util.cpp
+index fc7e19c..63f6b44 100644
+--- cpp/src/IceSSL/Util.cpp
++++ cpp.orig/src/IceSSL/Util.cpp
+@@ -175,7 +175,7 @@ convertDH(unsigned char* p, int plen, unsigned char* g, int glen)
+     return dh;
+ }
+ 
+-IceUtil::Shared* IceInternal::upCast(IceSSL::DHParams* p) { return p; }
++IceUtil::Shared* IceSSL::upCast(IceSSL::DHParams* p) { return p; }
+ 
+ IceSSL::DHParams::DHParams() :
+     _dh512(0), _dh1024(0), _dh2048(0), _dh4096(0)
+diff --git cpp.old/src/IceSSL/UtilF.h cpp/src/IceSSL/UtilF.h
+index 4c06e1f..5bad4c8 100644
+--- cpp/src/IceSSL/UtilF.h
++++ cpp.orig/src/IceSSL/UtilF.h
+@@ -21,13 +21,13 @@ namespace IceSSL
+ {
+ 
+ class DHParams;
++IceUtil::Shared* upCast(IceSSL::DHParams*);
+ 
+ }
+ 
+ namespace IceInternal
+ {
+ 
+-IceUtil::Shared* upCast(IceSSL::DHParams*);
+ 
+ }
+ 
+diff --git cpp.old/src/IceStorm/NodeI.cpp cpp/src/IceStorm/NodeI.cpp
+index 0c9511e..b9788f4 100644
+--- cpp/src/IceStorm/NodeI.cpp
++++ cpp.orig/src/IceStorm/NodeI.cpp
+@@ -18,11 +18,6 @@ using namespace std;
+ namespace
+ {
+ 
+-bool operator==(const GroupNodeInfo& info, int id)
+-{
+-    return info.id == id;
+-}
+-
+ class CheckTask : public IceUtil::TimerTask
+ {
+     const NodeIPtr _node;
+diff --git cpp.old/src/IceUtil/Cond.cpp cpp/src/IceUtil/Cond.cpp
+index 6a8bd3d..a18fd61 100644
+--- cpp/src/IceUtil/Cond.cpp
++++ cpp.orig/src/IceUtil/Cond.cpp
+@@ -330,8 +330,11 @@ IceUtil::Cond::Cond()
+ 
+ IceUtil::Cond::~Cond()
+ {
++#ifndef NDEBUG
+     int rc = 0;
+-    rc = pthread_cond_destroy(&_cond);
++    rc = 
++#endif
++    pthread_cond_destroy(&_cond);
+     assert(rc == 0);
+ }
+ 
+diff --git cpp.old/src/IceUtil/CountDownLatch.cpp cpp/src/IceUtil/CountDownLatch.cpp
+index bd60766..86e8d2c 100644
+--- cpp/src/IceUtil/CountDownLatch.cpp
++++ cpp.orig/src/IceUtil/CountDownLatch.cpp
+@@ -44,10 +44,16 @@ IceUtilInternal::CountDownLatch::~CountDownLatch()
+ #ifdef _WIN32
+     CloseHandle(_event);
+ #else
++#ifndef NDEBUG
+     int rc = 0;
+-    rc = pthread_mutex_destroy(&_mutex);
++    rc = 
++#endif
++    pthread_mutex_destroy(&_mutex);
+     assert(rc == 0);
+-    rc = pthread_cond_destroy(&_cond);
++#ifndef NDEBUG
++    rc = 
++#endif
++    pthread_cond_destroy(&_cond);
+     assert(rc == 0);
+ #endif
+ }
+diff --git cpp.old/src/IceUtil/CtrlCHandler.cpp cpp/src/IceUtil/CtrlCHandler.cpp
+index f4d150c..575537a 100644
+--- cpp/src/IceUtil/CtrlCHandler.cpp
++++ cpp.orig/src/IceUtil/CtrlCHandler.cpp
+@@ -219,18 +219,27 @@ CtrlCHandler::CtrlCHandler(CtrlCHandlerCallback callback)
+         sigaddset(&ctrlCLikeSignals, SIGHUP);
+         sigaddset(&ctrlCLikeSignals, SIGINT);
+         sigaddset(&ctrlCLikeSignals, SIGTERM);
+-        int rc = pthread_sigmask(SIG_BLOCK, &ctrlCLikeSignals, 0);
++#ifndef NDEBUG
++        int rc = 
++#endif        
++        pthread_sigmask(SIG_BLOCK, &ctrlCLikeSignals, 0);
+         assert(rc == 0);
+ 
+         // Joinable thread
+-        rc = pthread_create(&_tid, 0, sigwaitThread, 0);
++#ifndef NDEBUG
++        rc = 
++#endif
++        pthread_create(&_tid, 0, sigwaitThread, 0);
+         assert(rc == 0);
+     }
+ }
+ 
+ CtrlCHandler::~CtrlCHandler()
+ {
+-    int rc = pthread_cancel(_tid);
++#ifndef NDEBUG
++    int rc = 
++#endif
++    pthread_cancel(_tid);
+     assert(rc == 0);
+ #if defined(__APPLE__)
+     //
+@@ -241,7 +250,10 @@ CtrlCHandler::~CtrlCHandler()
+     //assert(rc == 0); For some reaosns, this assert is sometime triggered
+ #endif
+     void* status = 0;
+-    rc = pthread_join(_tid, &status);
++#ifndef NDEBUG
++    rc = 
++#endif
++    pthread_join(_tid, &status);
+     assert(rc == 0);
+ #if !defined(__APPLE__)
+     assert(status == PTHREAD_CANCELED);
+diff --git cpp.old/src/IceUtil/FileUtil.cpp cpp/src/IceUtil/FileUtil.cpp
+index 1c1b974..0d7391d 100644
+--- cpp/src/IceUtil/FileUtil.cpp
++++ cpp.orig/src/IceUtil/FileUtil.cpp
+@@ -26,6 +26,10 @@
+ #  include <dir.h>
+ #endif
+ 
++#ifdef __FreeBSD__
++#  include <unistd.h>
++#endif
++
+ using namespace std;
+ 
+ //
+diff --git cpp.old/src/IceUtil/RecMutex.cpp cpp/src/IceUtil/RecMutex.cpp
+index f3b1376..ce719ad 100644
+--- cpp/src/IceUtil/RecMutex.cpp
++++ cpp.orig/src/IceUtil/RecMutex.cpp
+@@ -148,8 +148,11 @@ IceUtil::RecMutex::init(const MutexProtocol protocol)
+ IceUtil::RecMutex::~RecMutex()
+ {
+     assert(_count == 0);
++#ifndef NDEBUG
+     int rc = 0;
+-    rc = pthread_mutex_destroy(&_mutex);
++    rc = 
++#endif
++    pthread_mutex_destroy(&_mutex);
+     assert(rc == 0);
+ }
+ 
+@@ -196,8 +199,11 @@ IceUtil::RecMutex::unlock() const
+ {
+     if(--_count == 0)
+     {
++#ifndef NDEBUG
+         int rc = 0; // Prevent warnings when NDEBUG is defined.
+-        rc = pthread_mutex_unlock(&_mutex);
++        rc = 
++#endif
++        pthread_mutex_unlock(&_mutex);
+         assert(rc == 0);
+     }
+ }
+diff --git cpp.old/src/Slice/CPlusPlusUtil.cpp cpp/src/Slice/CPlusPlusUtil.cpp
+index f0d6a51..0d5024d 100644
+--- cpp/src/Slice/CPlusPlusUtil.cpp
++++ cpp.orig/src/Slice/CPlusPlusUtil.cpp
+@@ -631,7 +631,7 @@ Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, const string&
+         string scope = fixKwd(cl->scope());
+         if(marshal)
+         {
+-            out << nl << stream << deref << "write(::Ice::ObjectPtr(::IceInternal::upCast(" << fixedParam 
++            out << nl << stream << deref << "write(::Ice::ObjectPtr(" << scope << "upCast(" << fixedParam 
+                 << ".get())));";
+         }
+         else
+@@ -649,7 +649,7 @@ Slice::writeMarshalUnmarshalCode(Output& out, const TypePtr& type, const string&
+         string scope = fixKwd(px->_class()->scope());
+         if(marshal)
+         {
+-            out << nl << stream << deref << "write(::Ice::ObjectPrx(::IceInternal::upCast(" << fixedParam 
++            out << nl << stream << deref << "write(::Ice::ObjectPrx(::IceProxy" << scope << "upCast(" << fixedParam 
+                 << ".get())));";
+         }
+         else
+diff --git cpp.old/src/Slice/FileTracker.cpp cpp/src/Slice/FileTracker.cpp
+index af009fe..37a3048 100644
+--- cpp/src/Slice/FileTracker.cpp
++++ cpp.orig/src/Slice/FileTracker.cpp
+@@ -17,6 +17,10 @@
+ #   include <direct.h>
+ #endif
+ 
++#ifdef __FreeBSD__
++#   include <unistd.h>
++#endif
++
+ using namespace std;
+ 
+ Slice::FileException::FileException(const char* file, int line, const string& r) :
+diff --git cpp.old/src/slice2cpp/Gen.cpp cpp/src/slice2cpp/Gen.cpp
+index dfceb00..3509ea1 100644
+--- cpp/src/slice2cpp/Gen.cpp
++++ cpp.orig/src/slice2cpp/Gen.cpp
+@@ -1944,8 +1944,10 @@ Slice::Gen::ProxyDeclVisitor::visitClassDecl(const ClassDeclPtr& p)
+     }
+ 
+     string name = fixKwd(p->name());
++    string scoped = fixKwd(p->scoped());
+ 
+     H << sp << nl << "class " << name << ';';
++    H << nl << _dllExport << "::IceProxy::Ice::Object* upCast(::IceProxy" << scoped << "*);";
+ }
+ 
+ Slice::Gen::ProxyVisitor::ProxyVisitor(Output& h, Output& c, const string& dllExport) :
+@@ -3691,10 +3693,22 @@ void
+ Slice::Gen::ObjectDeclVisitor::visitClassDecl(const ClassDeclPtr& p)
+ {
+     string name = fixKwd(p->name());
++    string scoped = fixKwd(p->scoped());
+ 
+     H << sp << nl << "class " << name << ';';
+     H << nl << "bool operator==(const " << name << "&, const " << name << "&);";
+     H << nl << "bool operator<(const " << name << "&, const " << name << "&);";
++
++    H << sp;
++
++    if(!p->isLocal())
++    {
++        H << nl << _dllExport << "::Ice::Object* upCast(" << scoped << "*);";
++    }
++    else
++    {
++        H << nl << _dllExport << "::Ice::LocalObject* upCast(" << scoped << "*);";
++    }
+ }
+ 
+ void
+@@ -4922,13 +4936,13 @@ Slice::Gen::ObjectVisitor::emitGCInsertCode(const TypePtr& p, const string& pref
+ {
+     if((BuiltinPtr::dynamicCast(p) && BuiltinPtr::dynamicCast(p)->kind() == Builtin::KindObject)
+        || ClassDeclPtr::dynamicCast(p))
+-    {
+-        C << nl << "if(" << prefix << name << ')';
++    {        C << nl << "if(" << prefix << name << ')';
+         C << sb;
+         ClassDeclPtr decl = ClassDeclPtr::dynamicCast(p);
+         if(decl)
+         {
+-            C << nl << "::IceInternal::upCast(" << prefix << name << ".get())->__addObject(_c);";
++            string scope = fixKwd(decl->scope());
++            C << nl << scope << "upCast(" << prefix << name << ".get())->__addObject(_c);";
+         }
+         else
+         {
+@@ -4991,9 +5005,10 @@ Slice::Gen::ObjectVisitor::emitGCClearCode(const TypePtr& p, const string& prefi
+         ClassDeclPtr decl = ClassDeclPtr::dynamicCast(p);
+         if(decl)
+         {
+-            C << nl << "if(" << "::IceInternal::upCast(" << prefix << name << ".get())->__usesClasses())";
++            string scope = fixKwd(decl->scope());
++            C << nl << "if(" << scope << "upCast(" << prefix << name << ".get())->__usesClasses())";
+             C << sb;
+-            C << nl << "::IceInternal::upCast(" << prefix << name << ".get())->__decRefUnsafe();";
++            C << nl << scope << "upCast(" << prefix << name << ".get())->__decRefUnsafe();";
+             C << nl << prefix << name << ".__clearHandleUnsafe();";
+ 
+         }
+@@ -5629,40 +5644,30 @@ Slice::Gen::IceInternalVisitor::visitClassDecl(const ClassDeclPtr& p)
+ {
+     string scoped = fixKwd(p->scoped());
+ 
+-    H << sp;
+-
+-    if(!p->isLocal())
+-    {
+-        H << nl << _dllExport << "::Ice::Object* upCast(" << scoped << "*);";
+-        H << nl << _dllExport << "::IceProxy::Ice::Object* upCast(::IceProxy" << scoped << "*);";
+-    }
+-    else
+-    {
+-        H << nl << _dllExport << "::Ice::LocalObject* upCast(" << scoped << "*);";
+-    }
+ }
+ 
+ bool
+ Slice::Gen::IceInternalVisitor::visitClassDefStart(const ClassDefPtr& p)
+ {
+     string scoped = fixKwd(p->scoped());
++    string scope = fixKwd(p->scope());
+ 
+     C << sp;
+     if(!p->isLocal())
+     {
+         C << nl
+ 	  << (_dllExport.empty() ? "" : "ICE_DECLSPEC_EXPORT ")
+-	  << "::Ice::Object* IceInternal::upCast(" << scoped << "* p) { return p; }";
++	  << "::Ice::Object* " << scope << "upCast(" << scoped << "* p) { return p; }";
+         C << nl
+ 	  << (_dllExport.empty() ? "" : "ICE_DECLSPEC_EXPORT ")
+-	  << "::IceProxy::Ice::Object* IceInternal::upCast(::IceProxy" << scoped
++	  << "::IceProxy::Ice::Object* IceProxy" << scope << "upCast(::IceProxy" << scoped
+           << "* p) { return p; }";
+     }
+     else
+     {
+         C << nl
+ 	  << (_dllExport.empty() ? "" : "ICE_DECLSPEC_EXPORT ")
+-	  << "::Ice::LocalObject* IceInternal::upCast(" << scoped << "* p) { return p; }";
++	  << "::Ice::LocalObject* " << scope << "upCast(" << scoped << "* p) { return p; }";
+     }
+ 
+     return true;
+diff --git cpp.old/src/slice2cs/Gen.cpp cpp/src/slice2cs/Gen.cpp
+index 90d3136..dd5cf4f 100644
+--- cpp/src/slice2cs/Gen.cpp
++++ cpp.orig/src/slice2cs/Gen.cpp
+@@ -1281,7 +1281,7 @@ Slice::CsVisitor::writeConstantValue(const TypePtr& type, const SyntaxTreeBasePt
+         {
+             _out << value << "F";
+         }
+-        else if(ep = EnumPtr::dynamicCast(type))
++        else if((ep = EnumPtr::dynamicCast(type)))
+         {
+             string enumName = fixId(ep->scoped());
+             string::size_type colon = value.rfind(':');
+@@ -3914,16 +3914,6 @@ Slice::Gen::ProxyVisitor::visitOperation(const OperationPtr& p)
+     ClassDefPtr cl = ClassDefPtr::dynamicCast(p->container());
+     string name = fixId(p->name(), DotNet::ICloneable, true);
+     vector<string> params = getParams(p);
+-    bool hasOutParams = false;
+-    ParamDeclList paramList = p->parameters();
+-    for(ParamDeclList::const_iterator pli = paramList.begin(); pli != paramList.end(); ++pli)
+-    {
+-        if((*pli)->isOutParam())
+-        {
+-            hasOutParams = true;
+-            break;
+-        }
+-    }
+ 
+     _out << sp;
+ 
+diff --git cpp.old/src/slice2java/Gen.cpp cpp/src/slice2java/Gen.cpp
+index e0ac391..5dd7226 100644
+--- cpp/src/slice2java/Gen.cpp
++++ cpp.orig/src/slice2java/Gen.cpp
+@@ -1246,7 +1246,7 @@ Slice::JavaVisitor::writeConstantValue(Output& out, const TypePtr& type, const S
+     {
+         BuiltinPtr bp;
+         EnumPtr ep;
+-        if(bp = BuiltinPtr::dynamicCast(type))
++        if((bp = BuiltinPtr::dynamicCast(type)))
+         {
+             switch(bp->kind())
+             {
+@@ -1349,7 +1349,7 @@ Slice::JavaVisitor::writeConstantValue(Output& out, const TypePtr& type, const S
+             }
+ 
+         }
+-        else if(ep = EnumPtr::dynamicCast(type))
++        else if((ep = EnumPtr::dynamicCast(type)))
+         {
+             string val = value;
+             string::size_type pos = val.rfind(':');
+diff --git cpp.old/test/Glacier2/ssl/Server.cpp cpp/test/Glacier2/ssl/Server.cpp
+index 4fb14f5..1b0c6a5 100644
+--- cpp/test/Glacier2/ssl/Server.cpp
++++ cpp.orig/test/Glacier2/ssl/Server.cpp
+@@ -31,9 +31,15 @@ void testContext(bool ssl, const Ice::Context& context)
+         test(ctx["_con.type"] == "ssl");
+         test(ctx["_con.localPort"] == "12348");
+     }
+-    test(ctx["_con.localAddress"] == "127.0.0.1");
++    if (!inFreeBSDJail())
++    {
++        test(ctx["_con.localAddress"] == "127.0.0.1");
++    }
+     test(ctx["_con.remotePort"] != "");
+-    test(ctx["_con.remoteAddress"] == "127.0.0.1");
++    if (!inFreeBSDJail())
++    {
++        test(ctx["_con.remoteAddress"] == "127.0.0.1");
++    }
+ }
+ 
+ }
+@@ -99,7 +105,7 @@ public:
+     }
+ 
+     virtual void
+-    ice_ping(const Ice::Current& current)
++    ice_ping(const Ice::Current& current) const
+     {
+         testContext(_ssl, current.ctx);
+     }
+@@ -133,8 +139,11 @@ public:
+     {
+         testContext(true, current.ctx);
+ 
+-        test(info.remoteHost == "127.0.0.1");
+-        test(info.localHost == "127.0.0.1");
++        if (!inFreeBSDJail())
++        {
++            test(info.remoteHost == "127.0.0.1");
++            test(info.localHost == "127.0.0.1");
++        }
+         test(info.localPort == 12348);
+ 
+         try
+diff --git cpp.old/test/Ice/background/EndpointI.h cpp/test/Ice/background/EndpointI.h
+index f38a280..4d35f7d 100644
+--- cpp/test/Ice/background/EndpointI.h
++++ cpp.orig/test/Ice/background/EndpointI.h
+@@ -48,7 +48,7 @@ protected:
+ 
+     virtual Ice::Int hashInit() const;
+ #if !defined(_MSC_VER) || _MSC_VER > 1300
+-    using IceInternal::EndpointI::connectors;
++    using ::IceInternal::EndpointI::connectors;
+ #endif
+     
+ private:
+diff --git cpp.old/test/Ice/custom/AllTests.cpp cpp/test/Ice/custom/AllTests.cpp
+index bf66fa9..9907e6b 100644
+--- cpp/test/Ice/custom/AllTests.cpp
++++ cpp.orig/test/Ice/custom/AllTests.cpp
+@@ -1384,7 +1384,8 @@ public:
+                        const ::Test::ClassStructSeq& seq,
+                        const InParamPtr& cookie)
+     {
+-        pair< ::Test::ClassStructPtr, ::Test::ClassStructSeq> in = getIn(in, cookie);
++        pair< ::Test::ClassStructPtr, ::Test::ClassStructSeq> in;
++        in = getIn(in, cookie);
+         test(ret == in.first);
+         test(cs1 == in.first);
+         test(seq == in.second);
+@@ -1432,7 +1433,8 @@ public:
+ 
+     void throwExcept1(const Ice::AsyncResultPtr& result)
+     {
+-        wstring in = getIn(in, InParamPtr::dynamicCast(result->getCookie()));
++        wstring in;
++        in = getIn(in, InParamPtr::dynamicCast(result->getCookie()));
+         try
+         {
+             Test1::WstringClassPrx t = Test1::WstringClassPrx::uncheckedCast(result->getProxy());
+@@ -1451,7 +1453,8 @@ public:
+ 
+     void throwExcept2(const Ice::AsyncResultPtr& result)
+     {
+-        wstring in = getIn(in, InParamPtr::dynamicCast(result->getCookie()));
++        wstring in;
++        in = getIn(in, InParamPtr::dynamicCast(result->getCookie()));
+         try
+         {
+             Test2::WstringClassPrx t = Test2::WstringClassPrx::uncheckedCast(result->getProxy());
+diff --git cpp.old/test/Ice/info/AllTests.cpp cpp/test/Ice/info/AllTests.cpp
+index 3e9c229..7f92b7f 100644
+--- cpp/test/Ice/info/AllTests.cpp
++++ cpp.orig/test/Ice/info/AllTests.cpp
+@@ -141,9 +141,11 @@ allTests(const Ice::CommunicatorPtr& communicator)
+         test(info->adapterName.empty());
+         test(info->localPort > 0);
+         test(info->remotePort == 12010);
+-        test(info->remoteAddress == defaultHost);
+-        test(info->localAddress == defaultHost);
+-
++        if (!inFreeBSDJail())
++        {
++            test(info->remoteAddress == defaultHost);
++            test(info->localAddress == defaultHost);
++        }
+         ostringstream os;
+ 
+         Ice::Context ctx = testIntf->getConnectionInfoAsContext();
+@@ -163,8 +165,11 @@ allTests(const Ice::CommunicatorPtr& communicator)
+         test(info->adapterName.empty());
+         test(info->localPort > 0);
+         test(info->remotePort == 12010);
+-        test(info->remoteAddress ==defaultHost);
+-        test(info->localAddress == defaultHost);
++        if (!inFreeBSDJail())
++        {
++            test(info->remoteAddress == defaultHost);
++            test(info->localAddress == defaultHost);
++        }
+     }
+     cout << "ok" << endl;
+ 
+diff --git cpp.old/test/Ice/properties/run.py cpp/test/Ice/properties/run.py
+index 18f78f0..955295e 100755
+--- cpp/test/Ice/properties/run.py
++++ cpp.orig/test/Ice/properties/run.py
+@@ -26,7 +26,7 @@ client = os.path.join(os.getcwd(), "client")
+ #
+ # Write config
+ #
+-configPath = u"./config/中国_client.config"
++configPath = u"./config/中国_client.config".encode("utf-8")
+ 
+ TestUtil.createConfig(configPath, 
+                       ["# Automatically generated by Ice test driver.", 
+diff --git cpp.old/test/IceUtil/unicode/Client.cpp cpp/test/IceUtil/unicode/Client.cpp
+index 6370c9e..18ccc7c 100644
+--- cpp/test/IceUtil/unicode/Client.cpp
++++ cpp.orig/test/IceUtil/unicode/Client.cpp
+@@ -15,6 +15,10 @@
+ #   include <io.h>
+ #endif
+ 
++#ifdef __FreeBSD__
++#   include <unistd.h>
++#endif
++
+ using namespace IceUtil;
+ using namespace std;
+ 
+diff --git cpp.old/test/Slice/keyword/Client.cpp cpp/test/Slice/keyword/Client.cpp
+index 0714a17..edcfe00 100644
+--- cpp/test/Slice/keyword/Client.cpp
++++ cpp.orig/test/Slice/keyword/Client.cpp
+@@ -73,6 +73,9 @@ public:
+     virtual void ice_response(Ice::Int)  {}
+     virtual void ice_exception(const ::Ice::Exception&) {}
+ };
++
++template<typename T>
++void unused(T const &) { }
+    
+ //
+ // This section of the test is present to ensure that the C++ types
+@@ -86,6 +89,7 @@ testtypes()
+ 
+     _cpp_and::_cpp_auto b;
+     b._cpp_default = 0;
++    unused(b);
+ 
+     _cpp_and::deletePtr c = new _cpp_and::_cpp_delete();
+     c->_cpp_else = "";
+diff --git cpp.old/test/include/TestCommon.h cpp/test/include/TestCommon.h
+index 651a885..ca603d4 100644
+--- cpp/test/include/TestCommon.h
++++ cpp.orig/test/include/TestCommon.h
+@@ -17,6 +17,22 @@
+ #include <stdlib.h>
+ #endif
+ 
++#if defined(__FreeBSD__)
++#  include <sys/types.h>
++#  include <sys/sysctl.h>
++inline bool inFreeBSDJail()
++{
++    int jailed;
++    size_t size = sizeof(jailed);
++    return (sysctlbyname("security.jail.jailed", &jailed, &size, NULL, 0) != -1 || jailed);
++}
++#else
++inline bool inFreeBSDJail()
++{
++    return false;
++}
++#endif
++
+ void
+ inline testFailed(const char* expr, const char* file, unsigned int line)
+ {
+diff --git scripts/TestUtil.py scripts/TestUtil.py
+index e02da06..9b5f497 100755
+--- scripts/TestUtil.py
++++ scripts/TestUtil.py
+@@ -74,6 +74,25 @@ def isDarwin():
+ def isLinux():
+     return sys.platform.startswith("linux")
+ 
++def isFreeBSD():
++    return sys.platform.startswith("freebsd")
++
++def sysctl(key):
++    p = subprocess.Popen("sysctl "+key, shell=1, stdout=subprocess.PIPE)
++    try:
++        result = p.communicate()[0].strip().split()[1]
++    except IndexError:
++        return 0    
++    if sys.version_info >= (3,):
++        result = str(result, sys.stdout.encoding)
++    try:
++        return int(result)
++    except ValueError:
++        return result
++
++def isFreeBSDJail():
++    return isFreeBSD() and sysctl("security.jail.jailed")
++
+ def getCppCompiler():
+     compiler = ""
+     if os.environ.get("CPP_COMPILER", "") != "":
+@@ -1590,7 +1609,15 @@ def runTests(start, expanded, num = 0, script = False):
+             if isDarwin() and "nodarwin" in config:
+                 print "%s*** test not supported under Darwin%s" % (prefix, suffix)
+                 continue
++
++            if isFreeBSD() and "nofreebsd" in config:
++                print "%s*** test not supported under FreeBSD%s" % (prefix, suffix)
++                continue
+             
++            if isFreeBSDJail() and "nofreebsdjail" in config:
++                print "%s*** test not supported within a FreeBSD Jail%s" % (prefix, suffix)
++                continue
++
+             if not isWin32() and "win32only" in config:
+                 print "%s*** test only supported under Win32%s" % (prefix, suffix)
+                 continue