__in -> __inS, __out -> __outS See

    http://bugzilla.zeroc.com/bugzilla/show_bug.cgi?id=322

10 files changed, 317 insertions, 317 deletions

diff --git a/cpp/src/Ice/Object.cpp b/cpp/src/Ice/Object.cpp
index 44ee8c07361..a4c419f5dc6 100644
--- a/cpp/src/Ice/Object.cpp
+++ b/cpp/src/Ice/Object.cpp
@@ -111,10 +111,10 @@ Ice::Object::ice_postUnmarshal()
 }
 
 DispatchStatus
-Ice::Object::___ice_isA(Incoming& __in, const Current& __current)
+Ice::Object::___ice_isA(Incoming& __inS, const Current& __current)
 {
-    BasicStream* __is = __in.is();
-    BasicStream* __os = __in.os();
+    BasicStream* __is = __inS.is();
+    BasicStream* __os = __inS.os();
     string __id;
     __is->read(__id);
     bool __ret = ice_isA(__id, __current);
@@ -130,18 +130,18 @@ Ice::Object::___ice_ping(Incoming&, const Current& __current)
 }
 
 DispatchStatus
-Ice::Object::___ice_ids(Incoming& __in, const Current& __current)
+Ice::Object::___ice_ids(Incoming& __inS, const Current& __current)
 {
-    BasicStream* __os = __in.os();
+    BasicStream* __os = __inS.os();
     vector<string> __ret = ice_ids(__current);
     __os->write(__ret);
     return DispatchOK;
 }
 
 DispatchStatus
-Ice::Object::___ice_id(Incoming& __in, const Current& __current)
+Ice::Object::___ice_id(Incoming& __inS, const Current& __current)
 {
-    BasicStream* __os = __in.os();
+    BasicStream* __os = __inS.os();
     string __ret = ice_id(__current);
     __os->write(__ret);
     return DispatchOK;
@@ -222,32 +222,32 @@ Ice::Object::__read(BasicStream* __is, bool __rid)
 }
 
 void
-Ice::Object::__write(const OutputStreamPtr& __out) const
+Ice::Object::__write(const OutputStreamPtr& __outS) const
 {
-    __out->writeTypeId(ice_staticId());
-    __out->startSlice();
-    __out->writeSize(0); // For compatibility with the old AFM.
-    __out->endSlice();
+    __outS->writeTypeId(ice_staticId());
+    __outS->startSlice();
+    __outS->writeSize(0); // For compatibility with the old AFM.
+    __outS->endSlice();
 }
 
 void
-Ice::Object::__read(const InputStreamPtr& __in, bool __rid)
+Ice::Object::__read(const InputStreamPtr& __inS, bool __rid)
 {
     if(__rid)
     {
-	__in->readTypeId();
+	__inS->readTypeId();
     }
 
-    __in->startSlice();
+    __inS->startSlice();
 
     // For compatibility with the old AFM.
-    Int sz = __in->readSize();
+    Int sz = __inS->readSize();
     if(sz != 0)
     {
 	throw Ice::MarshalException(__FILE__, __LINE__);
     }
 
-    __in->endSlice();
+    __inS->endSlice();
 }
 
 void
diff --git a/cpp/src/Ice/Proxy.cpp b/cpp/src/Ice/Proxy.cpp
index 40fcad562c4..ca04ffd949b 100644
--- a/cpp/src/Ice/Proxy.cpp
+++ b/cpp/src/Ice/Proxy.cpp
@@ -812,14 +812,14 @@ bool
 IceDelegateM::Ice::Object::ice_isA(const string& __id, const Context& __context)
 {
     static const string __operation("ice_isA");
-    Outgoing __out(__connection.get(), __reference.get(), __operation, ::Ice::Nonmutating, __context, __compress);
-    BasicStream* __is = __out.is();
-    BasicStream* __os = __out.os();
+    Outgoing __outS(__connection.get(), __reference.get(), __operation, ::Ice::Nonmutating, __context, __compress);
+    BasicStream* __is = __outS.is();
+    BasicStream* __os = __outS.os();
     __os->write(__id);
     bool __ret;
     try
     {
-	if(!__out.invoke())
+	if(!__outS.invoke())
 	{
 	    __is->throwException();
 	}
@@ -836,11 +836,11 @@ void
 IceDelegateM::Ice::Object::ice_ping(const Context& __context)
 {
     static const string __operation("ice_ping");
-    Outgoing __out(__connection.get(), __reference.get(), __operation, ::Ice::Nonmutating, __context, __compress);
-    BasicStream* __is = __out.is();
+    Outgoing __outS(__connection.get(), __reference.get(), __operation, ::Ice::Nonmutating, __context, __compress);
+    BasicStream* __is = __outS.is();
     try
     {
-	if(!__out.invoke())
+	if(!__outS.invoke())
 	{
 	    __is->throwException();
 	}
@@ -855,12 +855,12 @@ vector<string>
 IceDelegateM::Ice::Object::ice_ids(const Context& __context)
 {
     static const string __operation("ice_ids");
-    Outgoing __out(__connection.get(), __reference.get(), __operation, ::Ice::Nonmutating, __context, __compress);
-    BasicStream* __is = __out.is();
+    Outgoing __outS(__connection.get(), __reference.get(), __operation, ::Ice::Nonmutating, __context, __compress);
+    BasicStream* __is = __outS.is();
     vector<string> __ret;
     try
     {
-	if(!__out.invoke())
+	if(!__outS.invoke())
 	{
 	    __is->throwException();
 	}
@@ -877,12 +877,12 @@ string
 IceDelegateM::Ice::Object::ice_id(const Context& __context)
 {
     static const string __operation("ice_id");
-    Outgoing __out(__connection.get(), __reference.get(), __operation, ::Ice::Nonmutating, __context, __compress);
-    BasicStream* __is = __out.is();
+    Outgoing __outS(__connection.get(), __reference.get(), __operation, ::Ice::Nonmutating, __context, __compress);
+    BasicStream* __is = __outS.is();
     string __ret;
     try
     {
-	if(!__out.invoke())
+	if(!__outS.invoke())
 	{
 	    __is->throwException();
 	}
@@ -902,15 +902,15 @@ IceDelegateM::Ice::Object::ice_invoke(const string& operation,
 				      vector<Byte>& outParams,
 				      const Context& context)
 {
-    Outgoing __out(__connection.get(), __reference.get(), operation, mode, context, __compress);
-    BasicStream* __os = __out.os();
+    Outgoing __outS(__connection.get(), __reference.get(), operation, mode, context, __compress);
+    BasicStream* __os = __outS.os();
     __os->writeBlob(inParams);
-    bool ok = __out.invoke();
+    bool ok = __outS.invoke();
     if(__reference->getMode() == Reference::ModeTwoway)
     {
         try
         {
-            BasicStream* __is = __out.is();
+            BasicStream* __is = __outS.is();
             Int sz = __is->getReadEncapsSize();
             __is->readBlob(outParams, sz);
         }
diff --git a/cpp/src/Slice/CPlusPlusUtil.cpp b/cpp/src/Slice/CPlusPlusUtil.cpp
index 6737ac0c193..adf24fd7267 100644
--- a/cpp/src/Slice/CPlusPlusUtil.cpp
+++ b/cpp/src/Slice/CPlusPlusUtil.cpp
@@ -522,7 +522,7 @@ Slice::writeStreamMarshalUnmarshalCode(Output& out, const TypePtr& type, const s
     string stream;
     if(str.empty())
     {
-	stream = marshal ? "__out" : "__in";
+	stream = marshal ? "__outS" : "__inS";
     }
     else
     {
diff --git a/cpp/src/Slice/CsUtil.cpp b/cpp/src/Slice/CsUtil.cpp
index 8565d295977..8f9880d1349 100755
--- a/cpp/src/Slice/CsUtil.cpp
+++ b/cpp/src/Slice/CsUtil.cpp
@@ -227,11 +227,11 @@ Slice::CsGenerator::writeMarshalUnmarshalCode(Output &out,
 
     if(marshal)
     {
-        stream = streamingAPI ? "__out" : "__os";
+        stream = streamingAPI ? "__outS" : "__os";
     }
     else
     {
-        stream = streamingAPI ? "__in" : "__is";
+        stream = streamingAPI ? "__inS" : "__is";
     }
 
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
@@ -523,11 +523,11 @@ Slice::CsGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
     string stream;
     if(marshal)
     {
-        stream = streamingAPI ? "__out" : "__os";
+        stream = streamingAPI ? "__outS" : "__os";
     }
     else
     {
-        stream = streamingAPI ? "__in" : "__is";
+        stream = streamingAPI ? "__inS" : "__is";
     }
     
     TypePtr type = seq->type();
diff --git a/cpp/src/Slice/JavaUtil.cpp b/cpp/src/Slice/JavaUtil.cpp
index 049b62da2f4..6c55124ec3b 100644
--- a/cpp/src/Slice/JavaUtil.cpp
+++ b/cpp/src/Slice/JavaUtil.cpp
@@ -1450,7 +1450,7 @@ Slice::JavaGenerator::writeStreamMarshalUnmarshalCode(Output& out,
                                                       const StringList& metaData,
                                                       const string& patchParams)
 {
-    string stream = marshal ? "__out" : "__in";
+    string stream = marshal ? "__outS" : "__inS";
     string v;
     if(holder)
     {
@@ -1720,7 +1720,7 @@ Slice::JavaGenerator::writeStreamSequenceMarshalUnmarshalCode(Output& out,
                                                               bool useHelper,
                                                               const StringList& metaData)
 {
-    string stream = marshal ? "__out" : "__in";
+    string stream = marshal ? "__outS" : "__inS";
     string v = param;
 
     //
diff --git a/cpp/src/Slice/VbUtil.cpp b/cpp/src/Slice/VbUtil.cpp
index 0a74bad392d..9d7e1505fbf 100755
--- a/cpp/src/Slice/VbUtil.cpp
+++ b/cpp/src/Slice/VbUtil.cpp
@@ -235,11 +235,11 @@ Slice::VbGenerator::writeMarshalUnmarshalCode(Output &out,
 
     if(marshal)
     {
-	stream = streamingAPI ? "__out" : "__os";
+	stream = streamingAPI ? "__outS" : "__os";
     }
     else
     {
-        stream = streamingAPI ? "__in" : "__is";
+        stream = streamingAPI ? "__inS" : "__is";
     }
 
     BuiltinPtr builtin = BuiltinPtr::dynamicCast(type);
@@ -542,11 +542,11 @@ Slice::VbGenerator::writeSequenceMarshalUnmarshalCode(Output& out,
     string stream;
     if(marshal)
     {
-        stream = streamingAPI ? "__out" : "__os";
+        stream = streamingAPI ? "__outS" : "__os";
     }
     else
     {
-        stream = streamingAPI ? "__in" : "__is";
+        stream = streamingAPI ? "__inS" : "__is";
     }
 
     TypePtr type = seq->type();
diff --git a/cpp/src/slice2cpp/Gen.cpp b/cpp/src/slice2cpp/Gen.cpp
index b333d58b2d0..145326ba49a 100644
--- a/cpp/src/slice2cpp/Gen.cpp
+++ b/cpp/src/slice2cpp/Gen.cpp
@@ -524,22 +524,22 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
 
         if(_stream)
         {
-            C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(const ::Ice::OutputStreamPtr& __out) const";
+            C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(const ::Ice::OutputStreamPtr& __outS) const";
             C << sb;
-            C << nl << "__out->writeString(::std::string(\"" << p->scoped() << "\"));";
-            C << nl << "__out->startSlice();";
+            C << nl << "__outS->writeString(::std::string(\"" << p->scoped() << "\"));";
+            C << nl << "__outS->startSlice();";
             writeStreamMarshalCode(C, memberList, 0);
-            C << nl << "__out->endSlice();";
+            C << nl << "__outS->endSlice();";
             if(base)
             {
                 C.zeroIndent();
                 C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
                 C.restoreIndent();
-                C << nl << fixKwd(base->name()) << "::__write(__out);";
+                C << nl << fixKwd(base->name()) << "::__write(__outS);";
                 C.zeroIndent();
                 C << nl << "#else";
                 C.restoreIndent();
-                C << nl << fixKwd(base->scoped()) << "::__write(__out);";
+                C << nl << fixKwd(base->scoped()) << "::__write(__outS);";
                 C.zeroIndent();
                 C << nl << "#endif";
                 C.restoreIndent();
@@ -547,25 +547,25 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
             C << eb;
 
             C << sp << nl << "void" << nl << scoped.substr(2)
-              << "::__read(const ::Ice::InputStreamPtr& __in, bool __rid)";
+              << "::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)";
             C << sb;
             C << nl << "if(__rid)";
             C << sb;
-            C << nl << "__in->readString();";
+            C << nl << "__inS->readString();";
             C << eb;
-            C << nl << "__in->startSlice();";
+            C << nl << "__inS->startSlice();";
             writeStreamUnmarshalCode(C, memberList, 0);
-            C << nl << "__in->endSlice();";
+            C << nl << "__inS->endSlice();";
             if(base)
             {
                 C.zeroIndent();
                 C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
                 C.restoreIndent();
-                C << nl << fixKwd(base->name()) << "::__read(__in, true);";
+                C << nl << fixKwd(base->name()) << "::__read(__inS, true);";
                 C.zeroIndent();
                 C << nl << "#else";
                 C.restoreIndent();
-                C << nl << fixKwd(base->scoped()) << "::__read(__in, true);";
+                C << nl << fixKwd(base->scoped()) << "::__read(__inS, true);";
                 C.zeroIndent();
                 C << nl << "#endif";
                 C.restoreIndent();
@@ -751,12 +751,12 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
 
 	if(_stream)
 	{
-	    C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(const ::Ice::OutputStreamPtr& __out) const";
+	    C << sp << nl << "void" << nl << scoped.substr(2) << "::__write(const ::Ice::OutputStreamPtr& __outS) const";
 	    C << sb;
 	    writeStreamMarshalCode(C, memberList, 0);
 	    C << eb;
 
-	    C << sp << nl << "void" << nl << scoped.substr(2) << "::__read(const ::Ice::InputStreamPtr& __in)";
+	    C << sp << nl << "void" << nl << scoped.substr(2) << "::__read(const ::Ice::InputStreamPtr& __inS)";
 	    C << sb;
 	    writeStreamUnmarshalCode(C, memberList, 0);
 	    C << eb;
@@ -772,15 +772,15 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
         H << nl << _dllExport << "void ice_read" << p->name() << "(const ::Ice::InputStreamPtr&, " << name << "&);";
 
         C << sp << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
-          << "(const ::Ice::OutputStreamPtr& __out, const " << scoped << "& __v)";
+          << "(const ::Ice::OutputStreamPtr& __outS, const " << scoped << "& __v)";
         C << sb;
-        C << nl << "__v.__write(__out);";
+        C << nl << "__v.__write(__outS);";
         C << eb;
 
         C << sp << nl << "void" << nl << scope.substr(2) << "ice_read" << p->name()
-          << "(const ::Ice::InputStreamPtr& __in, " << scoped << "& __v)";
+          << "(const ::Ice::InputStreamPtr& __inS, " << scoped << "& __v)";
         C << sb;
-        C << nl << "__v.__read(__in);";
+        C << nl << "__v.__read(__inS);";
         C << eb;
     }
 }
@@ -884,9 +884,9 @@ Slice::Gen::TypesVisitor::visitSequence(const SequencePtr& p)
         if(_stream)
         {
             C << sp << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
-              << "(const ::Ice::OutputStreamPtr& __out, const " << scoped << "& v)";
+              << "(const ::Ice::OutputStreamPtr& __outS, const " << scoped << "& v)";
             C << sb;
-            C << nl << "__out->writeSize(::Ice::Int(v.size()));";
+            C << nl << "__outS->writeSize(::Ice::Int(v.size()));";
             C << nl << scoped << "::const_iterator p;";
             C << nl << "for(p = v.begin(); p != v.end(); ++p)";
             C << sb;
@@ -895,9 +895,9 @@ Slice::Gen::TypesVisitor::visitSequence(const SequencePtr& p)
             C << eb;
 
             C << sp << nl << "void" << nl << scope.substr(2) << "ice_read" << p->name()
-              << "(const ::Ice::InputStreamPtr& __in, " << scoped << "& v)";
+              << "(const ::Ice::InputStreamPtr& __inS, " << scoped << "& v)";
             C << sb;
-            C << nl << "::Ice::Int sz = __in->readSize();";
+            C << nl << "::Ice::Int sz = __inS->readSize();";
             C << nl << "v.resize(sz);";
             C << nl << "for(int i = 0; i < sz; ++i)";
             C << sb;
@@ -970,9 +970,9 @@ Slice::Gen::TypesVisitor::visitDictionary(const DictionaryPtr& p)
 	if(_stream)
 	{
 	    C << sp << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
-	      << "(const ::Ice::OutputStreamPtr& __out, const " << scoped << "& v)";
+	      << "(const ::Ice::OutputStreamPtr& __outS, const " << scoped << "& v)";
 	    C << sb;
-	    C << nl << "__out->writeSize(::Ice::Int(v.size()));";
+	    C << nl << "__outS->writeSize(::Ice::Int(v.size()));";
 	    C << nl << scoped << "::const_iterator p;";
 	    C << nl << "for(p = v.begin(); p != v.end(); ++p)";
 	    C << sb;
@@ -982,9 +982,9 @@ Slice::Gen::TypesVisitor::visitDictionary(const DictionaryPtr& p)
 	    C << eb;
 
 	    C << sp << nl << "void" << nl << scope.substr(2) << "ice_read" << p->name()
-	      << "(const ::Ice::InputStreamPtr& __in, " << scoped << "& v)";
+	      << "(const ::Ice::InputStreamPtr& __inS, " << scoped << "& v)";
 	    C << sb;
-	    C << nl << "::Ice::Int sz = __in->readSize();";
+	    C << nl << "::Ice::Int sz = __inS->readSize();";
 	    C << nl << "while(sz--)";
 	    C << sb;
 	    C << nl << "::std::pair<const " << ks << ", " << vs << "> pair;";
@@ -1077,38 +1077,38 @@ Slice::Gen::TypesVisitor::visitEnum(const EnumPtr& p)
 	if(_stream)
 	{
 	    C << sp << nl << "void" << nl << scope.substr(2) << "ice_write" << p->name()
-              << "(const ::Ice::OutputStreamPtr& __out, " << scoped << " v)";
+              << "(const ::Ice::OutputStreamPtr& __outS, " << scoped << " v)";
 	    C << sb;
 	    if(sz <= 0x7f)
 	    {
-		C << nl << "__out->writeByte(static_cast< ::Ice::Byte>(v));";
+		C << nl << "__outS->writeByte(static_cast< ::Ice::Byte>(v));";
 	    }
 	    else if(sz <= 0x7fff)
 	    {
-		C << nl << "__out->writeShort(static_cast< ::Ice::Short>(v));";
+		C << nl << "__outS->writeShort(static_cast< ::Ice::Short>(v));";
 	    }
 	    else
 	    {
-		C << nl << "__out->writeInt(static_cast< ::Ice::Int>(v));";
+		C << nl << "__outS->writeInt(static_cast< ::Ice::Int>(v));";
 	    }
 	    C << eb;
 
 	    C << sp << nl << "void" << nl << scope.substr(2) << "ice_read" << p->name()
-              << "(const ::Ice::InputStreamPtr& __in, " << scoped << "& v)";
+              << "(const ::Ice::InputStreamPtr& __inS, " << scoped << "& v)";
 	    C << sb;
 	    if(sz <= 0x7f)
 	    {
-		C << nl << "::Ice::Byte val = __in->readByte();";
+		C << nl << "::Ice::Byte val = __inS->readByte();";
 		C << nl << "v = static_cast< " << scoped << ">(val);";
 	    }
 	    else if(sz <= 0x7fff)
 	    {
-		C << nl << "::Ice::Short val = __in->readShort();";
+		C << nl << "::Ice::Short val = __inS->readShort();";
 		C << nl << "v = static_cast< " << scoped << ">(val);";
 	    }
 	    else
 	    {
-		C << nl << "::Ice::Int val = __in->readInt();";
+		C << nl << "::Ice::Int val = __inS->readInt();";
 		C << nl << "v = static_cast< " << scoped << ">(val);";
 	    }
 	    C << eb;
@@ -1790,13 +1790,13 @@ Slice::Gen::DelegateMVisitor::visitOperation(const OperationPtr& p)
     C << sp << nl << retS << nl << "IceDelegateM" << scoped << spar << paramsDecl << epar;
     C << sb;
     C << nl << "static const ::std::string __operation(\"" << p->name() << "\");";
-    C << nl << "::IceInternal::Outgoing __out(__connection.get(), __reference.get(), __operation, "
+    C << nl << "::IceInternal::Outgoing __outS(__connection.get(), __reference.get(), __operation, "
       << "static_cast< ::Ice::OperationMode>(" << p->mode() << "), __context, __compress);";
     if(!inParams.empty())
     {
 	C << nl << "try";
 	C << sb;
-	C << nl << "::IceInternal::BasicStream* __os = __out.os();";
+	C << nl << "::IceInternal::BasicStream* __os = __outS.os();";
 	writeMarshalCode(C, inParams, 0);
 	if(p->sendsClasses())
 	{
@@ -1805,13 +1805,13 @@ Slice::Gen::DelegateMVisitor::visitOperation(const OperationPtr& p)
 	C << eb;
 	C << nl << "catch(const ::Ice::LocalException& __ex)";
 	C << sb;
-	C << nl << "__out.abort(__ex);";
+	C << nl << "__outS.abort(__ex);";
 	C << eb;
     }
-    C << nl << "bool __ok = __out.invoke();";
+    C << nl << "bool __ok = __outS.invoke();";
     C << nl << "try";
     C << sb;
-    C << nl << "::IceInternal::BasicStream* __is = __out.is();";
+    C << nl << "::IceInternal::BasicStream* __is = __outS.is();";
     C << nl << "if(!__ok)";
     C << sb;
     C << nl << "__is->throwException();";
@@ -2461,42 +2461,42 @@ Slice::Gen::ObjectVisitor::visitClassDefEnd(const ClassDefPtr& p)
 	if(_stream)
 	{
 	    C << sp;
-	    C << nl << "void" << nl << scoped.substr(2) << "::__write(const ::Ice::OutputStreamPtr& __out) const";
+	    C << nl << "void" << nl << scoped.substr(2) << "::__write(const ::Ice::OutputStreamPtr& __outS) const";
 	    C << sb;
-	    C << nl << "__out->writeTypeId(ice_staticId());";
-	    C << nl << "__out->startSlice();";
+	    C << nl << "__outS->writeTypeId(ice_staticId());";
+	    C << nl << "__outS->startSlice();";
 	    writeStreamMarshalCode(C, memberList, 0);
-	    C << nl << "__out->endSlice();";
+	    C << nl << "__outS->endSlice();";
 	    C.zeroIndent();
 	    C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
 	    C.restoreIndent();
-	    C << nl << (base ? fixKwd(base->name()) : "Object") << "::__write(__out);";
+	    C << nl << (base ? fixKwd(base->name()) : "Object") << "::__write(__outS);";
 	    C.zeroIndent();
 	    C << nl << "#else";
 	    C.restoreIndent();
-	    C << nl << (base ? fixKwd(base->scoped()) : "::Ice::Object") << "::__write(__out);";
+	    C << nl << (base ? fixKwd(base->scoped()) : "::Ice::Object") << "::__write(__outS);";
 	    C.zeroIndent();
 	    C << nl << "#endif";
 	    C.restoreIndent();
 	    C << eb;
 	    C << sp;
-	    C << nl << "void" << nl << scoped.substr(2) << "::__read(const ::Ice::InputStreamPtr& __in, bool __rid)";
+	    C << nl << "void" << nl << scoped.substr(2) << "::__read(const ::Ice::InputStreamPtr& __inS, bool __rid)";
 	    C << sb;
 	    C << nl << "if(__rid)";
 	    C << sb;
-	    C << nl << "__in->readTypeId();";
+	    C << nl << "__inS->readTypeId();";
 	    C << eb;
-	    C << nl << "__in->startSlice();";
+	    C << nl << "__inS->startSlice();";
 	    writeStreamUnmarshalCode(C, memberList, 0);
-	    C << nl << "__in->endSlice();";
+	    C << nl << "__inS->endSlice();";
 	    C.zeroIndent();
 	    C << nl << "#if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug"; // COMPILERBUG
 	    C.restoreIndent();
-	    C << nl << (base ? fixKwd(base->name()) : "Object") << "::__read(__in, true);";
+	    C << nl << (base ? fixKwd(base->name()) : "Object") << "::__read(__inS, true);";
 	    C.zeroIndent();
 	    C << nl << "#else";
 	    C.restoreIndent();
-	    C << nl << (base ? fixKwd(base->scoped()) : "::Ice::Object") << "::__read(__in, true);";
+	    C << nl << (base ? fixKwd(base->scoped()) : "::Ice::Object") << "::__read(__inS, true);";
 	    C.zeroIndent();
 	    C << nl << "#endif";
 	    C.restoreIndent();
@@ -2776,7 +2776,7 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
 
 	C << sp;
 	C << nl << "::IceInternal::DispatchStatus" << nl << scope.substr(2) << "___" << name
-	  << "(::IceInternal::Incoming& __in, const ::Ice::Current& __current)" << (nonmutating ? " const" : "");
+	  << "(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)" << (nonmutating ? " const" : "");
 	C << sb;
 	if(!amd)
 	{
@@ -2799,11 +2799,11 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
 
 	    if(!inParams.empty())
 	    {
-		C << nl << "::IceInternal::BasicStream* __is = __in.is();";
+		C << nl << "::IceInternal::BasicStream* __is = __inS.is();";
 	    }
 	    if(ret || !outParams.empty() || !throws.empty())
 	    {
-		C << nl << "::IceInternal::BasicStream* __os = __in.os();";
+		C << nl << "::IceInternal::BasicStream* __os = __inS.os();";
 	    }
 	    writeAllocateCode(C, inParams, 0);
 	    writeUnmarshalCode(C, inParams, 0);
@@ -2847,7 +2847,7 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
 	{
 	    if(!inParams.empty())
 	    {
-		C << nl << "::IceInternal::BasicStream* __is = __in.is();";
+		C << nl << "::IceInternal::BasicStream* __is = __inS.is();";
 	    }
 	    writeAllocateCode(C, inParams, 0);
 	    writeUnmarshalCode(C, inParams, 0);
@@ -2856,7 +2856,7 @@ Slice::Gen::ObjectVisitor::visitOperation(const OperationPtr& p)
 		C << nl << "__is->readPendingObjects();";
 	    }
 	    C << nl << classScopedAMD << '_' << name << "Ptr __cb = new IceAsync" << classScopedAMD << '_' << name
-	      << "(__in);";
+	      << "(__inS);";
 	    C << nl << "try";
 	    C << sb;
 	    C << nl << name << "_async" << argsAMD << ';';
@@ -3337,16 +3337,16 @@ Slice::Gen::HandleVisitor::visitClassDefStart(const ClassDefPtr& p)
 	{
 	    C << sp;
 	    C << nl << "void" << nl << scope.substr(2) << "ice_write" << name
-              << "Prx(const ::Ice::OutputStreamPtr& __out, const " << scope << name << "Prx& v)";
+              << "Prx(const ::Ice::OutputStreamPtr& __outS, const " << scope << name << "Prx& v)";
 	    C << sb;
-	    C << nl << "__out->writeProxy(v);";
+	    C << nl << "__outS->writeProxy(v);";
 	    C << eb;
 
 	    C << sp;
 	    C << nl << "void" << nl << scope.substr(2) << "ice_read" << name
-              << "Prx(const ::Ice::InputStreamPtr& __in, " << scope << name << "Prx& v)";
+              << "Prx(const ::Ice::InputStreamPtr& __inS, " << scope << name << "Prx& v)";
 	    C << sb;
-	    C << nl << "::Ice::ObjectPrx proxy = __in->readProxy();";
+	    C << nl << "::Ice::ObjectPrx proxy = __inS->readProxy();";
 	    C << nl << "if(!proxy)";
 	    C << sb;
 	    C << nl << "v = 0;";
@@ -3360,18 +3360,18 @@ Slice::Gen::HandleVisitor::visitClassDefStart(const ClassDefPtr& p)
 
 	    C << sp;
 	    C << nl << "void" << nl << scope.substr(2) << "ice_write" << name
-              << "(const ::Ice::OutputStreamPtr& __out, const " << scope << name << "Ptr& v)";
+              << "(const ::Ice::OutputStreamPtr& __outS, const " << scope << name << "Ptr& v)";
 	    C << sb;
-	    C << nl << "__out->writeObject(v);";
+	    C << nl << "__outS->writeObject(v);";
 	    C << eb;
 
             C << sp;
-            C << nl << "void" << nl << scope.substr(2) << "ice_read" << name << "(const ::Ice::InputStreamPtr& __in, "
+            C << nl << "void" << nl << scope.substr(2) << "ice_read" << name << "(const ::Ice::InputStreamPtr& __inS, "
               << scoped << "Ptr& __v)";
             C << sb;
             C << nl << "::Ice::ReadObjectCallbackPtr __cb = new ::Ice::ReadObjectCallbackI(" << scope << "__patch__"
               << name << "Ptr, &__v);";
-            C << nl << "__in->readObject(__cb);";
+            C << nl << "__inS->readObject(__cb);";
             C << eb;
 	}
     }
diff --git a/cpp/src/slice2cs/Gen.cpp b/cpp/src/slice2cs/Gen.cpp
index b009494820b..9bf9e7b0d05 100755
--- a/cpp/src/slice2cs/Gen.cpp
+++ b/cpp/src/slice2cs/Gen.cpp
@@ -303,7 +303,7 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
 
         string opName = op->name();
         _out << sp << nl << "public static IceInternal.DispatchStatus ___" << opName << '(' << name
-	     << " __obj, IceInternal.Incoming __in, Ice.Current __current)";
+	     << " __obj, IceInternal.Incoming __inS, Ice.Current __current)";
         _out << sb;
 
 	bool amd = p->hasMetaData("amd") || op->hasMetaData("amd");
@@ -346,11 +346,11 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
 	    
 	    if(!inParams.empty())
 	    {
-		_out << nl << "IceInternal.BasicStream __is = __in.istr();";
+		_out << nl << "IceInternal.BasicStream __is = __inS.istr();";
 	    }
 	    if(!outParams.empty() || ret || !throws.empty())
 	    {
-		_out << nl << "IceInternal.BasicStream __os = __in.ostr();";
+		_out << nl << "IceInternal.BasicStream __os = __inS.ostr();";
 	    }
 	    
 	    //
@@ -481,7 +481,7 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
 	    
 	    if(!inParams.empty())
 	    {
-		_out << nl << "IceInternal.BasicStream __is = __in.istr();";
+		_out << nl << "IceInternal.BasicStream __is = __inS.istr();";
 	    }
 	    
 	    //
@@ -517,7 +517,7 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
 	    //
 	    string classNameAMD = "AMD_" + p->name();
 	    _out << nl << classNameAMD << '_' << opName << " __cb = new _" << classNameAMD << '_' << opName
-		 << "(__in);";
+		 << "(__inS);";
             _out << nl << "try";
             _out << sb;
 	    _out << nl << "__obj.";
@@ -608,7 +608,7 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
 	_out << eb << ';';
 
 	_out << sp << nl << "public override IceInternal.DispatchStatus "
-	     << "__dispatch(IceInternal.Incoming __in, Ice.Current __current)";
+	     << "__dispatch(IceInternal.Incoming __inS, Ice.Current __current)";
 	_out << sb;
 	_out << nl << "int pos;";
 	//
@@ -652,19 +652,19 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
 	    _out << sb;
 	    if(opName == "ice_id")
 	    {
-		_out << nl << "return ___ice_id(this, __in, __current);";
+		_out << nl << "return ___ice_id(this, __inS, __current);";
 	    }
 	    else if(opName == "ice_ids")
 	    {
-		_out << nl << "return ___ice_ids(this, __in, __current);";
+		_out << nl << "return ___ice_ids(this, __inS, __current);";
 	    }
 	    else if(opName == "ice_isA")
 	    {
-		_out << nl << "return ___ice_isA(this, __in, __current);";
+		_out << nl << "return ___ice_isA(this, __inS, __current);";
 	    }
 	    else if(opName == "ice_ping")
 	    {
-		_out << nl << "return ___ice_ping(this, __in, __current);";
+		_out << nl << "return ___ice_ping(this, __inS, __current);";
 	    }
 	    else
 	    {
@@ -680,7 +680,7 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
 			assert(cl);
 			if(cl->scoped() == p->scoped())
 			{
-			    _out << nl << "return ___" << opName << "(this, __in, __current);";
+			    _out << nl << "return ___" << opName << "(this, __inS, __current);";
 			}
 			else
 			{
@@ -692,7 +692,7 @@ Slice::CsVisitor::writeDispatch(const ClassDefPtr& p)
 				base = base.insert(pos + 2, "_");
 				base += "Disp";
 			    }
-			    _out << nl << "return " << fixId(base) << ".___" << opName << "(this, __in, __current);";
+			    _out << nl << "return " << fixId(base) << ".___" << opName << "(this, __inS, __current);";
 			}
 			break;
 		    }
@@ -1084,15 +1084,15 @@ Slice::Gen::TypesVisitor::visitClassDefStart(const ClassDefPtr& p)
         _out << sp << nl << "public sealed class " << name << "Helper";
 	_out << sb;
 
-	_out << sp << nl << "public " << name << "Helper(Ice.InputStream __in)";
+	_out << sp << nl << "public " << name << "Helper(Ice.InputStream __inS)";
 	_out << sb;
-	_out << nl << "_in = __in;";
+	_out << nl << "_in = __inS;";
 	_out << nl << "_pp = new IceInternal.ParamPatcher(typeof(" << scoped << "));";
 	_out << eb;
 
-	_out << sp << nl << "public static void write(Ice.OutputStream __out, " << fixId(name) << " __v)";
+	_out << sp << nl << "public static void write(Ice.OutputStream __outS, " << fixId(name) << " __v)";
 	_out << sb;
-	_out << nl << "__out.writeObject(__v);";
+	_out << nl << "__outS.writeObject(__v);";
 	_out << eb;
 
 	_out << sp << nl << "public void read()";
@@ -1351,10 +1351,10 @@ Slice::Gen::TypesVisitor::visitClassDefEnd(const ClassDefPtr& p)
 	//
 	if(_stream)
 	{
-	    _out << sp << nl << "public override void __write(Ice.OutputStream __out)";
+	    _out << sp << nl << "public override void __write(Ice.OutputStream __outS)";
 	    _out << sb;
-	    _out << nl << "__out.writeTypeId(ice_staticId());";
-	    _out << nl << "__out.startSlice();";
+	    _out << nl << "__outS.writeTypeId(ice_staticId());";
+	    _out << nl << "__outS.startSlice();";
 	    for(d = members.begin(); d != members.end(); ++d)
 	    {
 		StringList metaData = (*d)->getMetaData();
@@ -1362,17 +1362,17 @@ Slice::Gen::TypesVisitor::visitClassDefEnd(const ClassDefPtr& p)
 					  fixId((*d)->name(), DotNet::ICloneable, true),
 					  true, true, false);
 	    }
-	    _out << nl << "__out.endSlice();";
-	    _out << nl << "base.__write(__out);";
+	    _out << nl << "__outS.endSlice();";
+	    _out << nl << "base.__write(__outS);";
 	    _out << eb;
 
-	    _out << sp << nl << "public override void __read(Ice.InputStream __in, bool __rid)";
+	    _out << sp << nl << "public override void __read(Ice.InputStream __inS, bool __rid)";
 	    _out << sb;
 	    _out << nl << "if(__rid)";
 	    _out << sb;
-	    _out << nl << "/* string myId = */ __in.readTypeId();";
+	    _out << nl << "/* string myId = */ __inS.readTypeId();";
 	    _out << eb;
-	    _out << nl << "__in.startSlice();";
+	    _out << nl << "__inS.startSlice();";
 	    for(d = members.begin(); d != members.end(); ++d)
 	    {
 		StringList metaData = (*d)->getMetaData();
@@ -1390,8 +1390,8 @@ Slice::Gen::TypesVisitor::visitClassDefEnd(const ClassDefPtr& p)
 					  fixId((*d)->name(), DotNet::ICloneable, true),
 					  false, true, false, patchParams.str());
 	    }
-	    _out << nl << "__in.endSlice();";
-	    _out << nl << "base.__read(__in, true);";
+	    _out << nl << "__inS.endSlice();";
+	    _out << nl << "base.__read(__inS, true);";
 	    _out << eb;
 	}
 	else
@@ -1400,14 +1400,14 @@ Slice::Gen::TypesVisitor::visitClassDefEnd(const ClassDefPtr& p)
 	    // Emit placeholder functions to catch errors.
 	    //
             string scoped = p->scoped();
-	    _out << sp << nl << "public override void __write(Ice.OutputStream __out)";
+	    _out << sp << nl << "public override void __write(Ice.OutputStream __outS)";
 	    _out << sb;
 	    _out << nl << "Ice.MarshalException ex = new Ice.MarshalException();";
 	    _out << nl << "ex.reason = \"type " << scoped.substr(2) << " was not generated with stream support\";";
 	    _out << nl << "throw ex;";
 	    _out << eb;
 
-	    _out << sp << nl << "public override void __read(Ice.InputStream __in, bool __rid)";
+	    _out << sp << nl << "public override void __read(Ice.InputStream __inS, bool __rid)";
 	    _out << sb;
 	    _out << nl << "Ice.MarshalException ex = new Ice.MarshalException();";
 	    _out << nl << "ex.reason = \"type " << scoped.substr(2) << " was not generated with stream support\";";
@@ -1988,30 +1988,30 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
 
 	if(_stream)
 	{
-	    _out << sp << nl << "public override void __write(Ice.OutputStream __out)";
+	    _out << sp << nl << "public override void __write(Ice.OutputStream __outS)";
 	    _out << sb;
-	    _out << nl << "__out.writeString(\"" << scoped << "\");";
-	    _out << nl << "__out.startSlice();";
+	    _out << nl << "__outS.writeString(\"" << scoped << "\");";
+	    _out << nl << "__outS.startSlice();";
 	    for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
 	    {
 		writeMarshalUnmarshalCode(_out, (*q)->type(),
 					  fixId((*q)->name(), DotNet::ApplicationException),
 					  true, true, false);
 	    }
-	    _out << nl << "__out.endSlice();";
+	    _out << nl << "__outS.endSlice();";
 	    if(base)
 	    {
-		_out << nl << "base.__write(__out);";
+		_out << nl << "base.__write(__outS);";
 	    }
 	    _out << eb;
 
-	    _out << sp << nl << "public override void __read(Ice.InputStream __in, bool __rid)";
+	    _out << sp << nl << "public override void __read(Ice.InputStream __inS, bool __rid)";
 	    _out << sb;
 	    _out << nl << "if(__rid)";
 	    _out << sb;
-	    _out << nl << "/* string myId = */ __in.readString();";
+	    _out << nl << "/* string myId = */ __inS.readString();";
 	    _out << eb;
-	    _out << nl << "__in.startSlice();";
+	    _out << nl << "__inS.startSlice();";
 	    classMemberCount = static_cast<int>(allClassMembers.size() - classMembers.size());
 	    for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
 	    {
@@ -2029,10 +2029,10 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
 					  fixId((*q)->name(), DotNet::ApplicationException),
 					  false, true, false, patchParams.str());
 	    }
-	    _out << nl << "__in.endSlice();";
+	    _out << nl << "__inS.endSlice();";
 	    if(base)
 	    {
-		_out << nl << "base.__read(__in, true);";
+		_out << nl << "base.__read(__inS, true);";
 	    }
 	    _out << eb;
 	}
@@ -2042,14 +2042,14 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
 	    // Emit placeholder functions to catch errors.
 	    //
             string scoped = p->scoped();
-	    _out << sp << nl << "public override void __write(Ice.OutputStream __out)";
+	    _out << sp << nl << "public override void __write(Ice.OutputStream __outS)";
 	    _out << sb;
 	    _out << nl << "Ice.MarshalException ex = new Ice.MarshalException();";
 	    _out << nl << "ex.reason = \"exception " << scoped.substr(2) << " was not generated with stream support\";";
 	    _out << nl << "throw ex;";
 	    _out << eb;
 
-	    _out << sp << nl << "public override void __read(Ice.InputStream __in, bool __rid)";
+	    _out << sp << nl << "public override void __read(Ice.InputStream __inS, bool __rid)";
 	    _out << sb;
 	    _out << nl << "Ice.MarshalException ex = new Ice.MarshalException();";
 	    _out << nl << "ex.reason = \"exception " << scoped.substr(2) << " was not generated with stream support\";";
@@ -2081,15 +2081,15 @@ Slice::Gen::TypesVisitor::visitStructStart(const StructPtr& p)
         _out << sp << nl << "public sealed class " << p->name() << "Helper";
 	_out << sb;
 
-	_out << sp << nl << "public static void write(Ice.OutputStream __out, " << name << " __v)";
+	_out << sp << nl << "public static void write(Ice.OutputStream __outS, " << name << " __v)";
 	_out << sb;
-	_out << nl << "__v.__write(__out);";
+	_out << nl << "__v.__write(__outS);";
 	_out << eb;
 
-	_out << sp << nl << "public static " << name << " read(Ice.InputStream __in)";
+	_out << sp << nl << "public static " << name << " read(Ice.InputStream __inS)";
 	_out << sb;
 	_out << nl << name << " __v = new " << name << "();";
-	_out << nl << "__v.__read(__in);";
+	_out << nl << "__v.__read(__inS);";
 	_out << nl << "return __v;";
 	_out << eb;
 
@@ -2361,7 +2361,7 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
 
 	if(_stream)
 	{
-	    _out << sp << nl << "public void __write(Ice.OutputStream __out)";
+	    _out << sp << nl << "public void __write(Ice.OutputStream __outS)";
 	    _out << sb;
 	    for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
 	    {
@@ -2371,7 +2371,7 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
 	    }
 	    _out << eb;
 
-	    _out << sp << nl << "public void __read(Ice.InputStream __in)";
+	    _out << sp << nl << "public void __read(Ice.InputStream __inS)";
 	    _out << sb;
 	    if(patchStruct)
 	    {
@@ -2673,12 +2673,12 @@ Slice::Gen::TypesVisitor::visitEnum(const EnumPtr& p)
 	_out << sp << nl << "public sealed class " << name << "Helper";
 	_out << sb;
 
-	_out << sp << nl << "public static void write(Ice.OutputStream __out, " << scoped << " __v)";
+	_out << sp << nl << "public static void write(Ice.OutputStream __outS, " << scoped << " __v)";
 	_out << sb;
 	writeMarshalUnmarshalCode(_out, p, "__v", true, true, false);
 	_out << eb;
 
-	_out << sp << nl << "public static " << scoped << " read(Ice.InputStream __in)";
+	_out << sp << nl << "public static " << scoped << " read(Ice.InputStream __inS)";
 	_out << sb;
 	_out << nl << scoped << " __v;";
 	writeMarshalUnmarshalCode(_out, p, "__v", false, true, false);
@@ -3292,14 +3292,14 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
 
     if(_stream)
     {
-	_out << sp << nl << "public static void write(Ice.OutputStream __out, " << name << "Prx __v)";
+	_out << sp << nl << "public static void write(Ice.OutputStream __outS, " << name << "Prx __v)";
 	_out << sb;
-	_out << nl << "__out.writeProxy(__v);";
+	_out << nl << "__outS.writeProxy(__v);";
 	_out << eb;
 
-	_out << sp << nl << "public static " << name << "Prx read(Ice.InputStream __in)";
+	_out << sp << nl << "public static " << name << "Prx read(Ice.InputStream __inS)";
 	_out << sb;
-	_out << nl << "Ice.ObjectPrx proxy = __in.readProxy();";
+	_out << nl << "Ice.ObjectPrx proxy = __inS.readProxy();";
 	_out << nl << "if(proxy != null)";
 	_out << sb;
 	_out << nl << name << "PrxHelper result = new " << name << "PrxHelper();";
@@ -3352,12 +3352,12 @@ Slice::Gen::HelperVisitor::visitSequence(const SequencePtr& p)
 
     if(_stream)
     {
-	_out << sp << nl << "public static void write(Ice.OutputStream __out, " << typeS << " __v)";
+	_out << sp << nl << "public static void write(Ice.OutputStream __outS, " << typeS << " __v)";
 	_out << sb;
 	writeSequenceMarshalUnmarshalCode(_out, p, "__v", true, true);
 	_out << eb;
 
-	_out << sp << nl << "public static " << typeS << " read(Ice.InputStream __in)";
+	_out << sp << nl << "public static " << typeS << " read(Ice.InputStream __inS)";
 	_out << sb;
 	_out << nl << typeS << " __v;";
 	writeSequenceMarshalUnmarshalCode(_out, p, "__v", false, true);
@@ -3454,15 +3454,15 @@ Slice::Gen::HelperVisitor::visitDictionary(const DictionaryPtr& p)
 
     if(_stream)
     {
-	_out << sp << nl << "public static void write(Ice.OutputStream __out, " << name << " __v)";
+	_out << sp << nl << "public static void write(Ice.OutputStream __outS, " << name << " __v)";
 	_out << sb;
 	_out << nl << "if(__v == null)";
 	_out << sb;
-	_out << nl << "__out.writeSize(0);";
+	_out << nl << "__outS.writeSize(0);";
 	_out << eb;
 	_out << nl << "else";
 	_out << sb;
-	_out << nl << "__out.writeSize(__v.Count);";
+	_out << nl << "__outS.writeSize(__v.Count);";
 	_out << nl << "foreach(_System.Collections.DictionaryEntry __e in __v)";
 	_out << sb;
 	writeMarshalUnmarshalCode(_out, key, keyArg, true, true, false);
@@ -3471,9 +3471,9 @@ Slice::Gen::HelperVisitor::visitDictionary(const DictionaryPtr& p)
 	_out << eb;
 	_out << eb;
 
-	_out << sp << nl << "public static " << name << " read(Ice.InputStream __in)";
+	_out << sp << nl << "public static " << name << " read(Ice.InputStream __inS)";
 	_out << sb;
-	_out << nl << "int __sz = __in.readSize();";
+	_out << nl << "int __sz = __inS.readSize();";
 	_out << nl << name << " __r = new " << name << "();";
 	_out << nl << "for(int __i = 0; __i < __sz; ++__i)";
 	_out << sb;
@@ -3665,7 +3665,7 @@ Slice::Gen::DelegateMVisitor::visitClassDefStart(const ClassDefPtr& p)
 	_out << sp << nl << "public " << retS << ' ' << opName << spar << params << "Ice.Context __context" << epar;
 	_out << sb;
 
-	_out << nl << "IceInternal.Outgoing __out = getOutgoing(\"" << op->name() << "\", " << sliceModeToIceMode(op)
+	_out << nl << "IceInternal.Outgoing __outS = getOutgoing(\"" << op->name() << "\", " << sliceModeToIceMode(op)
 	     << ", __context, __compress);";
 	_out << nl << "try";
 	_out << sb;
@@ -3673,7 +3673,7 @@ Slice::Gen::DelegateMVisitor::visitClassDefStart(const ClassDefPtr& p)
 	{
 	    _out << nl << "try";
 	    _out << sb;
-	    _out << nl << "IceInternal.BasicStream __os = __out.ostr();";
+	    _out << nl << "IceInternal.BasicStream __os = __outS.ostr();";
 	    for(q = inParams.begin(); q != inParams.end(); ++q)
 	    {
 		writeMarshalUnmarshalCode(_out, q->first, fixId(q->second), true, false, false);
@@ -3685,14 +3685,14 @@ Slice::Gen::DelegateMVisitor::visitClassDefStart(const ClassDefPtr& p)
 	    _out << eb;
 	    _out << nl << "catch(Ice.LocalException __ex)";
 	    _out << sb;
-	    _out << nl << "__out.abort(__ex);";
+	    _out << nl << "__outS.abort(__ex);";
 	    _out << eb;
 	}
 	if(!outParams.empty() || ret || !throws.empty())
 	{
-	    _out << nl << "IceInternal.BasicStream __is = __out.istr();";
+	    _out << nl << "IceInternal.BasicStream __is = __outS.istr();";
 	}
-	_out << nl << "if(!__out.invoke())";
+	_out << nl << "if(!__outS.invoke())";
 	_out << sb;
 	if(!throws.empty())
 	{
@@ -3794,7 +3794,7 @@ Slice::Gen::DelegateMVisitor::visitClassDefStart(const ClassDefPtr& p)
         _out << eb;
         _out << nl << "finally";
         _out << sb;
-        _out << nl << "reclaimOutgoing(__out);";
+        _out << nl << "reclaimOutgoing(__outS);";
         _out << eb;
         _out << eb;
     }
diff --git a/cpp/src/slice2java/Gen.cpp b/cpp/src/slice2java/Gen.cpp
index e92cadc18cc..004987f7310 100644
--- a/cpp/src/slice2java/Gen.cpp
+++ b/cpp/src/slice2java/Gen.cpp
@@ -549,7 +549,7 @@ Slice::JavaVisitor::writeDispatch(Output& out, const ClassDefPtr& p)
 
         string opName = op->name();
         out << sp << nl << "public static IceInternal.DispatchStatus" << nl << "___" << opName << '(' << name
-	    << " __obj, IceInternal.Incoming __in, Ice.Current __current)";
+	    << " __obj, IceInternal.Incoming __inS, Ice.Current __current)";
         out << sb;
 
 	bool amd = cl->hasMetaData("amd") || op->hasMetaData("amd");
@@ -593,11 +593,11 @@ Slice::JavaVisitor::writeDispatch(Output& out, const ClassDefPtr& p)
 	    
 	    if(!inParams.empty())
 	    {
-		out << nl << "IceInternal.BasicStream __is = __in.is();";
+		out << nl << "IceInternal.BasicStream __is = __inS.is();";
 	    }
 	    if(!outParams.empty() || ret || !throws.empty())
 	    {
-		out << nl << "IceInternal.BasicStream __os = __in.os();";
+		out << nl << "IceInternal.BasicStream __os = __inS.os();";
 	    }
 	    
 	    //
@@ -724,7 +724,7 @@ Slice::JavaVisitor::writeDispatch(Output& out, const ClassDefPtr& p)
 	    
 	    if(!inParams.empty())
 	    {
-		out << nl << "IceInternal.BasicStream __is = __in.is();";
+		out << nl << "IceInternal.BasicStream __is = __inS.is();";
 	    }
 	    
 	    //
@@ -760,7 +760,7 @@ Slice::JavaVisitor::writeDispatch(Output& out, const ClassDefPtr& p)
 	    //
 	    string classNameAMD = "AMD_" + p->name();
 	    out << nl << classNameAMD << '_' << opName << " __cb = new _" << classNameAMD << '_' << opName
-		<< "(__in);";
+		<< "(__inS);";
             out << nl << "try";
             out << sb;
 	    out << nl << "__obj." << (amd ? opName + "_async" : fixKwd(opName)) << (amd ? "(__cb, " : "(");
@@ -1655,10 +1655,10 @@ Slice::Gen::TypesVisitor::visitClassDefStart(const ClassDefPtr& p)
 
         if(_stream)
         {
-            out << sp << nl << "public void" << nl << "__write(Ice.OutputStream __out)";
+            out << sp << nl << "public void" << nl << "__write(Ice.OutputStream __outS)";
             out << sb;
-            out << nl << "__out.writeTypeId(ice_staticId());";
-            out << nl << "__out.startSlice();";
+            out << nl << "__outS.writeTypeId(ice_staticId());";
+            out << nl << "__outS.startSlice();";
             iter = 0;
             for(d = members.begin(); d != members.end(); ++d)
             {
@@ -1666,17 +1666,17 @@ Slice::Gen::TypesVisitor::visitClassDefStart(const ClassDefPtr& p)
                 writeStreamMarshalUnmarshalCode(out, package, (*d)->type(), fixKwd((*d)->name()), true, iter, false,
                                                 metaData);
             }
-            out << nl << "__out.endSlice();";
-            out << nl << "super.__write(__out);";
+            out << nl << "__outS.endSlice();";
+            out << nl << "super.__write(__outS);";
             out << eb;
 
-            out << sp << nl << "public void" << nl << "__read(Ice.InputStream __in, boolean __rid)";
+            out << sp << nl << "public void" << nl << "__read(Ice.InputStream __inS, boolean __rid)";
             out << sb;
             out << nl << "if(__rid)";
             out << sb;
-            out << nl << "String myId = __in.readTypeId();";
+            out << nl << "String myId = __inS.readTypeId();";
             out << eb;
-            out << nl << "__in.startSlice();";
+            out << nl << "__inS.startSlice();";
             iter = 0;
             for(d = members.begin(); d != members.end(); ++d)
             {
@@ -1693,8 +1693,8 @@ Slice::Gen::TypesVisitor::visitClassDefStart(const ClassDefPtr& p)
                 writeStreamMarshalUnmarshalCode(out, package, (*d)->type(), fixKwd((*d)->name()), false, iter, false,
                                                 metaData, patchParams.str());
             }
-            out << nl << "__in.endSlice();";
-            out << nl << "super.__read(__in, true);";
+            out << nl << "__inS.endSlice();";
+            out << nl << "super.__read(__inS, true);";
             out << eb;
         }
         else
@@ -1703,14 +1703,14 @@ Slice::Gen::TypesVisitor::visitClassDefStart(const ClassDefPtr& p)
             // Emit placeholder functions to catch errors.
             //
             string scoped = p->scoped();
-            out << sp << nl << "public void" << nl << "__write(Ice.OutputStream __out)";
+            out << sp << nl << "public void" << nl << "__write(Ice.OutputStream __outS)";
             out << sb;
             out << nl << "Ice.MarshalException ex = new Ice.MarshalException();";
             out << nl << "ex.reason = \"type " << scoped.substr(2) << " was not generated with stream support\";";
             out << nl << "throw ex;";
             out << eb;
 
-            out << sp << nl << "public void" << nl << "__read(Ice.InputStream __in, boolean __rid)";
+            out << sp << nl << "public void" << nl << "__read(Ice.InputStream __inS, boolean __rid)";
             out << sb;
             out << nl << "Ice.MarshalException ex = new Ice.MarshalException();";
             out << nl << "ex.reason = \"type " << scoped.substr(2) << " was not generated with stream support\";";
@@ -1919,10 +1919,10 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
 
         if(_stream)
         {
-            out << sp << nl << "public void" << nl << "__write(Ice.OutputStream __out)";
+            out << sp << nl << "public void" << nl << "__write(Ice.OutputStream __outS)";
             out << sb;
-            out << nl << "__out.writeString(\"" << scoped << "\");";
-            out << nl << "__out.startSlice();";
+            out << nl << "__outS.writeString(\"" << scoped << "\");";
+            out << nl << "__outS.startSlice();";
             iter = 0;
             for(d = members.begin(); d != members.end(); ++d)
             {
@@ -1930,20 +1930,20 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
                 writeStreamMarshalUnmarshalCode(out, package, (*d)->type(), fixKwd((*d)->name()), true, iter, false,
                                                 metaData);
             }
-            out << nl << "__out.endSlice();";
+            out << nl << "__outS.endSlice();";
             if(base)
             {
-                out << nl << "super.__write(__out);";
+                out << nl << "super.__write(__outS);";
             }
             out << eb;
 
-            out << sp << nl << "public void" << nl << "__read(Ice.InputStream __in, boolean __rid)";
+            out << sp << nl << "public void" << nl << "__read(Ice.InputStream __inS, boolean __rid)";
             out << sb;
             out << nl << "if(__rid)";
             out << sb;
-            out << nl << "String myId = __in.readString();";
+            out << nl << "String myId = __inS.readString();";
             out << eb;
-            out << nl << "__in.startSlice();";
+            out << nl << "__inS.startSlice();";
             iter = 0;
             for(d = members.begin(); d != members.end(); ++d)
             {
@@ -1960,10 +1960,10 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
                 writeStreamMarshalUnmarshalCode(out, package, (*d)->type(), fixKwd((*d)->name()), false, iter, false,
                                                 metaData, patchParams.str());
             }
-            out << nl << "__in.endSlice();";
+            out << nl << "__inS.endSlice();";
             if(base)
             {
-                out << nl << "super.__read(__in, true);";
+                out << nl << "super.__read(__inS, true);";
             }
             out << eb;
         }
@@ -1973,14 +1973,14 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
             // Emit placeholder functions to catch errors.
             //
             string scoped = p->scoped();
-            out << sp << nl << "public void" << nl << "__write(Ice.OutputStream __out)";
+            out << sp << nl << "public void" << nl << "__write(Ice.OutputStream __outS)";
             out << sb;
             out << nl << "Ice.MarshalException ex = new Ice.MarshalException();";
             out << nl << "ex.reason = \"exception " << scoped.substr(2) << " was not generated with stream support\";";
             out << nl << "throw ex;";
             out << eb;
 
-            out << sp << nl << "public void" << nl << "__read(Ice.InputStream __in, boolean __rid)";
+            out << sp << nl << "public void" << nl << "__read(Ice.InputStream __inS, boolean __rid)";
             out << sb;
             out << nl << "Ice.MarshalException ex = new Ice.MarshalException();";
             out << nl << "ex.reason = \"exception " << scoped.substr(2) << " was not generated with stream support\";";
@@ -2273,7 +2273,7 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
 
         if(_stream)
         {
-            out << sp << nl << "public void" << nl << "__write(Ice.OutputStream __out)";
+            out << sp << nl << "public void" << nl << "__write(Ice.OutputStream __outS)";
             out << sb;
             iter = 0;
             for(d = members.begin(); d != members.end(); ++d)
@@ -2284,7 +2284,7 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
             }
             out << eb;
 
-            out << sp << nl << "public void" << nl << "__read(Ice.InputStream __in)";
+            out << sp << nl << "public void" << nl << "__read(Ice.InputStream __inS)";
             out << sb;
             iter = 0;
             classMemberCount = 0;
@@ -2416,35 +2416,35 @@ Slice::Gen::TypesVisitor::visitEnum(const EnumPtr& p)
 
         if(_stream)
         {
-            out << sp << nl << "public void" << nl << "__write(Ice.OutputStream __out)";
+            out << sp << nl << "public void" << nl << "__write(Ice.OutputStream __outS)";
             out << sb;
             if(sz <= 0x7f)
             {
-                out << nl << "__out.writeByte((byte)__value);";
+                out << nl << "__outS.writeByte((byte)__value);";
             }
             else if(sz <= 0x7fff)
             {
-                out << nl << "__out.writeShort((short)__value);";
+                out << nl << "__outS.writeShort((short)__value);";
             }
             else
             {
-                out << nl << "__out.writeInt(__value);";
+                out << nl << "__outS.writeInt(__value);";
             }
             out << eb;
 
-            out << sp << nl << "public static " << name << nl << "__read(Ice.InputStream __in)";
+            out << sp << nl << "public static " << name << nl << "__read(Ice.InputStream __inS)";
             out << sb;
             if(sz <= 0x7f)
             {
-                out << nl << "int __v = __in.readByte();";
+                out << nl << "int __v = __inS.readByte();";
             }
             else if(sz <= 0x7fff)
             {
-                out << nl << "int __v = __in.readShort();";
+                out << nl << "int __v = __inS.readShort();";
             }
             else
             {
-                out << nl << "int __v = __in.readInt();";
+                out << nl << "int __v = __inS.readInt();";
             }
             out << nl << "if(__v < 0 || __v >= " << sz << ')';
             out << sb;
@@ -3016,14 +3016,14 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
 
     if(_stream)
     {
-        out << sp << nl << "public static void" << nl << "write(Ice.OutputStream __out, " << name << "Prx v)";
+        out << sp << nl << "public static void" << nl << "write(Ice.OutputStream __outS, " << name << "Prx v)";
         out << sb;
-        out << nl << "__out.writeProxy(v);";
+        out << nl << "__outS.writeProxy(v);";
         out << eb;
 
-        out << sp << nl << "public static " << name << "Prx" << nl << "read(Ice.InputStream __in)";
+        out << sp << nl << "public static " << name << "Prx" << nl << "read(Ice.InputStream __inS)";
         out << sb;
-        out << nl << "Ice.ObjectPrx proxy = __in.readProxy();";
+        out << nl << "Ice.ObjectPrx proxy = __inS.readProxy();";
         out << nl << "if(proxy != null)";
         out << sb;
         out << nl << name << "PrxHelper result = new " << name << "PrxHelper();";
@@ -3052,14 +3052,14 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
         out2 << sp << nl << "public final class " << name << "Helper";
         out2 << sb;
 
-        out2 << sp << nl << "public static void" << nl << "write(Ice.OutputStream __out, " << fixKwd(name) << " __v)";
+        out2 << sp << nl << "public static void" << nl << "write(Ice.OutputStream __outS, " << fixKwd(name) << " __v)";
         out2 << sb;
-        out2 << nl << "__out.writeObject(__v);";
+        out2 << nl << "__outS.writeObject(__v);";
         out2 << eb;
 
-        out2 << sp << nl << "public static void" << nl << "read(Ice.InputStream __in, " << name << "Holder __h)";
+        out2 << sp << nl << "public static void" << nl << "read(Ice.InputStream __inS, " << name << "Holder __h)";
         out2 << sb;
-        out2 << nl << "__in.readObject(__h.getPatcher());";
+        out2 << nl << "__inS.readObject(__h.getPatcher());";
         out2 << eb;
 
         out2 << eb;
@@ -3087,15 +3087,15 @@ Slice::Gen::HelperVisitor::visitStructStart(const StructPtr& p)
         out << sp << nl << "public final class " << name << "Helper";
         out << sb;
 
-        out << sp << nl << "public static void" << nl << "write(Ice.OutputStream __out, " << fixedName << " __v)";
+        out << sp << nl << "public static void" << nl << "write(Ice.OutputStream __outS, " << fixedName << " __v)";
         out << sb;
-        out << nl << "__v.__write(__out);";
+        out << nl << "__v.__write(__outS);";
         out << eb;
 
-        out << sp << nl << "public static " << fixedName << nl << "read(Ice.InputStream __in)";
+        out << sp << nl << "public static " << fixedName << nl << "read(Ice.InputStream __inS)";
         out << sb;
         out << nl << fixedName << " __v = new " << fixedName << "();";
-        out << nl << "__v.__read(__in);";
+        out << nl << "__v.__read(__inS);";
         out << nl << "return __v;";
         out << eb;
 
@@ -3147,13 +3147,13 @@ Slice::Gen::HelperVisitor::visitSequence(const SequencePtr& p)
 
         if(_stream)
         {
-            out << sp << nl << "public static void" << nl << "write(Ice.OutputStream __out, " << typeS << " __v)";
+            out << sp << nl << "public static void" << nl << "write(Ice.OutputStream __outS, " << typeS << " __v)";
             out << sb;
             iter = 0;
             writeStreamSequenceMarshalUnmarshalCode(out, package, p, "__v", true, iter, false);
             out << eb;
 
-            out << sp << nl << "public static " << typeS << nl << "read(Ice.InputStream __in)";
+            out << sp << nl << "public static " << typeS << nl << "read(Ice.InputStream __inS)";
             out << sb;
             out << nl << typeS << " __v;";
             iter = 0;
@@ -3494,15 +3494,15 @@ Slice::Gen::HelperVisitor::visitDictionary(const DictionaryPtr& p)
 
         if(_stream)
         {
-            out << sp << nl << "public static void" << nl << "write(Ice.OutputStream __out, " << "java.util.Map __v)";
+            out << sp << nl << "public static void" << nl << "write(Ice.OutputStream __outS, " << "java.util.Map __v)";
             out << sb;
             out << nl << "if(__v == null)";
             out << sb;
-            out << nl << "__out.writeSize(0);";
+            out << nl << "__outS.writeSize(0);";
             out << eb;
             out << nl << "else";
             out << sb;
-            out << nl << "__out.writeSize(__v.size());";
+            out << nl << "__outS.writeSize(__v.size());";
             out << nl << "java.util.Iterator __i = __v.entrySet().iterator();";
             out << nl << "while(__i.hasNext())";
             out << sb;
@@ -3589,9 +3589,9 @@ Slice::Gen::HelperVisitor::visitDictionary(const DictionaryPtr& p)
             out << eb;
 
 	    out << sp << nl << "public static " << (dictType.empty() ? "java.util.Map" : dictType)
-                << nl << "read(Ice.InputStream __in)";
+                << nl << "read(Ice.InputStream __inS)";
             out << sb;
-            out << nl << "int __sz = __in.readSize();";
+            out << nl << "int __sz = __inS.readSize();";
 	    out << nl << (dictType.empty() ? "java.util.Map" : dictType) << " __r = new "
 		<< (dictType.empty() ? "java.util.HashMap(__sz)" : dictType + "()") << ';';
             out << nl << "for(int __i = 0; __i < __sz; __i++)";
@@ -3619,52 +3619,52 @@ Slice::Gen::HelperVisitor::visitDictionary(const DictionaryPtr& p)
                     {
                         case Builtin::KindByte:
                         {
-                            out << nl << "java.lang.Byte " << arg << " = new java.lang.Byte(__in.readByte());";
+                            out << nl << "java.lang.Byte " << arg << " = new java.lang.Byte(__inS.readByte());";
                             break;
                         }
                         case Builtin::KindBool:
                         {
-                            out << nl << "java.lang.Boolean " << arg << " = new java.lang.Boolean(__in.readBool());";
+                            out << nl << "java.lang.Boolean " << arg << " = new java.lang.Boolean(__inS.readBool());";
                             break;
                         }
                         case Builtin::KindShort:
                         {
-                            out << nl << "java.lang.Short " << arg << " = new java.lang.Short(__in.readShort());";
+                            out << nl << "java.lang.Short " << arg << " = new java.lang.Short(__inS.readShort());";
                             break;
                         }
                         case Builtin::KindInt:
                         {
-                            out << nl << "java.lang.Integer " << arg << " = new java.lang.Integer(__in.readInt());";
+                            out << nl << "java.lang.Integer " << arg << " = new java.lang.Integer(__inS.readInt());";
                             break;
                         }
                         case Builtin::KindLong:
                         {
-                            out << nl << "java.lang.Long " << arg << " = new java.lang.Long(__in.readLong());";
+                            out << nl << "java.lang.Long " << arg << " = new java.lang.Long(__inS.readLong());";
                             break;
                         }
                         case Builtin::KindFloat:
                         {
-                            out << nl << "java.lang.Float " << arg << " = new java.lang.Float(__in.readFloat());";
+                            out << nl << "java.lang.Float " << arg << " = new java.lang.Float(__inS.readFloat());";
                             break;
                         }
                         case Builtin::KindDouble:
                         {
-                            out << nl << "java.lang.Double " << arg << " = new java.lang.Double(__in.readDouble());";
+                            out << nl << "java.lang.Double " << arg << " = new java.lang.Double(__inS.readDouble());";
                             break;
                         }
                         case Builtin::KindString:
                         {
-                            out << nl << "java.lang.String " << arg << " = __in.readString();";
+                            out << nl << "java.lang.String " << arg << " = __inS.readString();";
                             break;
                         }
                         case Builtin::KindObject:
                         {
-                            out << nl << "__in.readObject(new Patcher(__r, __key));";
+                            out << nl << "__inS.readObject(new Patcher(__r, __key));";
                             break;
                         }
                         case Builtin::KindObjectProxy:
                         {
-                            out << nl << "Ice.ObjectPrx " << arg << " = __in.readProxy();";
+                            out << nl << "Ice.ObjectPrx " << arg << " = __inS.readProxy();";
                             break;
                         }
                         case Builtin::KindLocalObject:
@@ -3722,14 +3722,14 @@ Slice::Gen::HelperVisitor::visitEnum(const EnumPtr& p)
         out << sp << nl << "public final class " << name << "Helper";
         out << sb;
 
-        out << sp << nl << "public static void" << nl << "write(Ice.OutputStream __out, " << fixedName << " __v)";
+        out << sp << nl << "public static void" << nl << "write(Ice.OutputStream __outS, " << fixedName << " __v)";
         out << sb;
-        out << nl << "__v.__write(__out);";
+        out << nl << "__v.__write(__outS);";
         out << eb;
 
-        out << sp << nl << "public static " << fixedName << nl << "read(Ice.InputStream __in)";
+        out << sp << nl << "public static " << fixedName << nl << "read(Ice.InputStream __inS)";
         out << sb;
-        out << nl << "return " << fixedName << ".__read(__in);";
+        out << nl << "return " << fixedName << ".__read(__inS);";
         out << eb;
 
         out << eb;
@@ -3996,7 +3996,7 @@ Slice::Gen::DelegateMVisitor::visitClassDefStart(const ClassDefPtr& p)
         writeDelegateThrowsClause(package, throws);
         out << sb;
 
-        out << nl << "IceInternal.Outgoing __out = getOutgoing(\"" << op->name() << "\", " << sliceModeToIceMode(op)
+        out << nl << "IceInternal.Outgoing __outS = getOutgoing(\"" << op->name() << "\", " << sliceModeToIceMode(op)
 	    << ", __ctx);";
         out << nl << "try";
         out << sb;
@@ -4004,7 +4004,7 @@ Slice::Gen::DelegateMVisitor::visitClassDefStart(const ClassDefPtr& p)
         {
 	    out << nl << "try";
 	    out << sb;
-            out << nl << "IceInternal.BasicStream __os = __out.os();";
+            out << nl << "IceInternal.BasicStream __os = __outS.os();";
 	    iter = 0;
 	    for(pli = inParams.begin(); pli != inParams.end(); ++pli)
 	    {
@@ -4018,13 +4018,13 @@ Slice::Gen::DelegateMVisitor::visitClassDefStart(const ClassDefPtr& p)
 	    out << eb;
 	    out << nl << "catch(Ice.LocalException __ex)";
 	    out << sb;
-	    out << nl << "__out.abort(__ex);";
+	    out << nl << "__outS.abort(__ex);";
 	    out << eb;
 	}
-	out << nl << "boolean __ok = __out.invoke();";
+	out << nl << "boolean __ok = __outS.invoke();";
 	out << nl << "try";
 	out << sb;
-	out << nl << "IceInternal.BasicStream __is = __out.is();";
+	out << nl << "IceInternal.BasicStream __is = __outS.is();";
         out << nl << "if(!__ok)";
         out << sb;
 	out << nl << "try";
@@ -4086,7 +4086,7 @@ Slice::Gen::DelegateMVisitor::visitClassDefStart(const ClassDefPtr& p)
         out << eb;
         out << nl << "finally";
         out << sb;
-        out << nl << "reclaimOutgoing(__out);";
+        out << nl << "reclaimOutgoing(__outS);";
         out << eb;
         out << eb;
     }
diff --git a/cpp/src/slice2vb/Gen.cpp b/cpp/src/slice2vb/Gen.cpp
index f16553b4d55..7f3787184aa 100755
--- a/cpp/src/slice2vb/Gen.cpp
+++ b/cpp/src/slice2vb/Gen.cpp
@@ -301,7 +301,7 @@ Slice::VbVisitor::writeDispatch(const ClassDefPtr& p)
 	_out.inc();
 	_out.inc();
 	_out << nl << "ByVal __obj As _" << p->name() << "Operations, _";
-	_out << nl << "ByVal __in As IceInternal.Incoming, _";
+	_out << nl << "ByVal __inS As IceInternal.Incoming, _";
 	_out << nl << "ByVal __current As Ice.Current) As IceInternal.DispatchStatus";
         _out.dec();
 
@@ -345,11 +345,11 @@ Slice::VbVisitor::writeDispatch(const ClassDefPtr& p)
 	    
 	    if(!inParams.empty())
 	    {
-		_out << nl << "Dim __is As IceInternal.BasicStream = __in.istr()";
+		_out << nl << "Dim __is As IceInternal.BasicStream = __inS.istr()";
 	    }
 	    if(!outParams.empty() || ret || !throws.empty())
 	    {
-		_out << nl << "Dim __os As IceInternal.BasicStream = __in.ostr()";
+		_out << nl << "Dim __os As IceInternal.BasicStream = __inS.ostr()";
 	    }
 	    
 	    //
@@ -479,7 +479,7 @@ Slice::VbVisitor::writeDispatch(const ClassDefPtr& p)
 	    
 	    if(!inParams.empty())
 	    {
-		_out << nl << "Dim __is As IceInternal.BasicStream = __in.istr()";
+		_out << nl << "Dim __is As IceInternal.BasicStream = __inS.istr()";
 	    }
 	    
 	    //
@@ -515,7 +515,7 @@ Slice::VbVisitor::writeDispatch(const ClassDefPtr& p)
 	    //
 	    string classNameAMD = "AMD_" + p->name();
 	    _out << nl << "Dim __cb As " << classNameAMD << '_' << op->name() << " = new _"
-	         << classNameAMD << '_' << op->name() << "(__in)";
+	         << classNameAMD << '_' << op->name() << "(__inS)";
             _out << nl << "Try";
             _out.inc();
 	    _out << nl << "__obj.";
@@ -613,7 +613,7 @@ Slice::VbVisitor::writeDispatch(const ClassDefPtr& p)
 	_out << sp << nl << "Public Overloads Overrides Function __dispatch( _";
 	_out.inc();
 	_out.inc();
-	_out << nl << "ByVal __in As IceInternal.Incoming, _";
+	_out << nl << "ByVal __inS As IceInternal.Incoming, _";
 	_out << nl << "ByVal __current As Ice.Current) As IceInternal.DispatchStatus";
 	_out.dec();
 	_out << nl << "Dim pos As Integer";
@@ -635,19 +635,19 @@ Slice::VbVisitor::writeDispatch(const ClassDefPtr& p)
 	    _out.inc();
 	    if(opName == "ice_id")
 	    {
-		_out << nl << "Return ___ice_id(Me, __in, __current)";
+		_out << nl << "Return ___ice_id(Me, __inS, __current)";
 	    }
 	    else if(opName == "ice_ids")
 	    {
-		_out << nl << "Return ___ice_ids(Me, __in, __current)";
+		_out << nl << "Return ___ice_ids(Me, __inS, __current)";
 	    }
 	    else if(opName == "ice_isA")
 	    {
-		_out << nl << "Return ___ice_isA(Me, __in, __current)";
+		_out << nl << "Return ___ice_isA(Me, __inS, __current)";
 	    }
 	    else if(opName == "ice_ping")
 	    {
-		_out << nl << "Return ___ice_ping(Me, __in, __current)";
+		_out << nl << "Return ___ice_ping(Me, __inS, __current)";
 	    }
 	    else
 	    {
@@ -663,7 +663,7 @@ Slice::VbVisitor::writeDispatch(const ClassDefPtr& p)
 			assert(cl);
 			if(cl->scoped() == p->scoped())
 			{
-			    _out << nl << "Return ___" << opName << "(Me, __in, __current)";
+			    _out << nl << "Return ___" << opName << "(Me, __inS, __current)";
 			}
 			else
 			{
@@ -675,7 +675,7 @@ Slice::VbVisitor::writeDispatch(const ClassDefPtr& p)
 				base = base.insert(pos + 2, "_");
 				base += "Disp";
 			    }
-			    _out << nl << "Return " << fixId(base) << ".___" << opName << "(Me, __in, __current)";
+			    _out << nl << "Return " << fixId(base) << ".___" << opName << "(Me, __inS, __current)";
 			}
 			break;
 		    }
@@ -1073,17 +1073,17 @@ Slice::Gen::TypesVisitor::visitClassDefStart(const ClassDefPtr& p)
         _out << sp << nl << "Public NotInheritable Class " << p->name() << "Helper";
 	_out.inc();
 
-	_out << sp << nl << "Public Sub New(ByVal __in As Ice.InputStream)";
+	_out << sp << nl << "Public Sub New(ByVal __inS As Ice.InputStream)";
 	_out.inc();
-	_out << nl << "_in = __in";
+	_out << nl << "_in = __inS";
 	_out << nl << "_pp = New IceInternal.ParamPatcher(GetType(" << scoped << "))";
 	_out.dec();
 	_out << nl << "End Sub";
 
-	_out << sp << nl << "Public Shared Sub write(ByVal __out As Ice.OutputStream, ByVal __v As "
+	_out << sp << nl << "Public Shared Sub write(ByVal __outS As Ice.OutputStream, ByVal __v As "
 	     << fixId(name) << ')';
 	_out.inc();
-	_out << nl << "__out.writeObject(__v)";
+	_out << nl << "__outS.writeObject(__v)";
 	_out.dec();
 	_out << nl << "End Sub";
 
@@ -1353,10 +1353,10 @@ Slice::Gen::TypesVisitor::visitClassDefEnd(const ClassDefPtr& p)
 	//
 	if(_stream)
 	{
-	    _out << sp << nl << "Public Overloads Overrides Sub __write(ByVal __out As Ice.OutputStream)";
+	    _out << sp << nl << "Public Overloads Overrides Sub __write(ByVal __outS As Ice.OutputStream)";
 	    _out.inc();
-	    _out << nl << "__out.writeTypeId(ice_staticId())";
-	    _out << nl << "__out.startSlice()";
+	    _out << nl << "__outS.writeTypeId(ice_staticId())";
+	    _out << nl << "__outS.startSlice()";
 	    for(d = members.begin(); d != members.end(); ++d)
 	    {
 		StringList metaData = (*d)->getMetaData();
@@ -1364,20 +1364,20 @@ Slice::Gen::TypesVisitor::visitClassDefEnd(const ClassDefPtr& p)
 					  fixId((*d)->name(), DotNet::ICloneable, true),
 					  true, true, false);
 	    }
-	    _out << nl << "__out.endSlice()";
-	    _out << nl << "MyBase.__write(__out)";
+	    _out << nl << "__outS.endSlice()";
+	    _out << nl << "MyBase.__write(__outS)";
 	    _out.dec();
 	    _out << nl << "End Sub";
 
 	    _out << sp << nl << "Public Overloads Overrides Sub __read"
-	         << "(ByVal __in As Ice.InputStream, ByVal __rid As Boolean)";
+	         << "(ByVal __inS As Ice.InputStream, ByVal __rid As Boolean)";
 	    _out.inc();
 	    _out << nl << "If __rid Then";
 	    _out.inc();
-	    _out << nl << "Dim myId As String = __in.readTypeId()";
+	    _out << nl << "Dim myId As String = __inS.readTypeId()";
 	    _out.dec();
 	    _out << nl << "End If";
-	    _out << nl << "__in.startSlice()";
+	    _out << nl << "__inS.startSlice()";
 	    for(d = members.begin(); d != members.end(); ++d)
 	    {
 		StringList metaData = (*d)->getMetaData();
@@ -1395,8 +1395,8 @@ Slice::Gen::TypesVisitor::visitClassDefEnd(const ClassDefPtr& p)
 					  fixId((*d)->name(), DotNet::ICloneable, true),
 					  false, true, false, patchParams.str());
 	    }
-	    _out << nl << "__in.endSlice()";
-	    _out << nl << "MyBase.__read(__in, True)";
+	    _out << nl << "__inS.endSlice()";
+	    _out << nl << "MyBase.__read(__inS, True)";
 	    _out.dec();
 	    _out << nl << "End Sub";
 	}
@@ -1406,7 +1406,7 @@ Slice::Gen::TypesVisitor::visitClassDefEnd(const ClassDefPtr& p)
 	    // Emit placeholder functions to catch errors.
 	    //
             string scoped = p->scoped();
-	    _out << sp << nl << "Public Overloads Overrides Sub __write(ByVal __out As Ice.OutputStream)";
+	    _out << sp << nl << "Public Overloads Overrides Sub __write(ByVal __outS As Ice.OutputStream)";
 	    _out.inc();
 	    _out << nl << "Dim ex As Ice.MarshalException = New Ice.MarshalException";
 	    _out << nl << "ex.reason = \"type " << scoped.substr(2) << " was not generated with stream support\"";
@@ -1415,7 +1415,7 @@ Slice::Gen::TypesVisitor::visitClassDefEnd(const ClassDefPtr& p)
 	    _out << nl << "End Sub";
 
 	    _out << sp << nl << "Public Overloads Overrides Sub __read"
-	         << "(ByVal __in As Ice.InputStream, ByVal __rid As Boolean)";
+	         << "(ByVal __inS As Ice.InputStream, ByVal __rid As Boolean)";
 	    _out.inc();
 	    _out << nl << "Dim ex As Ice.MarshalException = New Ice.MarshalException";
 	    _out << nl << "ex.reason = \"type " << scoped.substr(2) << " was not generated with stream support\"";
@@ -2133,33 +2133,33 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
 
 	if(_stream)
 	{
-	    _out << sp << nl << "Public Overloads Overrides Sub __write(ByVal __out As Ice.OutputStream)";
+	    _out << sp << nl << "Public Overloads Overrides Sub __write(ByVal __outS As Ice.OutputStream)";
 	    _out.inc();
-	    _out << nl << "__out.writeString(\"" << scoped << "\")";
-	    _out << nl << "__out.startSlice()";
+	    _out << nl << "__outS.writeString(\"" << scoped << "\")";
+	    _out << nl << "__outS.startSlice()";
 	    for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
 	    {
 		writeMarshalUnmarshalCode(_out, (*q)->type(),
 					  fixId((*q)->name(), DotNet::ApplicationException),
 					  true, true, false);
 	    }
-	    _out << nl << "__out.endSlice()";
+	    _out << nl << "__outS.endSlice()";
 	    if(base)
 	    {
-		_out << nl << "MyBase.__write(__out)";
+		_out << nl << "MyBase.__write(__outS)";
 	    }
 	    _out.dec();
 	    _out << nl << "End Sub";
 
-	    _out << sp << nl << "Public Overloads Overrides Sub __read(ByVal __in As Ice.InputStream, "
+	    _out << sp << nl << "Public Overloads Overrides Sub __read(ByVal __inS As Ice.InputStream, "
 		 << "ByVal __rid As Boolean)";
 	    _out.inc();
 	    _out << nl << "If __rid Then";
 	    _out.inc();
-	    _out << nl << "Dim myId As String = __in.readString()";
+	    _out << nl << "Dim myId As String = __inS.readString()";
 	    _out.dec();
 	    _out << nl << "End If";
-	    _out << nl << "__in.startSlice()";
+	    _out << nl << "__inS.startSlice()";
 	    classMemberCount = static_cast<int>(allClassMembers.size() - classMembers.size());
 	    for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
 	    {
@@ -2177,10 +2177,10 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
 					  fixId((*q)->name(), DotNet::ApplicationException),
 					  false, true, false, patchParams.str());
 	    }
-	    _out << nl << "__in.endSlice()";
+	    _out << nl << "__inS.endSlice()";
 	    if(base)
 	    {
-		_out << nl << "MyBase.__read(__in, true)";
+		_out << nl << "MyBase.__read(__inS, true)";
 	    }
 	    _out.dec();
 	    _out << nl << "End Sub";
@@ -2191,7 +2191,7 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
 	    // Emit placeholder functions to catch errors.
 	    //
             string scoped = p->scoped();
-	    _out << sp << nl << "Public Overloads Overrides Sub __write(ByVal __out As Ice.OutputStream)";
+	    _out << sp << nl << "Public Overloads Overrides Sub __write(ByVal __outS As Ice.OutputStream)";
 	    _out.inc();
 	    _out << nl << "Dim ex As Ice.MarshalException = New Ice.MarshalException";
 	    _out << nl << "ex.reason = \"type " << scoped.substr(2) << " was not generated with stream support\"";
@@ -2200,7 +2200,7 @@ Slice::Gen::TypesVisitor::visitExceptionEnd(const ExceptionPtr& p)
 	    _out << nl << "End Sub";
 
 	    _out << sp << nl << "Public Overloads Overrides Sub __read"
-	         << "(ByVal __in As Ice.InputStream, ByVal __rid As Boolean)";
+	         << "(ByVal __inS As Ice.InputStream, ByVal __rid As Boolean)";
 	    _out.inc();
 	    _out << nl << "Dim ex As Ice.MarshalException = New Ice.MarshalException";
 	    _out << nl << "ex.reason = \"type " << scoped.substr(2) << " was not generated with stream support\"";
@@ -2237,16 +2237,16 @@ Slice::Gen::TypesVisitor::visitStructStart(const StructPtr& p)
         _out << sp << nl << "Public NotInheritable Class " << p->name() << "Helper";
 	_out.inc();
 
-	_out << sp << nl << "Public Shared Sub write(ByVal __out As Ice.OutputStream, ByVal __v As " << name << ')';
+	_out << sp << nl << "Public Shared Sub write(ByVal __outS As Ice.OutputStream, ByVal __v As " << name << ')';
 	_out.inc();
-	_out << nl << "__v.__write(__out)";
+	_out << nl << "__v.__write(__outS)";
 	_out.dec();
 	_out << nl << "End Sub";
 
-	_out << sp << nl << "Public Shared Function read(ByVal __in As Ice.InputStream) As " << name;
+	_out << sp << nl << "Public Shared Function read(ByVal __inS As Ice.InputStream) As " << name;
 	_out.inc();
 	_out << nl << "Dim __v As " << name << " = New " << name;
-	_out << nl << "__v.__read(__in)";
+	_out << nl << "__v.__read(__inS)";
 	_out << nl << "Return __v";
 	_out.dec();
 	_out << nl << "End Function";
@@ -2585,7 +2585,7 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
 
 	if(_stream)
 	{
-	    _out << sp << nl << "Public Sub __write(ByVal __out As Ice.OutputStream)";
+	    _out << sp << nl << "Public Sub __write(ByVal __outS As Ice.OutputStream)";
 	    _out.inc();
 	    for(q = dataMembers.begin(); q != dataMembers.end(); ++q)
 	    {
@@ -2596,7 +2596,7 @@ Slice::Gen::TypesVisitor::visitStructEnd(const StructPtr& p)
 	    _out.dec();
 	    _out << nl << "End Sub";
 
-	    _out << sp << nl << "Public Sub __read(ByVal __in As Ice.InputStream)";
+	    _out << sp << nl << "Public Sub __read(ByVal __inS As Ice.InputStream)";
 	    _out.inc();
 	    if(patchStruct)
 	    {
@@ -2965,13 +2965,13 @@ Slice::Gen::TypesVisitor::visitEnum(const EnumPtr& p)
 	_out << sp << nl << "Public NotInheritable Class " << name << "Helper";
 	_out.inc();
 
-	_out << sp << nl << "Public Shared Sub write(ByVal __out As Ice.OutputStream, ByVal __v As " << scoped << ')';
+	_out << sp << nl << "Public Shared Sub write(ByVal __outS As Ice.OutputStream, ByVal __v As " << scoped << ')';
 	_out.inc();
 	writeMarshalUnmarshalCode(_out, p, "__v", true, true, false);
 	_out.dec();
 	_out << nl << "End Sub";
 
-	_out << sp << nl << "Public Shared Function read(ByVal __in As Ice.InputStream) As " << scoped;
+	_out << sp << nl << "Public Shared Function read(ByVal __inS As Ice.InputStream) As " << scoped;
 	_out.inc();
 	_out << nl << "Dim __v As " << scoped;
 	writeMarshalUnmarshalCode(_out, p, "__v", false, true, false);
@@ -3710,15 +3710,15 @@ Slice::Gen::HelperVisitor::visitClassDefStart(const ClassDefPtr& p)
 
     if(_stream)
     {
-	_out << sp << nl << "Public Shared Sub write(ByVal __out As Ice.OutputStream, ByVal __v As " << name << "Prx)";
+	_out << sp << nl << "Public Shared Sub write(ByVal __outS As Ice.OutputStream, ByVal __v As " << name << "Prx)";
 	_out.inc();
-	_out << nl << "__out.writeProxy(__v)";
+	_out << nl << "__outS.writeProxy(__v)";
 	_out.dec();
 	_out << nl << "End Sub";
 
-	_out << sp << nl << "Public Shared Function read(ByVal __in As Ice.InputStream) As " << name << "Prx";
+	_out << sp << nl << "Public Shared Function read(ByVal __inS As Ice.InputStream) As " << name << "Prx";
 	_out.inc();
-	_out << nl << "Dim proxy As Ice.ObjectPrx = __in.readProxy()";
+	_out << nl << "Dim proxy As Ice.ObjectPrx = __inS.readProxy()";
 	_out << nl << "If Not proxy Is Nothing";
 	_out.inc();
 	_out << nl << "Dim result As " << name << "PrxHelper = New " << name << "PrxHelper";
@@ -3778,13 +3778,13 @@ Slice::Gen::HelperVisitor::visitSequence(const SequencePtr& p)
 
     if(_stream)
     {
-	_out << sp << nl << "Public Shared Sub write(ByVal __out As Ice.OutputStream, ByVal __v As " << typeS << ')';
+	_out << sp << nl << "Public Shared Sub write(ByVal __outS As Ice.OutputStream, ByVal __v As " << typeS << ')';
 	_out.inc();
 	writeSequenceMarshalUnmarshalCode(_out, p, "__v", true, true);
 	_out.dec();
 	_out << nl << "End Sub";
 
-	_out << sp << nl << "Public Shared Function read(ByVal __in As Ice.InputStream) As " << typeS;
+	_out << sp << nl << "Public Shared Function read(ByVal __inS As Ice.InputStream) As " << typeS;
 	_out.inc();
 	_out << nl << "Dim __v As " << typeS;
 	writeSequenceMarshalUnmarshalCode(_out, p, "__v", false, true);
@@ -3896,15 +3896,15 @@ Slice::Gen::HelperVisitor::visitDictionary(const DictionaryPtr& p)
 
     if(_stream)
     {
-	_out << nl << "Public Shared Sub write(ByVal __out As Ice.OutputStream, ByVal __v As " << name << ')';
+	_out << nl << "Public Shared Sub write(ByVal __outS As Ice.OutputStream, ByVal __v As " << name << ')';
 	_out.inc();
 	_out << nl << "If __v Is Nothing Then";
 	_out.inc();
-	_out << nl << "__out.writeSize(0)";
+	_out << nl << "__outS.writeSize(0)";
 	_out.dec();
 	_out << nl << "Else";
 	_out.inc();
-	_out << nl << "__out.writeSize(__v.Count)";
+	_out << nl << "__outS.writeSize(__v.Count)";
 	_out << nl << "For Each __e As _System.Collections.DictionaryEntry In __v";
 	_out.inc();
 	writeMarshalUnmarshalCode(_out, key, keyArg, true, true, false);
@@ -3916,9 +3916,9 @@ Slice::Gen::HelperVisitor::visitDictionary(const DictionaryPtr& p)
 	_out.dec();
 	_out << nl << "End Sub";
 
-	_out << sp << nl << "Public Shared Function read(ByVal __in As Ice.InputStream) As " << name;
+	_out << sp << nl << "Public Shared Function read(ByVal __inS As Ice.InputStream) As " << name;
 	_out.inc();
-	_out << nl << "Dim __sz As Integer = __in.readSize()";
+	_out << nl << "Dim __sz As Integer = __inS.readSize()";
 	_out << nl << "Dim __r As " << name << " = New " << name;
 	_out << nl << "For __i As Integer = 0 To __sz - 1";
 	_out.inc();
@@ -4131,7 +4131,7 @@ Slice::Gen::DelegateMVisitor::visitClassDefStart(const ClassDefPtr& p)
 	_out << " Implements _" << name << "Del." << opName; // TODO: should be containing class?
 	_out.inc();
 
-	_out << nl << "Dim __out As IceInternal.Outgoing = getOutgoing(\""
+	_out << nl << "Dim __outS As IceInternal.Outgoing = getOutgoing(\""
 	     << op->name() << "\", " << sliceModeToIceMode(op) << ", __context, __compress)";
 	_out << nl << "Try";
 	_out.inc();
@@ -4139,7 +4139,7 @@ Slice::Gen::DelegateMVisitor::visitClassDefStart(const ClassDefPtr& p)
 	{
 	    _out << nl << "Try";
 	    _out.inc();
-	    _out << nl << "Dim __os As IceInternal.BasicStream = __out.ostr()";
+	    _out << nl << "Dim __os As IceInternal.BasicStream = __outS.ostr()";
 	    for(q = inParams.begin(); q != inParams.end(); ++q)
 	    {
 		writeMarshalUnmarshalCode(_out, q->first, fixId(q->second), true, false, false);
@@ -4151,15 +4151,15 @@ Slice::Gen::DelegateMVisitor::visitClassDefStart(const ClassDefPtr& p)
 	    _out.dec();
 	    _out << nl << "Catch __ex As Ice.LocalException";
 	    _out.inc();
-	    _out << nl << "__out.abort(__ex)";
+	    _out << nl << "__outS.abort(__ex)";
 	    _out.dec();
 	    _out << nl << "End Try";
 	}
 	if(!outParams.empty() || ret || !throws.empty())
 	{
-	    _out << nl << "Dim __is As IceInternal.BasicStream = __out.istr()";
+	    _out << nl << "Dim __is As IceInternal.BasicStream = __outS.istr()";
 	}
-	_out << nl << "If Not __out.invoke() Then";
+	_out << nl << "If Not __outS.invoke() Then";
 	_out.inc();
 	if(!throws.empty())
 	{
@@ -4263,7 +4263,7 @@ Slice::Gen::DelegateMVisitor::visitClassDefStart(const ClassDefPtr& p)
         _out.dec();
         _out << nl << "Finally";
         _out.inc();
-        _out << nl << "reclaimOutgoing(__out)";
+        _out << nl << "reclaimOutgoing(__outS)";
         _out.dec();
 	_out << nl << "End Try";