Removed or replaced most double underscores in ObjC

19 files changed, 297 insertions, 297 deletions

diff --git a/objective-c/src/Ice/BatchRequestInterceptor.mm b/objective-c/src/Ice/BatchRequestInterceptor.mm
index 00b1546e14d..5472f9e2415 100644
--- a/objective-c/src/Ice/BatchRequestInterceptor.mm
+++ b/objective-c/src/Ice/BatchRequestInterceptor.mm
@@ -100,6 +100,6 @@ batchRequestInterceptorWithBatchRequestInterceptor:(void(^)(id<ICEBatchRequest>,
 }
 -(id<ICEObjectPrx>) getProxy
 {
-    return [ICEObjectPrx objectPrxWithObjectPrx__:cxxRequest_->getProxy()];
+    return [ICEObjectPrx iceObjectPrxWithObjectPrx:cxxRequest_->getProxy()];
 }
 @end
diff --git a/objective-c/src/Ice/CommunicatorI.mm b/objective-c/src/Ice/CommunicatorI.mm
index 39d1e3a929e..5bd82866953 100644
--- a/objective-c/src/Ice/CommunicatorI.mm
+++ b/objective-c/src/Ice/CommunicatorI.mm
@@ -62,9 +62,9 @@
 @implementation ICECommunicator
 -(void)setup:(ICEInitializationData*)initData
 {
-    if(initData.prefixTable__)
+    if(initData.prefixTable_)
     {
-        prefixTable_ = [initData.prefixTable__ retain];
+        prefixTable_ = [initData.prefixTable_ retain];
     }
     else
     {
@@ -179,7 +179,7 @@
     NSException* nsex = nil;
     try
     {
-        return [ICEObjectPrx objectPrxWithObjectPrx__:COMMUNICATOR->stringToProxy(fromNSString(str))];
+        return [ICEObjectPrx iceObjectPrxWithObjectPrx:COMMUNICATOR->stringToProxy(fromNSString(str))];
     }
     catch(const std::exception& ex)
     {
@@ -194,7 +194,7 @@
     NSException* nsex = nil;
     try
     {
-        return [toNSMutableString(COMMUNICATOR->proxyToString([(ICEObjectPrx*)obj objectPrx__])) autorelease];
+        return [toNSMutableString(COMMUNICATOR->proxyToString([(ICEObjectPrx*)obj iceObjectPrx])) autorelease];
     }
     catch(const std::exception& ex)
     {
@@ -209,7 +209,7 @@
     NSException* nsex = nil;
     try
     {
-        return [ICEObjectPrx objectPrxWithObjectPrx__:COMMUNICATOR->propertyToProxy(fromNSString(property))];
+        return [ICEObjectPrx iceObjectPrxWithObjectPrx:COMMUNICATOR->propertyToProxy(fromNSString(property))];
     }
     catch(const std::exception& ex)
     {
@@ -224,7 +224,7 @@
     NSException* nsex = nil;
     try
     {
-        return [toNSDictionary(COMMUNICATOR->proxyToProperty([(ICEObjectPrx*)prx objectPrx__],
+        return [toNSDictionary(COMMUNICATOR->proxyToProperty([(ICEObjectPrx*)prx iceObjectPrx],
                                                              fromNSString(property))) autorelease];
     }
     catch(const std::exception& ex)
@@ -296,7 +296,7 @@
     NSException* nsex = nil;
     try
     {
-        Ice::RouterPrx router = Ice::RouterPrx::uncheckedCast(Ice::ObjectPrx([(ICEObjectPrx*)rtr objectPrx__]));
+        Ice::RouterPrx router = Ice::RouterPrx::uncheckedCast(Ice::ObjectPrx([(ICEObjectPrx*)rtr iceObjectPrx]));
         ICEObjectAdapter* adapter = [ICEObjectAdapter localObjectWithCxxObject:
                                                           COMMUNICATOR->createObjectAdapterWithRouter(
                                                               fromNSString(name), router).get()];
@@ -382,7 +382,7 @@
     NSException* nsex = nil;
     try
     {
-        return (id<ICERouterPrx>)[ICERouterPrx objectPrxWithObjectPrx__:COMMUNICATOR->getDefaultRouter()];
+        return (id<ICERouterPrx>)[ICERouterPrx iceObjectPrxWithObjectPrx:COMMUNICATOR->getDefaultRouter()];
     }
     catch(const std::exception& ex)
     {
@@ -397,7 +397,7 @@
     NSException* nsex = nil;
     try
     {
-        COMMUNICATOR->setDefaultRouter(Ice::RouterPrx::uncheckedCast(Ice::ObjectPrx([(ICEObjectPrx*)rtr objectPrx__])));
+        COMMUNICATOR->setDefaultRouter(Ice::RouterPrx::uncheckedCast(Ice::ObjectPrx([(ICEObjectPrx*)rtr iceObjectPrx])));
     }
     catch(const std::exception& ex)
     {
@@ -414,7 +414,7 @@
     NSException* nsex = nil;
     try
     {
-        return (id<ICELocatorPrx>)[ICELocatorPrx objectPrxWithObjectPrx__:COMMUNICATOR->getDefaultLocator()];
+        return (id<ICELocatorPrx>)[ICELocatorPrx iceObjectPrxWithObjectPrx:COMMUNICATOR->getDefaultLocator()];
     }
     catch(const std::exception& ex)
     {
@@ -430,7 +430,7 @@
     try
     {
         COMMUNICATOR->setDefaultLocator(Ice::LocatorPrx::uncheckedCast(
-                                            Ice::ObjectPrx([(ICEObjectPrx*)loc objectPrx__])));
+                                            Ice::ObjectPrx([(ICEObjectPrx*)loc iceObjectPrx])));
     }
     catch(const std::exception& ex)
     {
@@ -496,7 +496,7 @@
     try
     {
         Ice::ObjectAdapterPtr adminAdapter = [(ICEObjectAdapter*)adapter adapter];
-        return [ICEObjectPrx objectPrxWithObjectPrx__:COMMUNICATOR->createAdmin(adminAdapter, [adminId identity])];
+        return [ICEObjectPrx iceObjectPrxWithObjectPrx:COMMUNICATOR->createAdmin(adminAdapter, [adminId identity])];
     }
     catch(const std::exception& ex)
     {
@@ -509,7 +509,7 @@
     NSException* nsex;
     try
     {
-        return [ICEObjectPrx objectPrxWithObjectPrx__:COMMUNICATOR->getAdmin()];
+        return [ICEObjectPrx iceObjectPrxWithObjectPrx:COMMUNICATOR->getAdmin()];
     }
     catch(const std::exception& ex)
     {
@@ -522,7 +522,7 @@
     NSException* nsex;
     try
     {
-        COMMUNICATOR->addAdminFacet([servant object__], fromNSString(facet));
+        COMMUNICATOR->addAdminFacet([servant iceObject], fromNSString(facet));
         @synchronized(adminFacets_)
         {
             [adminFacets_ setObject:servant forKey:facet];
diff --git a/objective-c/src/Ice/ConnectionI.mm b/objective-c/src/Ice/ConnectionI.mm
index 09ee73c982f..3b0d642b934 100644
--- a/objective-c/src/Ice/ConnectionI.mm
+++ b/objective-c/src/Ice/ConnectionI.mm
@@ -287,7 +287,7 @@ private:
     NSException* nsex = nil;
     try
     {
-        return [ICEObjectPrx objectPrxWithObjectPrx__:CONNECTION->createProxy([identity identity])];
+        return [ICEObjectPrx iceObjectPrxWithObjectPrx:CONNECTION->createProxy([identity identity])];
     }
     catch(const std::exception& ex)
     {
diff --git a/objective-c/src/Ice/DispatchInterceptor.m b/objective-c/src/Ice/DispatchInterceptor.m
index 0d3eb2ca5b8..0dcbcb665fb 100644
--- a/objective-c/src/Ice/DispatchInterceptor.m
+++ b/objective-c/src/Ice/DispatchInterceptor.m
@@ -15,7 +15,7 @@
 #import <Foundation/NSInvocation.h>
 
 @implementation ICEDispatchInterceptor
--(void) dispatch__:(ICECurrent*)current is:(id<ICEInputStream>)is os:(id<ICEOutputStream>)os
+-(void) iceDispatch:(ICECurrent*)current is:(id<ICEInputStream>)is os:(id<ICEOutputStream>)os
 {
     ICERequest* request = [ICERequest request:current is:is os:os];
     id<ICEDispatchInterceptor> dispatchInterceptor = (id<ICEDispatchInterceptor>)self;
diff --git a/objective-c/src/Ice/Exception.mm b/objective-c/src/Ice/Exception.mm
index 9e5e33010ad..6579d60fcb8 100644
--- a/objective-c/src/Ice/Exception.mm
+++ b/objective-c/src/Ice/Exception.mm
@@ -171,33 +171,33 @@ localExceptionToString(const Ice::LocalException& ex)
 @end
 
 @implementation ICEUserException
--(BOOL)usesClasses__
+-(BOOL)iceUsesClasses
 {
     return NO;
 }
 
--(void)write__:(id<ICEOutputStream>)os
+-(void)iceWrite:(id<ICEOutputStream>)os
 {
     [os startException:nil];
-    [self writeImpl__:os];
+    [self iceWriteImpl:os];
     [os endException];
 }
 
--(void) writeImpl__:(id<ICEOutputStream>)os
+-(void) iceWriteImpl:(id<ICEOutputStream>)os
 {
-    NSAssert(NO, @"writeImpl__ requires override");
+    NSAssert(NO, @"iceWriteImpl requires override");
 }
 
--(void)read__:(id<ICEInputStream>)is
+-(void)iceRead:(id<ICEInputStream>)is
 {
     [is startException];
-    [self readImpl__:is];
+    [self iceReadImpl:is];
     [is endException:NO];
 }
 
--(void) readImpl__:(id<ICEInputStream>)is
+-(void) iceReadImpl:(id<ICEInputStream>)is
 {
-    NSAssert(NO, @"readImpl__ requires override");
+    NSAssert(NO, @"iceReadImpl requires override");
 }
 
 -(id) copyWithZone:(NSZone *)zone
diff --git a/objective-c/src/Ice/ImplicitContextI.h b/objective-c/src/Ice/ImplicitContextI.h
index 74369ccc694..b048e74120f 100644
--- a/objective-c/src/Ice/ImplicitContextI.h
+++ b/objective-c/src/Ice/ImplicitContextI.h
@@ -15,7 +15,7 @@
 {
 @private
 
-    Ice::ImplicitContext* implicitContext__;
+    Ice::ImplicitContext* implicitContext_;
 }
 -(id) init:(Ice::ImplicitContext*)implicitContext;
 +(id) implicitContextWithImplicitContext:(Ice::ImplicitContext*)implicitContext;
diff --git a/objective-c/src/Ice/ImplicitContextI.mm b/objective-c/src/Ice/ImplicitContextI.mm
index 92b12edcf96..1f5bfa7daa5 100644
--- a/objective-c/src/Ice/ImplicitContextI.mm
+++ b/objective-c/src/Ice/ImplicitContextI.mm
@@ -17,8 +17,8 @@
     self = [super init];
     if(self)
     {
-        self->implicitContext__ = implicitContext;
-        self->implicitContext__->__incRef();
+        self->implicitContext_ = implicitContext;
+        self->implicitContext_->__incRef();
     }
     return self;
 }
@@ -37,32 +37,32 @@
 
 -(void) dealloc
 {
-    self->implicitContext__->__decRef();
+    self->implicitContext_->__decRef();
     [super dealloc];
 }
 
 -(ICEContext*) getContext
 {
-    return [toNSDictionary(implicitContext__->getContext()) autorelease];
+    return [toNSDictionary(implicitContext_->getContext()) autorelease];
 }
 
 -(void) setContext:(ICEContext*)context
 {
     Ice::Context ctx;
     fromNSDictionary(context, ctx);
-    implicitContext__->setContext(ctx);
+    implicitContext_->setContext(ctx);
 }
 
 -(BOOL) containsKey:(NSString*)key
 {
-    return implicitContext__->containsKey(fromNSString(key));
+    return implicitContext_->containsKey(fromNSString(key));
 }
 
 -(NSMutableString*) get:(NSString*)key
 {
-    if(implicitContext__->containsKey(fromNSString(key)))
+    if(implicitContext_->containsKey(fromNSString(key)))
     {
-        return [toNSMutableString(implicitContext__->get(fromNSString(key))) autorelease];
+        return [toNSMutableString(implicitContext_->get(fromNSString(key))) autorelease];
     }
     else
     {
@@ -72,12 +72,12 @@
 
 -(NSMutableString*) put:(NSString*)key value:(NSString*)value
 {
-    return [toNSMutableString(implicitContext__->put(fromNSString(key), fromNSString(value))) autorelease];
+    return [toNSMutableString(implicitContext_->put(fromNSString(key), fromNSString(value))) autorelease];
 }
 
 -(NSMutableString*) remove:(NSString*)key
 {
-    return [toNSMutableString(implicitContext__->remove(fromNSString(key))) autorelease];
+    return [toNSMutableString(implicitContext_->remove(fromNSString(key))) autorelease];
 }
 
 @end
diff --git a/objective-c/src/Ice/Initialize.mm b/objective-c/src/Ice/Initialize.mm
index 40f8ce180e7..0f797b2b68a 100644
--- a/objective-c/src/Ice/Initialize.mm
+++ b/objective-c/src/Ice/Initialize.mm
@@ -187,7 +187,7 @@ private:
 @synthesize logger;
 @synthesize dispatcher;
 @synthesize batchRequestInterceptor;
-@synthesize prefixTable__;
+@synthesize prefixTable_;
 
 -(id) init:(id<ICEProperties>)props logger:(id<ICELogger>)log dispatcher:(void(^)(id<ICEDispatcherCall>,
                                                                                   id<ICEConnection>))d;
@@ -222,7 +222,7 @@ private:
     copy->properties = [properties retain];
     copy->logger = [logger retain];
     copy->dispatcher = [dispatcher copy];
-    copy->prefixTable__ = [prefixTable__ retain];
+    copy->prefixTable_ = [prefixTable_ retain];
     return copy;
 }
 
@@ -231,7 +231,7 @@ private:
     NSUInteger h = 0;
     h = (h << 5 ^ [properties hash]);
     h = (h << 5 ^ [logger hash]);
-    h = (h << 5 ^ [prefixTable__ hash]);
+    h = (h << 5 ^ [prefixTable_ hash]);
     return h;
 }
 
@@ -288,16 +288,16 @@ private:
             return NO;
         }
     }
-    if(!prefixTable__)
+    if(!prefixTable_)
     {
-        if(obj->prefixTable__)
+        if(obj->prefixTable_)
         {
             return NO;
         }
     }
     else
     {
-        if(![prefixTable__ isEqual:obj->prefixTable__])
+        if(![prefixTable_ isEqual:obj->prefixTable_])
         {
             return NO;
         }
@@ -310,7 +310,7 @@ private:
     [properties release];
     [logger release];
     [dispatcher release];
-    [prefixTable__ release];
+    [prefixTable_ release];
     [super dealloc];
 }
 @end
diff --git a/objective-c/src/Ice/Object.mm b/objective-c/src/Ice/Object.mm
index 3344fd709b2..ebea699dd0d 100644
--- a/objective-c/src/Ice/Object.mm
+++ b/objective-c/src/Ice/Object.mm
@@ -131,7 +131,7 @@ ObjectI::ice_invoke_async(const Ice::AMD_Object_ice_invokePtr& cb,
         ICECurrent* c = [[ICECurrent alloc] initWithCurrent:current];
         @try
         {
-            [_object dispatch__:c is:is os:os];
+            [_object iceDispatch:c is:is os:os];
         }
         @catch(ICEUserException* ex)
         {
@@ -161,7 +161,7 @@ ObjectI::ice_invoke_async(const Ice::AMD_Object_ice_invokePtr& cb,
     [os release];
 }
 
-BlobjectI::BlobjectI(ICEBlobject* blobject) : _blobject(blobject), _target([blobject target__])
+BlobjectI::BlobjectI(ICEBlobject* blobject) : _blobject(blobject), _target([blobject iceTarget])
 {
 }
 
@@ -284,15 +284,15 @@ ICEInternalCheckModeAndSelector(id target, ICEOperationMode expected, SEL sel, I
 }
 
 @implementation ICEObject (ICEInternal)
--(Ice::Object*) object__
+-(Ice::Object*) iceObject
 {
-    NSAssert(NO, @"object__ requires override");
+    NSAssert(NO, @"iceObject requires override");
     return 0;
 }
 @end
 
 @implementation ICEObject
-static NSString* ICEObject_ids__[1] =
+static NSString* ICEObject_ids[1] =
 {
     @"::Ice::Object"
 };
@@ -359,22 +359,22 @@ static NSString* ICEObject_ids__[1] =
 +(NSString*) ice_staticId
 {
     int count, index;
-    NSString*const* staticIds = [self staticIds__:&count idIndex:&index];
+    NSString*const* staticIds = [self iceStaticIds:&count idIndex:&index];
     return staticIds[index];
 }
-+(NSString*const*) staticIds__:(int*)count idIndex:(int*)idx
++(NSString*const*) iceStaticIds:(int*)count idIndex:(int*)idx
 {
-    *count = sizeof(ICEObject_ids__) / sizeof(NSString*);
+    *count = sizeof(ICEObject_ids) / sizeof(NSString*);
     *idx = 0;
-    return ICEObject_ids__;
+    return ICEObject_ids;
 }
--(void) write__:(id<ICEOutputStream>)os
+-(void) iceWrite:(id<ICEOutputStream>)os
 {
-    NSAssert(NO, @"write__ requires override");
+    NSAssert(NO, @"iceWrite requires override");
 }
--(void) read__:(id<ICEInputStream>)is
+-(void) iceRead:(id<ICEInputStream>)is
 {
-    NSAssert(NO, @"read__ requires override");
+    NSAssert(NO, @"iceRead requires override");
 }
 -(id) copyWithZone:(NSZone*)zone
 {
@@ -383,7 +383,7 @@ static NSString* ICEObject_ids__[1] =
 @end
 
 @implementation ICEServant
-static NSString* ICEObject_all__[4] =
+static NSString* ICEObject_all[4] =
 {
     @"ice_id",
     @"ice_ids",
@@ -398,8 +398,8 @@ static NSString* ICEObject_all__[4] =
     {
         return nil;
     }
-    object__ = 0;
-    delegate__ = 0;
+    iceObject_ = 0;
+    iceDelegate_ = 0;
     return self;
 }
 
@@ -410,19 +410,19 @@ static NSString* ICEObject_all__[4] =
     {
         return nil;
     }
-    object__ = 0;
-    delegate__ = [delegate retain];
+    iceObject_ = 0;
+    iceDelegate_ = [delegate retain];
     return self;
 }
 
 -(void) dealloc
 {
-    if(object__)
+    if(iceObject_)
     {
-        delete static_cast<IceObjC::ServantWrapper*>(object__);
-        object__ = 0;
+        delete static_cast<IceObjC::ServantWrapper*>(iceObject_);
+        iceObject_ = 0;
     }
-    [delegate__ release];
+    [iceDelegate_ release];
     [super dealloc];
 }
 
@@ -434,7 +434,7 @@ static NSString* ICEObject_all__[4] =
 -(BOOL) ice_isA:(NSString*)typeId current:(ICECurrent*)current
 {
     int count, index;
-    NSString*const* staticIds = [[self class] staticIds__:&count idIndex:&index];
+    NSString*const* staticIds = [[self class] iceStaticIds:&count idIndex:&index];
     return ICEInternalLookupString(staticIds, count, typeId) >= 0;
 }
 
@@ -451,7 +451,7 @@ static NSString* ICEObject_all__[4] =
 -(NSArray*) ice_ids:(ICECurrent*)current
 {
     int count, index;
-    NSString*const* staticIds = [[self class] staticIds__:&count idIndex:&index];
+    NSString*const* staticIds = [[self class] iceStaticIds:&count idIndex:&index];
     return [NSArray arrayWithObjects:staticIds count:count];
 }
 
@@ -460,18 +460,18 @@ static NSString* ICEObject_all__[4] =
     [(ICERequest*)request callDispatch:self];
 }
 
-+(void) ice_isA___:(id)servant current:(ICECurrent*)current is:(id<ICEInputStream>)is os:(id<ICEOutputStream>)os
++(void) iceD_ice_isA:(id)servant current:(ICECurrent*)current is:(id<ICEInputStream>)is os:(id<ICEOutputStream>)os
 {
     ICEEncodingVersion* encoding = [is startEncapsulation];
-    NSString* id__ = [is readString];
+    NSString* ident = [is readString];
     [is endEncapsulation];
     [os startEncapsulation:encoding format:ICEDefaultFormat];
-    BOOL ret__ = [servant ice_isA:id__ current:current];
-    [os writeBool:ret__];
+    BOOL ret = [servant ice_isA:ident current:current];
+    [os writeBool:ret];
     [os endEncapsulation];
 }
 
-+(void) ice_ping___:(id)servant current:(ICECurrent*)current is:(id<ICEInputStream>)is os:(id<ICEOutputStream>)os
++(void) iceD_ice_ping:(id)servant current:(ICECurrent*)current is:(id<ICEInputStream>)is os:(id<ICEOutputStream>)os
 {
     ICEEncodingVersion* encoding = [is startEncapsulation];
     [is endEncapsulation];
@@ -480,85 +480,85 @@ static NSString* ICEObject_all__[4] =
     [os endEncapsulation];
 }
 
-+(void) ice_id___:(id)servant current:(ICECurrent*)current is:(id<ICEInputStream>)is os:(id<ICEOutputStream>)os
++(void) iceD_ice_id:(id)servant current:(ICECurrent*)current is:(id<ICEInputStream>)is os:(id<ICEOutputStream>)os
 {
     ICEEncodingVersion* encoding = [is startEncapsulation];
     [is endEncapsulation];
     [os startEncapsulation:encoding format:ICEDefaultFormat];
-    NSString* ret__ = [servant ice_id:current];
-    [os writeString:ret__];
+    NSString* ret = [servant ice_id:current];
+    [os writeString:ret];
     [os endEncapsulation];
 }
 
-+(void) ice_ids___:(id)servant current:(ICECurrent*)current is:(id<ICEInputStream>)is os:(id<ICEOutputStream>)os
++(void) iceD_ice_ids:(id)servant current:(ICECurrent*)current is:(id<ICEInputStream>)is os:(id<ICEOutputStream>)os
 {
     ICEEncodingVersion* encoding = [is startEncapsulation];
     [is endEncapsulation];
     [os startEncapsulation:encoding format:ICEDefaultFormat];
-    NSArray* ret__ = [servant ice_ids:current];
-    [os writeStringSeq:ret__];
+    NSArray* ret = [servant ice_ids:current];
+    [os writeStringSeq:ret];
     [os endEncapsulation];
 }
 
--(void) dispatch__:(ICECurrent*)current is:(id<ICEInputStream>)is os:(id<ICEOutputStream>)os
+-(void) iceDispatch:(ICECurrent*)current is:(id<ICEInputStream>)is os:(id<ICEOutputStream>)os
 {
-    switch(ICEInternalLookupString(ICEObject_all__, sizeof(ICEObject_all__) / sizeof(NSString*), current.operation))
+    switch(ICEInternalLookupString(ICEObject_all, sizeof(ICEObject_all) / sizeof(NSString*), current.operation))
     {
     case 0:
-        [ICEServant ice_id___:self current:current is:is os:os];
+        [ICEServant iceD_ice_id:self current:current is:is os:os];
         return;
     case 1:
-        [ICEServant ice_ids___:self current:current is:is os:os];
+        [ICEServant iceD_ice_ids:self current:current is:is os:os];
         return;
     case 2:
-        [ICEServant ice_isA___:self current:current is:is os:os];
+        [ICEServant iceD_ice_isA:self current:current is:is os:os];
         return;
     case 3:
-        [ICEServant ice_ping___:self current:current is:is os:os];
+        [ICEServant iceD_ice_ping:self current:current is:is os:os];
         return;
     default:
         @throw [ICEOperationNotExistException requestFailedException:__FILE__
-                                              line:__LINE__
-                                              id:current.id_
-                                              facet:current.facet
-                                              operation:current.operation];
+                                                                line:__LINE__
+                                                                  id:current.id_
+                                                               facet:current.facet
+                                                           operation:current.operation];
     }
 }
 
--(void) write__:(id<ICEOutputStream>)os
+-(void) iceWrite:(id<ICEOutputStream>)os
 {
     [os startValue:nil];
-    [self writeImpl__:os];
+    [self iceWriteImpl:os];
     [os endValue];
 }
 
--(void) read__:(id<ICEInputStream>)is
+-(void) iceRead:(id<ICEInputStream>)is
 {
     [is startValue];
-    [self readImpl__:is];
+    [self iceReadImpl:is];
     [is endValue:NO];
 }
 
--(void) writeImpl__:(id<ICEOutputStream>)os
+-(void) iceWriteImpl:(id<ICEOutputStream>)os
 {
-    NSAssert(NO, @"writeImpl__ requires override");
+    NSAssert(NO, @"iceWriteImpl requires override");
 }
 
--(void) readImpl__:(id<ICEInputStream>)is
+-(void) iceReadImpl:(id<ICEInputStream>)is
 {
-    NSAssert(NO, @"readImpl__ requires override");
+    NSAssert(NO, @"iceReadImpl requires override");
 }
 
--(id)target__
+-(id)iceTarget
 {
-    return (delegate__ == 0) ? self : delegate__;
+    return (iceDelegate_ == 0) ? self : iceDelegate_;
 }
 
--(Ice::Object*) object__
+-(Ice::Object*) iceObject
 {
     @synchronized([self class])
     {
-        if(object__ == 0)
+        if(iceObject_ == 0)
         {
             //
             // NOTE: IceObjC::ObjectI implements it own reference counting and there's no need
@@ -568,19 +568,19 @@ static NSString* ICEObject_all__[4] =
             // reference to the object (without this, servants added to the object adapter
             // couldn't be retained or released easily).
             //
-            object__ = static_cast<IceObjC::ServantWrapper*>(new ObjectI(self));
+            iceObject_ = static_cast<IceObjC::ServantWrapper*>(new ObjectI(self));
         }
     }
-    return static_cast<IceObjC::ServantWrapper*>(object__);
+    return static_cast<IceObjC::ServantWrapper*>(iceObject_);
 }
 @end
 
 @implementation ICEBlobject
--(Ice::Object*) object__
+-(Ice::Object*) iceObject
 {
     @synchronized([self class])
     {
-        if(object__ == 0)
+        if(iceObject_ == 0)
         {
             //
             // NOTE: IceObjC::ObjectI implements it own reference counting and there's no need
@@ -590,10 +590,10 @@ static NSString* ICEObject_all__[4] =
             // reference to the object (without this, servants added to the object adapter
             // couldn't be retained or released easily).
             //
-            object__ = static_cast<IceObjC::ServantWrapper*>(new BlobjectI(self));
+            iceObject_ = static_cast<IceObjC::ServantWrapper*>(new BlobjectI(self));
         }
     }
-    return static_cast<IceObjC::ServantWrapper*>(object__);
+    return static_cast<IceObjC::ServantWrapper*>(iceObject_);
 }
 @end
 
@@ -606,16 +606,16 @@ static NSString* ICEObject_all__[4] =
         return nil;
     }
 
-    object__ = arg;
-    object__->__incRef();
-    assert(cachedObjects.find(object__) == cachedObjects.end());
-    cachedObjects.insert(std::make_pair(object__, self));
+    object_ = arg;
+    object_->__incRef();
+    assert(cachedObjects.find(object_) == cachedObjects.end());
+    cachedObjects.insert(std::make_pair(object_, self));
     return self;
 }
 -(void) dealloc
 {
-    cachedObjects.erase(object__);
-    object__->__decRef();
+    cachedObjects.erase(object_);
+    object_->__decRef();
     [super dealloc];
 }
 +(id) servantWrapperWithCxxObject:(Ice::Object*)arg
@@ -653,7 +653,7 @@ static NSString* ICEObject_all__[4] =
     NSException* nsex = nil;
     try
     {
-        return object__->ice_isA(fromNSString(typeId), Ice::Current());
+        return object_->ice_isA(fromNSString(typeId), Ice::Current());
     }
     catch(const std::exception& ex)
     {
@@ -666,7 +666,7 @@ static NSString* ICEObject_all__[4] =
     NSException* nsex = nil;
     try
     {
-        return object__->ice_ping(Ice::Current());
+        return object_->ice_ping(Ice::Current());
     }
     catch(const std::exception& ex)
     {
@@ -679,7 +679,7 @@ static NSString* ICEObject_all__[4] =
     NSException* nsex = nil;
     try
     {
-        return toNSString(object__->ice_id(Ice::Current()));
+        return toNSString(object_->ice_id(Ice::Current()));
     }
     catch(const std::exception& ex)
     {
@@ -692,7 +692,7 @@ static NSString* ICEObject_all__[4] =
     NSException* nsex = nil;
     try
     {
-        return toNSArray(object__->ice_ids(Ice::Current()));
+        return toNSArray(object_->ice_ids(Ice::Current()));
     }
     catch(const std::exception& ex)
     {
@@ -704,12 +704,12 @@ static NSString* ICEObject_all__[4] =
 {
     @throw [ICEFeatureNotSupportedException featureNotSupportedException:__FILE__ line:__LINE__];
 }
--(void) write__:(id<ICEOutputStream>)os
+-(void) iceWrite:(id<ICEOutputStream>)os
 {
     NSException* nsex = nil;
     try
     {
-        object__->_iceWrite([(ICEOutputStream*)os os]);
+        object_->_iceWrite([(ICEOutputStream*)os os]);
     }
     catch(const std::exception& ex)
     {
@@ -717,12 +717,12 @@ static NSString* ICEObject_all__[4] =
     }
     @throw nsex;
 }
--(void) read__:(id<ICEInputStream>)is
+-(void) iceRead:(id<ICEInputStream>)is
 {
     NSException* nsex = nil;
     try
     {
-        object__->_iceRead([(ICEInputStream*)is is]);
+        object_->_iceRead([(ICEInputStream*)is is]);
     }
     catch(const std::exception& ex)
     {
@@ -730,8 +730,8 @@ static NSString* ICEObject_all__[4] =
     }
     @throw nsex;
 }
--(Ice::Object*) object__
+-(Ice::Object*) iceObject
 {
-    return object__;
+    return object_;
 }
 @end
diff --git a/objective-c/src/Ice/ObjectAdapterI.mm b/objective-c/src/Ice/ObjectAdapterI.mm
index af28d9d24f1..c88ca834326 100644
--- a/objective-c/src/Ice/ObjectAdapterI.mm
+++ b/objective-c/src/Ice/ObjectAdapterI.mm
@@ -105,7 +105,7 @@ public:
     _write(Ice::OutputStream* s) const
     {
         ICEOutputStream* os = [[ICEOutputStream alloc] initWithCxxStream:s];
-        [_ex write__:os];
+        [_ex iceWrite:os];
         [os release];
     }
 
@@ -118,7 +118,7 @@ public:
     bool
     _usesClasses() const
     {
-        return [_ex usesClasses__];
+        return [_ex iceUsesClasses];
     }
 
     std::string
@@ -179,7 +179,7 @@ public:
                 {
                     cookie = new Cookie(co);
                 }
-                return [servant object__];
+                return [servant iceObject];
             }
             @catch(id e)
             {
@@ -434,7 +434,7 @@ typedef IceUtil::Handle<ServantLocatorWrapper> ServantLocatorWrapperPtr;
     NSException* nsex = nil;
     try
     {
-        return [ICEObjectPrx objectPrxWithObjectPrx__:OBJECTADAPTER->add([servant object__], [ident identity])];
+        return [ICEObjectPrx iceObjectPrxWithObjectPrx:OBJECTADAPTER->add([servant iceObject], [ident identity])];
     }
     catch(const std::exception& ex)
     {
@@ -449,7 +449,7 @@ typedef IceUtil::Handle<ServantLocatorWrapper> ServantLocatorWrapperPtr;
     NSException* nsex = nil;
     try
     {
-        return [ICEObjectPrx objectPrxWithObjectPrx__:OBJECTADAPTER->addFacet([servant object__], [ident identity],
+        return [ICEObjectPrx iceObjectPrxWithObjectPrx:OBJECTADAPTER->addFacet([servant iceObject], [ident identity],
                                                                               fromNSString(facet))];
     }
     catch(const std::exception& ex)
@@ -465,7 +465,7 @@ typedef IceUtil::Handle<ServantLocatorWrapper> ServantLocatorWrapperPtr;
     NSException* nsex = nil;
     try
     {
-        return [ICEObjectPrx objectPrxWithObjectPrx__:OBJECTADAPTER->addWithUUID([servant object__])];
+        return [ICEObjectPrx iceObjectPrxWithObjectPrx:OBJECTADAPTER->addWithUUID([servant iceObject])];
     }
     catch(const std::exception& ex)
     {
@@ -480,7 +480,7 @@ typedef IceUtil::Handle<ServantLocatorWrapper> ServantLocatorWrapperPtr;
     NSException* nsex = nil;
     try
     {
-        return [ICEObjectPrx objectPrxWithObjectPrx__:OBJECTADAPTER->addFacetWithUUID([servant object__],
+        return [ICEObjectPrx iceObjectPrxWithObjectPrx:OBJECTADAPTER->addFacetWithUUID([servant iceObject],
                                                                                       fromNSString(facet))];
     }
     catch(const std::exception& ex)
@@ -496,7 +496,7 @@ typedef IceUtil::Handle<ServantLocatorWrapper> ServantLocatorWrapperPtr;
     NSException* nsex = nil;
     try
     {
-        Ice::ServantLocatorPtr servantLocator = new DefaultServantLocator([servant object__]);
+        Ice::ServantLocatorPtr servantLocator = new DefaultServantLocator([servant iceObject]);
         OBJECTADAPTER->addServantLocator(servantLocator, fromNSString(category));
     }
     catch(const std::exception& ex)
@@ -628,7 +628,7 @@ typedef IceUtil::Handle<ServantLocatorWrapper> ServantLocatorWrapperPtr;
     NSException* nsex = nil;
     try
     {
-        return toObjC(OBJECTADAPTER->findByProxy([(ICEObjectPrx*)proxy objectPrx__]));
+        return toObjC(OBJECTADAPTER->findByProxy([(ICEObjectPrx*)proxy iceObjectPrx]));
     }
     catch(const std::exception& ex)
     {
@@ -714,7 +714,7 @@ typedef IceUtil::Handle<ServantLocatorWrapper> ServantLocatorWrapperPtr;
     NSException* nsex = nil;
     try
     {
-        return [ICEObjectPrx objectPrxWithObjectPrx__:OBJECTADAPTER->createProxy([ident identity])];
+        return [ICEObjectPrx iceObjectPrxWithObjectPrx:OBJECTADAPTER->createProxy([ident identity])];
     }
     catch(const std::exception& ex)
     {
@@ -729,7 +729,7 @@ typedef IceUtil::Handle<ServantLocatorWrapper> ServantLocatorWrapperPtr;
     NSException* nsex = nil;
     try
     {
-        return [ICEObjectPrx objectPrxWithObjectPrx__:OBJECTADAPTER->createDirectProxy([ident identity])];
+        return [ICEObjectPrx iceObjectPrxWithObjectPrx:OBJECTADAPTER->createDirectProxy([ident identity])];
     }
     catch(const std::exception& ex)
     {
@@ -744,7 +744,7 @@ typedef IceUtil::Handle<ServantLocatorWrapper> ServantLocatorWrapperPtr;
     NSException* nsex = nil;
     try
     {
-        return [ICEObjectPrx objectPrxWithObjectPrx__:OBJECTADAPTER->createIndirectProxy([ident identity])];
+        return [ICEObjectPrx iceObjectPrxWithObjectPrx:OBJECTADAPTER->createIndirectProxy([ident identity])];
     }
     catch(const std::exception& ex)
     {
@@ -759,7 +759,7 @@ typedef IceUtil::Handle<ServantLocatorWrapper> ServantLocatorWrapperPtr;
     NSException* nsex = nil;
     try
     {
-        OBJECTADAPTER->setLocator(Ice::LocatorPrx::uncheckedCast(Ice::ObjectPrx([(ICEObjectPrx*)loc objectPrx__])));
+        OBJECTADAPTER->setLocator(Ice::LocatorPrx::uncheckedCast(Ice::ObjectPrx([(ICEObjectPrx*)loc iceObjectPrx])));
     }
     catch(const std::exception& ex)
     {
@@ -776,7 +776,7 @@ typedef IceUtil::Handle<ServantLocatorWrapper> ServantLocatorWrapperPtr;
     NSException* nsex = nil;
     try
     {
-        return (id<ICELocatorPrx>)[ICELocatorPrx objectPrxWithObjectPrx__:OBJECTADAPTER->getLocator()];
+        return (id<ICELocatorPrx>)[ICELocatorPrx iceObjectPrxWithObjectPrx:OBJECTADAPTER->getLocator()];
     }
     catch(const std::exception& ex)
     {
diff --git a/objective-c/src/Ice/ObjectI.h b/objective-c/src/Ice/ObjectI.h
index d21ad12e6c9..13fbd9ab717 100644
--- a/objective-c/src/Ice/ObjectI.h
+++ b/objective-c/src/Ice/ObjectI.h
@@ -33,12 +33,12 @@ typedef IceUtil::Handle<ServantWrapper> ServantWrapperPtr;
 };
 
 @interface ICEObject (ICEInternal)
--(Ice::Object*) object__;
+-(Ice::Object*) iceObject;
 @end
 
 @interface ICEServantWrapper : ICEObject
 {
-    Ice::Object* object__;
+    Ice::Object* object_;
 }
 +(id) servantWrapperWithCxxObject:(Ice::Object*)arg;
 @end
diff --git a/objective-c/src/Ice/PropertiesI.mm b/objective-c/src/Ice/PropertiesI.mm
index 9d2b119abcf..56d5a515e45 100644
--- a/objective-c/src/Ice/PropertiesI.mm
+++ b/objective-c/src/Ice/PropertiesI.mm
@@ -282,14 +282,14 @@ typedef IceUtil::Handle<UpdateCallbackI> UpdateCallbackIPtr;
 @implementation ICEPropertiesAdminUpdateCallback
 @end
 
-#define NATIVEPROPERTIESADMIN dynamic_cast<Ice::NativePropertiesAdmin*>(object__)
+#define NATIVEPROPERTIESADMIN dynamic_cast<Ice::NativePropertiesAdmin*>(object_)
 
 @implementation ICENativePropertiesAdmin
 -(void) addUpdateCallback:(id<ICEPropertiesAdminUpdateCallback>)cb
 {
     IceUtil::Mutex::Lock sync(mutex_);
     callbacks_.push_back(new UpdateCallbackI(cb));
-    assert(Ice::NativePropertiesAdminPtr::dynamicCast(object__));
+    assert(Ice::NativePropertiesAdminPtr::dynamicCast(object_));
     NATIVEPROPERTIESADMIN->addUpdateCallback(callbacks_.back());
 }
 
diff --git a/objective-c/src/Ice/Proxy.mm b/objective-c/src/Ice/Proxy.mm
index 9e78224b7eb..5e718477e5a 100644
--- a/objective-c/src/Ice/Proxy.mm
+++ b/objective-c/src/Ice/Proxy.mm
@@ -35,8 +35,8 @@
 
 #include <Block.h>
 
-#define OBJECTPRX ((IceProxy::Ice::Object*)objectPrx__)
-#define ASYNCRESULT ((Ice::AsyncResult*)asyncResult__)
+#define OBJECTPRX ((IceProxy::Ice::Object*)objectPrx_)
+#define ASYNCRESULT ((Ice::AsyncResult*)asyncResult_)
 
 namespace
 {
@@ -185,7 +185,7 @@ BOOL _returnsData;
 };
 
 @implementation ICEAsyncResult
--(ICEAsyncResult*) initWithAsyncResult__:(const Ice::AsyncResultPtr&)arg
+-(ICEAsyncResult*) initWithAsyncResult:(const Ice::AsyncResultPtr&)arg
                                operation:(NSString*)op
                                    proxy:(id<ICEObjectPrx>)p;
 {
@@ -195,14 +195,14 @@ BOOL _returnsData;
         return nil;
     }
 
-    asyncResult__ = arg.get();
+    asyncResult_ = arg.get();
     ASYNCRESULT->__incRef();
     operation_ = [op retain];
     proxy_ = [p retain];
     return self;
 }
 
--(Ice::AsyncResult*) asyncResult__
+-(Ice::AsyncResult*) asyncResult
 {
     return ASYNCRESULT;
 }
@@ -210,17 +210,17 @@ BOOL _returnsData;
 -(void) dealloc
 {
     ASYNCRESULT->__decRef();
-    asyncResult__ = 0;
+    asyncResult_ = 0;
     [operation_ release];
     [proxy_ release];
     [super dealloc];
 }
 
-+(ICEAsyncResult*) asyncResultWithAsyncResult__:(const Ice::AsyncResultPtr&)arg
++(ICEAsyncResult*) asyncResultWithAsyncResult:(const Ice::AsyncResultPtr&)arg
 {
-    return [self asyncResultWithAsyncResult__:arg operation:nil proxy:nil];
+    return [self asyncResultWithAsyncResult:arg operation:nil proxy:nil];
 }
-+(ICEAsyncResult*) asyncResultWithAsyncResult__:(const Ice::AsyncResultPtr&)arg
++(ICEAsyncResult*) asyncResultWithAsyncResult:(const Ice::AsyncResultPtr&)arg
                                       operation:(NSString*)op
                                           proxy:(id<ICEObjectPrx>)p
 {
@@ -230,7 +230,7 @@ BOOL _returnsData;
     }
     else
     {
-        return [[[self alloc] initWithAsyncResult__:arg operation:op proxy:p] autorelease];
+        return [[[self alloc] initWithAsyncResult:arg operation:op proxy:p] autorelease];
     }
 }
 -(NSString*) operation
@@ -313,33 +313,33 @@ BOOL _returnsData;
 
 @implementation ICEObjectPrx
 
--(ICEObjectPrx*) initWithObjectPrx__:(const Ice::ObjectPrx&)arg
+-(ICEObjectPrx*) iceInitWithObjectPrx:(const Ice::ObjectPrx&)arg
 {
     self = [super init];
     if(!self)
     {
         return nil;
     }
-    communicator__ = [ICECommunicator localObjectWithCxxObjectNoAutoRelease:arg->ice_getCommunicator().get()];
-    objectPrx__ = arg.get();
+    communicator_ = [ICECommunicator localObjectWithCxxObjectNoAutoRelease:arg->ice_getCommunicator().get()];
+    objectPrx_ = arg.get();
     OBJECTPRX->__incRef();
     return self;
 }
 
--(IceProxy::Ice::Object*) objectPrx__
+-(IceProxy::Ice::Object*) iceObjectPrx
 {
-    return (IceProxy::Ice::Object*)objectPrx__;
+    return (IceProxy::Ice::Object*)objectPrx_;
 }
 
 -(void) dealloc
 {
     OBJECTPRX->__decRef();
-    objectPrx__ = 0;
-    [communicator__ release];
+    objectPrx_ = 0;
+    [communicator_ release];
     [super dealloc];
 }
 
-+(ICEObjectPrx*) objectPrxWithObjectPrx__:(const Ice::ObjectPrx&)arg
++(ICEObjectPrx*) iceObjectPrxWithObjectPrx:(const Ice::ObjectPrx&)arg
 {
     if(!arg)
     {
@@ -347,7 +347,7 @@ BOOL _returnsData;
     }
     else
     {
-        return [[[self alloc] initWithObjectPrx__:arg] autorelease];
+        return [[[self alloc] iceInitWithObjectPrx:arg] autorelease];
     }
 }
 
@@ -361,7 +361,7 @@ BOOL _returnsData;
         }
         else
         {
-            return [[[self alloc] initWithObjectPrx__:[(ICEObjectPrx*)proxy objectPrx__]] autorelease];
+            return [[[self alloc] iceInitWithObjectPrx:[(ICEObjectPrx*)proxy iceObjectPrx]] autorelease];
         }
     }
     return nil;
@@ -378,10 +378,10 @@ BOOL _returnsData;
         {
             return [[proxy retain] autorelease];
         }
-        else if([(ICEObjectPrx*)proxy conformsToProtocol:[self protocol__]] ||
+        else if([(ICEObjectPrx*)proxy conformsToProtocol:[self iceProtocol]] ||
                 [proxy ice_isA:[self ice_staticId]])
         {
-            return [[[self alloc] initWithObjectPrx__:[(ICEObjectPrx*)proxy objectPrx__]] autorelease];
+            return [[[self alloc] iceInitWithObjectPrx:[(ICEObjectPrx*)proxy iceObjectPrx]] autorelease];
         }
     }
     return nil;
@@ -405,10 +405,10 @@ BOOL _returnsData;
         {
             return [[proxy retain] autorelease];
         }
-        else if([(ICEObjectPrx*)proxy conformsToProtocol:[self protocol__]] ||
+        else if([(ICEObjectPrx*)proxy conformsToProtocol:[self iceProtocol]] ||
                 [proxy ice_isA:[self ice_staticId] context:context])
         {
-            return [[[self alloc] initWithObjectPrx__:[(ICEObjectPrx*)proxy objectPrx__]] autorelease];
+            return [[[self alloc] iceInitWithObjectPrx:[(ICEObjectPrx*)proxy iceObjectPrx]] autorelease];
         }
     }
     return nil;
@@ -429,12 +429,12 @@ BOOL _returnsData;
     return @"::Ice::Object";
 }
 
-+(Protocol*) protocol__
++(Protocol*) iceProtocol
 {
     return objc_getProtocol(class_getName([self class]));
 }
 
--(id<ICEOutputStream>) createOutputStream__
+-(id<ICEOutputStream>) iceCreateOutputStream
 {
     NSException* nsex = nil;
     try
@@ -448,7 +448,7 @@ BOOL _returnsData;
     @throw nsex;
     return nil; // Keep the compiler happy.
 }
--(void) checkAsyncTwowayOnly__:(NSString*)operation
+-(void) iceCheckAsyncTwowayOnly:(NSString*)operation
 {
     //
     // No mutex lock necessary, there is nothing mutable in this
@@ -463,7 +463,7 @@ BOOL _returnsData;
     }
 }
 
--(void) invoke__:(NSString*)operation
+-(void) iceInvoke:(NSString*)operation
             mode:(ICEOperationMode)mode
           format:(ICEFormatType)format
          marshal:(ICEMarshalCB)marshal
@@ -478,7 +478,7 @@ BOOL _returnsData;
     ICEOutputStream<ICEOutputStream>* os = nil;
     if(marshal)
     {
-        os = [self createOutputStream__];
+        os = [self iceCreateOutputStream];
         try
         {
             [os os]->startEncapsulation(IceInternal::getCompatibleEncoding(OBJECTPRX->ice_getEncodingVersion()),
@@ -579,7 +579,7 @@ BOOL _returnsData;
     NSAssert(os == nil, @"output stream not cleared");
 }
 
--(id<ICEAsyncResult>) begin_invoke__:(NSString*)operation
+-(id<ICEAsyncResult>) iceI_begin_invoke:(NSString*)operation
                                 mode:(ICEOperationMode)mode
                               format:(ICEFormatType)format
                              marshal:(void(^)(id<ICEOutputStream>))marshal
@@ -588,13 +588,13 @@ BOOL _returnsData;
 {
     if(returnsData)
     {
-        [self checkAsyncTwowayOnly__:operation];
+        [self iceCheckAsyncTwowayOnly:operation];
     }
 
     ICEOutputStream<ICEOutputStream>* os = nil;
     if(marshal)
     {
-        os = [self createOutputStream__];
+        os = [self iceCreateOutputStream];
         try
         {
             [os os]->startEncapsulation(IceInternal::getCompatibleEncoding(OBJECTPRX->ice_getEncodingVersion()),
@@ -640,7 +640,7 @@ BOOL _returnsData;
         {
             r = OBJECTPRX->begin_ice_invoke(fromNSString(operation), (Ice::OperationMode)mode, inParams);
         }
-        return [ICEAsyncResult asyncResultWithAsyncResult__:r operation:operation proxy:self];
+        return [ICEAsyncResult asyncResultWithAsyncResult:r operation:operation proxy:self];
     }
     catch(const std::exception& ex)
     {
@@ -658,7 +658,7 @@ BOOL _returnsData;
     return nil; // Keep the compiler happy.
 }
 
--(id<ICEAsyncResult>) begin_invoke__:(NSString*)operation
+-(id<ICEAsyncResult>) iceI_begin_invoke:(NSString*)operation
                                 mode:(ICEOperationMode)mode
                               format:(ICEFormatType)format
                              marshal:(void(^)(id<ICEOutputStream>))marshal
@@ -671,7 +671,7 @@ BOOL _returnsData;
 {
     if(returnsData)
     {
-        [self checkAsyncTwowayOnly__:operation];
+        [self iceCheckAsyncTwowayOnly:operation];
         if(!response)
         {
             @throw [NSException exceptionWithName:NSInvalidArgumentException
@@ -690,7 +690,7 @@ BOOL _returnsData;
     ICEOutputStream<ICEOutputStream>* os = nil;
     if(marshal)
     {
-        os = [self createOutputStream__];
+        os = [self iceCreateOutputStream];
         try
         {
             [os os]->startEncapsulation(IceInternal::getCompatibleEncoding(OBJECTPRX->ice_getEncodingVersion()),
@@ -742,7 +742,7 @@ BOOL _returnsData;
         {
             r = OBJECTPRX->begin_ice_invoke(fromNSString(operation), (Ice::OperationMode)mode, inParams, cb);
         }
-        return [ICEAsyncResult asyncResultWithAsyncResult__:r operation:operation proxy:self];
+        return [ICEAsyncResult asyncResultWithAsyncResult:r operation:operation proxy:self];
     }
     catch(const std::exception& ex)
     {
@@ -759,7 +759,7 @@ BOOL _returnsData;
     }
     return nil; // Keep the compiler happy.
 }
--(id<ICEAsyncResult>) begin_invoke__:(NSString*)op
+-(id<ICEAsyncResult>) iceI_begin_invoke:(NSString*)op
                                 mode:(ICEOperationMode)mode
                               format:(ICEFormatType)format
                              marshal:(void(^)(id<ICEOutputStream>))marshal
@@ -774,7 +774,7 @@ BOOL _returnsData;
             response();
         }
     };
-    return [self begin_invoke__:op
+    return [self iceI_begin_invoke:op
                  mode:mode
                  format:format
                  marshal:marshal
@@ -786,7 +786,7 @@ BOOL _returnsData;
                  context:ctx];
 }
 
--(id<ICEAsyncResult>) begin_invoke__:(NSString*)op
+-(id<ICEAsyncResult>) iceI_begin_invoke:(NSString*)op
                                 mode:(ICEOperationMode)mode
                               format:(ICEFormatType)format
                              marshal:(void(^)(id<ICEOutputStream>))marshal
@@ -796,7 +796,7 @@ BOOL _returnsData;
                                 sent:(void(^)(BOOL))sent
                              context:(ICEContext*)ctx
 {
-    return [self begin_invoke__:op
+    return [self iceI_begin_invoke:op
                  mode:mode
                  format:format
                  marshal:marshal
@@ -807,7 +807,7 @@ BOOL _returnsData;
                  sent:sent context:ctx];
 }
 
--(void)end_invoke__:(NSString*)operation unmarshal:(ICEUnmarshalCB)unmarshal result:(id<ICEAsyncResult>)r
+-(void)iceI_end_invoke:(NSString*)operation unmarshal:(ICEUnmarshalCB)unmarshal result:(id<ICEAsyncResult>)r
 {
     ICEAsyncResult* result = (ICEAsyncResult*)r;
     if(operation != [result operation])
@@ -828,7 +828,7 @@ BOOL _returnsData;
     try
     {
         std::pair<const Ice::Byte*, const Ice::Byte*> outParams;
-        BOOL ok = OBJECTPRX->_iceI_end_ice_invoke(outParams, [result asyncResult__]);
+        BOOL ok = OBJECTPRX->_iceI_end_ice_invoke(outParams, [result asyncResult]);
 
         ICEInputStream* is;
         is = [[ICEInputStream alloc] initWithCxxCommunicator:OBJECTPRX->ice_getCommunicator().get() data:outParams];
@@ -899,13 +899,13 @@ BOOL _returnsData;
     {
         return NO;
     }
-    return *OBJECTPRX == *[o_ objectPrx__];
+    return *OBJECTPRX == *[o_ iceObjectPrx];
 }
 
 -(NSComparisonResult) compareIdentity:(id<ICEObjectPrx>)aProxy
 {
     IceProxy::Ice::Object* lhs = OBJECTPRX;
-    IceProxy::Ice::Object* rhs = [(ICEObjectPrx*)aProxy objectPrx__];
+    IceProxy::Ice::Object* rhs = [(ICEObjectPrx*)aProxy iceObjectPrx];
     if(Ice::proxyIdentityEqual(lhs, rhs))
     {
         return NSOrderedSame;
@@ -923,7 +923,7 @@ BOOL _returnsData;
 -(NSComparisonResult) compareIdentityAndFacet:(id<ICEObjectPrx>)aProxy
 {
     IceProxy::Ice::Object* lhs = OBJECTPRX;
-    IceProxy::Ice::Object* rhs = [(ICEObjectPrx*)aProxy objectPrx__];
+    IceProxy::Ice::Object* rhs = [(ICEObjectPrx*)aProxy iceObjectPrx];
     if(Ice::proxyIdentityAndFacetEqual(lhs, rhs))
     {
         return NSOrderedSame;
@@ -940,7 +940,7 @@ BOOL _returnsData;
 
 -(id<ICECommunicator>) ice_getCommunicator
 {
-    return [[communicator__ retain] autorelease];
+    return [[communicator_ retain] autorelease];
 }
 
 -(NSMutableString*) ice_toString
@@ -950,15 +950,15 @@ BOOL _returnsData;
 
 -(BOOL) ice_isA:(NSString*)typeId
 {
-    __block BOOL ret__;
-    cppCall(^ { ret__ = OBJECTPRX->ice_isA(fromNSString(typeId)); });
-    return ret__;
+    __block BOOL ret;
+    cppCall(^ { ret = OBJECTPRX->ice_isA(fromNSString(typeId)); });
+    return ret;
 }
 -(BOOL) ice_isA:(NSString*)typeId context:(ICEContext*)context
 {
-    __block BOOL ret__;
-    cppCall(^(const Ice::Context& ctx) { ret__ = OBJECTPRX->ice_isA(fromNSString(typeId), ctx); }, context);
-    return ret__;
+    __block BOOL ret;
+    cppCall(^(const Ice::Context& ctx) { ret = OBJECTPRX->ice_isA(fromNSString(typeId), ctx); }, context);
+    return ret;
 }
 -(id<ICEAsyncResult>) begin_ice_isA:(NSString*)typeId
 {
@@ -998,10 +998,10 @@ BOOL _returnsData;
                             result = OBJECTPRX->begin_ice_isA(fromNSString(typeId), cb);
                         },
                         ^(const Ice::AsyncResultPtr& result) {
-                            BOOL ret__ = OBJECTPRX->end_ice_isA(result);
+                            BOOL ret = OBJECTPRX->end_ice_isA(result);
                             if(response)
                             {
-                                response(ret__);
+                                response(ret);
                             }
                         },
                         exception, sent, self);
@@ -1019,19 +1019,19 @@ BOOL _returnsData;
                         },
                         context,
                         ^(const Ice::AsyncResultPtr& result) {
-                            BOOL ret__ = OBJECTPRX->end_ice_isA(result);
+                            BOOL ret = OBJECTPRX->end_ice_isA(result);
                             if(response)
                             {
-                                response(ret__);
+                                response(ret);
                             }
                         },
                         exception, sent, self);
 }
 -(BOOL) end_ice_isA:(id<ICEAsyncResult>)result
 {
-    __block BOOL ret__;
-    endCppCall(^(const Ice::AsyncResultPtr& r) { ret__ = OBJECTPRX->end_ice_isA(r); }, result);
-    return ret__;
+    __block BOOL ret;
+    endCppCall(^(const Ice::AsyncResultPtr& r) { ret = OBJECTPRX->end_ice_isA(r); }, result);
+    return ret;
 }
 
 -(void) ice_ping
@@ -1109,15 +1109,15 @@ BOOL _returnsData;
 
 -(NSMutableArray*) ice_ids
 {
-    __block NSMutableArray* ret__;
-    cppCall(^ { ret__ = [toNSArray(OBJECTPRX->ice_ids()) autorelease]; });
-    return ret__;
+    __block NSMutableArray* ret;
+    cppCall(^ { ret = [toNSArray(OBJECTPRX->ice_ids()) autorelease]; });
+    return ret;
 }
 -(NSMutableArray*) ice_ids:(ICEContext*)context
 {
-    __block NSMutableArray* ret__;
-    cppCall(^(const Ice::Context& ctx) { ret__ = [toNSArray(OBJECTPRX->ice_ids(ctx)) autorelease]; }, context);
-    return ret__;
+    __block NSMutableArray* ret;
+    cppCall(^(const Ice::Context& ctx) { ret = [toNSArray(OBJECTPRX->ice_ids(ctx)) autorelease]; }, context);
+    return ret;
 }
 -(id<ICEAsyncResult>) begin_ice_ids
 {
@@ -1150,10 +1150,10 @@ BOOL _returnsData;
                             result = OBJECTPRX->begin_ice_ids(cb);
                         },
                         ^(const Ice::AsyncResultPtr& result) {
-                            NSMutableArray* ret__ = [toNSArray(OBJECTPRX->end_ice_ids(result)) autorelease];
+                            NSMutableArray* ret = [toNSArray(OBJECTPRX->end_ice_ids(result)) autorelease];
                             if(response)
                             {
-                                response(ret__);
+                                response(ret);
                             }
                         },
                         exception, sent, self);
@@ -1169,32 +1169,32 @@ BOOL _returnsData;
                         },
                         context,
                         ^(const Ice::AsyncResultPtr& result) {
-                            NSMutableArray* ret__ = [toNSArray(OBJECTPRX->end_ice_ids(result)) autorelease];
+                            NSMutableArray* ret = [toNSArray(OBJECTPRX->end_ice_ids(result)) autorelease];
                             if(response)
                             {
-                                response(ret__);
+                                response(ret);
                             }
                         },
                         exception, sent, self);
 }
 -(NSMutableArray*) end_ice_ids:(id<ICEAsyncResult>)result
 {
-    __block NSMutableArray* ret__;
-    endCppCall(^(const Ice::AsyncResultPtr& r) { ret__ = [toNSArray(OBJECTPRX->end_ice_ids(r)) autorelease]; }, result);
-    return ret__;
+    __block NSMutableArray* ret;
+    endCppCall(^(const Ice::AsyncResultPtr& r) { ret = [toNSArray(OBJECTPRX->end_ice_ids(r)) autorelease]; }, result);
+    return ret;
 }
 
 -(NSMutableString*) ice_id
 {
-    __block NSMutableString* ret__;
-    cppCall(^ { ret__ = [toNSMutableString(OBJECTPRX->ice_id()) autorelease]; });
-    return ret__;
+    __block NSMutableString* ret;
+    cppCall(^ { ret = [toNSMutableString(OBJECTPRX->ice_id()) autorelease]; });
+    return ret;
 }
 -(NSMutableString*) ice_id:(ICEContext*)context
 {
-    __block NSMutableString* ret__;
-    cppCall(^(const Ice::Context& ctx) { ret__ = [toNSMutableString(OBJECTPRX->ice_id(ctx)) autorelease]; }, context);
-    return ret__;
+    __block NSMutableString* ret;
+    cppCall(^(const Ice::Context& ctx) { ret = [toNSMutableString(OBJECTPRX->ice_id(ctx)) autorelease]; }, context);
+    return ret;
 }
 -(id<ICEAsyncResult>) begin_ice_id
 {
@@ -1227,10 +1227,10 @@ BOOL _returnsData;
                             result = OBJECTPRX->begin_ice_id(cb);
                         },
                         ^(const Ice::AsyncResultPtr& result) {
-                            NSString* ret__ = [toNSString(OBJECTPRX->end_ice_id(result)) autorelease];
+                            NSString* ret = [toNSString(OBJECTPRX->end_ice_id(result)) autorelease];
                             if(response)
                             {
-                                response(ret__);
+                                response(ret);
                             }
                         },
                         exception, sent, self);
@@ -1246,20 +1246,20 @@ BOOL _returnsData;
                         },
                         context,
                         ^(const Ice::AsyncResultPtr& result) {
-                            NSString* ret__ = [toNSString(OBJECTPRX->end_ice_id(result)) autorelease];
+                            NSString* ret = [toNSString(OBJECTPRX->end_ice_id(result)) autorelease];
                             if(response)
                             {
-                                response(ret__);
+                                response(ret);
                             }
                         },
                         exception, sent, self);
 }
 -(NSMutableString*) end_ice_id:(id<ICEAsyncResult>)result
 {
-    __block NSMutableString* ret__;
-    endCppCall(^(const Ice::AsyncResultPtr& r) { ret__ = [toNSMutableString(OBJECTPRX->end_ice_id(r)) autorelease]; },
+    __block NSMutableString* ret;
+    endCppCall(^(const Ice::AsyncResultPtr& r) { ret = [toNSMutableString(OBJECTPRX->end_ice_id(r)) autorelease]; },
                result);
-    return ret__;
+    return ret;
 }
 
 -(BOOL) ice_invoke:(NSString*)operation
@@ -1342,12 +1342,12 @@ BOOL _returnsData;
                         },
                         ^(const Ice::AsyncResultPtr& result) {
                             std::pair<const ::Ice::Byte*, const ::Ice::Byte*> outP;
-                            BOOL ret__ = OBJECTPRX->_iceI_end_ice_invoke(outP, result);
+                            BOOL ret = OBJECTPRX->_iceI_end_ice_invoke(outP, result);
                             if(response)
                             {
                                 NSMutableData* outEncaps =
                                     [NSMutableData dataWithBytes:outP.first length:(outP.second - outP.first)];
-                                response(ret__, outEncaps);
+                                response(ret, outEncaps);
                             }
                         },
                         exception, sent, self);
@@ -1373,12 +1373,12 @@ BOOL _returnsData;
                         context,
                         ^(const Ice::AsyncResultPtr& result) {
                             std::pair<const ::Ice::Byte*, const ::Ice::Byte*> outP;
-                            BOOL ret__ = OBJECTPRX->_iceI_end_ice_invoke(outP, result);
+                            BOOL ret = OBJECTPRX->_iceI_end_ice_invoke(outP, result);
                             if(response)
                             {
                                 NSMutableData* outEncaps =
                                     [NSMutableData dataWithBytes:outP.first length:(outP.second - outP.first)];
-                                response(ret__, outEncaps);
+                                response(ret, outEncaps);
                             }
                         },
                         exception, sent, self);
@@ -1386,14 +1386,14 @@ BOOL _returnsData;
 -(BOOL) end_ice_invoke:(NSMutableData**)outEncaps result:(id<ICEAsyncResult>)result
 
 {
-    __block BOOL ret__;
+    __block BOOL ret;
     endCppCall(^(const Ice::AsyncResultPtr& r)
                {
                    std::pair<const ::Ice::Byte*, const ::Ice::Byte*> outP;
-                   ret__ = OBJECTPRX->_iceI_end_ice_invoke(outP, r);
+                   ret = OBJECTPRX->_iceI_end_ice_invoke(outP, r);
                    *outEncaps = [NSMutableData dataWithBytes:outP.first length:(outP.second - outP.first)];
                }, result);
-    return ret__;
+    return ret;
 }
 
 -(ICEIdentity*) ice_getIdentity
@@ -1402,7 +1402,7 @@ BOOL _returnsData;
 }
 -(id) ice_identity:(ICEIdentity*)identity
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_identity([identity identity])];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_identity([identity identity])];
 }
 -(ICEMutableContext*) ice_getContext
 {
@@ -1411,7 +1411,7 @@ BOOL _returnsData;
 -(id) ice_context:(ICEContext*)context
 {
     Ice::Context ctx;
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_context(fromNSDictionary(context, ctx))];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_context(fromNSDictionary(context, ctx))];
 }
 -(NSMutableString*) ice_getFacet
 {
@@ -1419,7 +1419,7 @@ BOOL _returnsData;
 }
 -(id) ice_facet:(NSString*)facet
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_facet(fromNSString(facet))];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_facet(fromNSString(facet))];
 }
 -(NSMutableString*) ice_getAdapterId
 {
@@ -1435,12 +1435,12 @@ BOOL _returnsData;
 {
     Ice::EndpointSeq cxxEndpoints;
     fromNSArray(endpoints, cxxEndpoints);
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_endpoints(cxxEndpoints)];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_endpoints(cxxEndpoints)];
 }
 
 -(id) ice_adapterId:(NSString*)adapterId
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_adapterId(fromNSString(adapterId))];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_adapterId(fromNSString(adapterId))];
 }
 
 -(ICEInt) ice_getLocatorCacheTimeout
@@ -1452,7 +1452,7 @@ BOOL _returnsData;
     NSException* nsex;
     try
     {
-        return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_locatorCacheTimeout(timeout)];
+        return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_locatorCacheTimeout(timeout)];
     }
     catch(const std::exception& ex)
     {
@@ -1466,7 +1466,7 @@ BOOL _returnsData;
 }
 -(id) ice_connectionCached:(BOOL)cached
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_connectionCached(cached)];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_connectionCached(cached)];
 }
 -(ICEEndpointSelectionType) ice_getEndpointSelection
 {
@@ -1474,7 +1474,7 @@ BOOL _returnsData;
 }
 -(id) ice_endpointSelection:(ICEEndpointSelectionType)type
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_endpointSelection((Ice::EndpointSelectionType)type)];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_endpointSelection((Ice::EndpointSelectionType)type)];
 }
 -(BOOL) ice_isSecure
 {
@@ -1482,7 +1482,7 @@ BOOL _returnsData;
 }
 -(id) ice_secure:(BOOL)secure
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_secure(secure)];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_secure(secure)];
 }
 
 -(ICEEncodingVersion*) ice_getEncodingVersion
@@ -1492,7 +1492,7 @@ BOOL _returnsData;
 
 -(id) ice_encodingVersion:(ICEEncodingVersion*)encoding;
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_encodingVersion([encoding encodingVersion])];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_encodingVersion([encoding encodingVersion])];
 }
 
 -(BOOL) ice_isPreferSecure
@@ -1501,25 +1501,25 @@ BOOL _returnsData;
 }
 -(id) ice_preferSecure:(BOOL)preferSecure
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_preferSecure(preferSecure)];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_preferSecure(preferSecure)];
 }
 -(id<ICERouterPrx>) ice_getRouter
 {
-    return (id<ICERouterPrx>)[ICERouterPrx objectPrxWithObjectPrx__:OBJECTPRX->ice_getRouter()];
+    return (id<ICERouterPrx>)[ICERouterPrx iceObjectPrxWithObjectPrx:OBJECTPRX->ice_getRouter()];
 }
 -(id) ice_router:(id<ICERouterPrx>)router
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_router(
-            Ice::RouterPrx::uncheckedCast(Ice::ObjectPrx([(ICEObjectPrx*)router objectPrx__])))];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_router(
+            Ice::RouterPrx::uncheckedCast(Ice::ObjectPrx([(ICEObjectPrx*)router iceObjectPrx])))];
 }
 -(id<ICELocatorPrx>) ice_getLocator
 {
-    return (id<ICELocatorPrx>)[ICELocatorPrx objectPrxWithObjectPrx__:OBJECTPRX->ice_getLocator()];
+    return (id<ICELocatorPrx>)[ICELocatorPrx iceObjectPrxWithObjectPrx:OBJECTPRX->ice_getLocator()];
 }
 -(id) ice_locator:(id<ICELocatorPrx>)locator
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_locator(
-            Ice::LocatorPrx::uncheckedCast(Ice::ObjectPrx([(ICEObjectPrx*)locator objectPrx__])))];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_locator(
+            Ice::LocatorPrx::uncheckedCast(Ice::ObjectPrx([(ICEObjectPrx*)locator iceObjectPrx])))];
 }
 -(BOOL) ice_isCollocationOptimized
 {
@@ -1527,7 +1527,7 @@ BOOL _returnsData;
 }
 -(id) ice_collocationOptimized:(BOOL)collocOptimized
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_collocationOptimized(collocOptimized)];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_collocationOptimized(collocOptimized)];
 }
 -(ICEInt) ice_getInvocationTimeout
 {
@@ -1538,7 +1538,7 @@ BOOL _returnsData;
     NSException* nsex;
     try
     {
-        return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_invocationTimeout(timeout)];
+        return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_invocationTimeout(timeout)];
     }
     catch(const std::exception& ex)
     {
@@ -1548,7 +1548,7 @@ BOOL _returnsData;
 }
 -(id) ice_twoway
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_twoway()];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_twoway()];
 }
 -(BOOL) ice_isTwoway
 {
@@ -1556,7 +1556,7 @@ BOOL _returnsData;
 }
 -(id) ice_oneway
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_oneway()];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_oneway()];
 }
 -(BOOL) ice_isOneway
 {
@@ -1564,7 +1564,7 @@ BOOL _returnsData;
 }
 -(id) ice_batchOneway
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_batchOneway()];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_batchOneway()];
 }
 -(BOOL) ice_isBatchOneway
 {
@@ -1572,7 +1572,7 @@ BOOL _returnsData;
 }
 -(id) ice_datagram
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_datagram()];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_datagram()];
 }
 -(BOOL) ice_isDatagram
 {
@@ -1580,7 +1580,7 @@ BOOL _returnsData;
 }
 -(id) ice_batchDatagram
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_batchDatagram()];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_batchDatagram()];
 }
 -(BOOL) ice_isBatchDatagram
 {
@@ -1588,14 +1588,14 @@ BOOL _returnsData;
 }
 -(id) ice_compress:(BOOL)compress
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_compress(compress)];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_compress(compress)];
 }
 -(id) ice_timeout:(int)timeout
 {
     NSException* nsex;
     try
     {
-        return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_timeout(timeout)];
+        return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_timeout(timeout)];
     }
     catch(const std::exception& ex)
     {
@@ -1605,7 +1605,7 @@ BOOL _returnsData;
 }
 -(id) ice_connectionId:(NSString*)connectionId
 {
-    return [[self class] objectPrxWithObjectPrx__:OBJECTPRX->ice_connectionId(fromNSString(connectionId))];
+    return [[self class] iceObjectPrxWithObjectPrx:OBJECTPRX->ice_connectionId(fromNSString(connectionId))];
 }
 -(id<ICEConnection>) ice_getConnection
 {
@@ -1637,23 +1637,23 @@ BOOL _returnsData;
                             result = OBJECTPRX->begin_ice_getConnection(cb);
                         },
                         ^(const Ice::AsyncResultPtr& result) {
-                            id<ICEConnection> ret__ =
+                            id<ICEConnection> ret =
                                 [ICEConnection localObjectWithCxxObject:OBJECTPRX->end_ice_getConnection(result).get()];
                             if(response)
                             {
-                                response(ret__);
+                                response(ret);
                             }
                         },
                         exception, nil, self);
 }
 -(id<ICEConnection>) end_ice_getConnection:(id<ICEAsyncResult>)result
 {
-    __block id<ICEConnection> ret__;
+    __block id<ICEConnection> ret;
     endCppCall(^(const Ice::AsyncResultPtr& r)
                {
-                   ret__ = [ICEConnection localObjectWithCxxObject:OBJECTPRX->end_ice_getConnection(r).get()];
+                   ret = [ICEConnection localObjectWithCxxObject:OBJECTPRX->end_ice_getConnection(r).get()];
                }, result);
-    return ret__;
+    return ret;
 }
 
 -(id<ICEConnection>) ice_getCachedConnection
diff --git a/objective-c/src/Ice/ProxyI.h b/objective-c/src/Ice/ProxyI.h
index 1cec205305d..7a61bb124ba 100644
--- a/objective-c/src/Ice/ProxyI.h
+++ b/objective-c/src/Ice/ProxyI.h
@@ -14,19 +14,19 @@
 @interface ICEAsyncResult : NSObject<ICEAsyncResult>
 {
 @private
-    void* asyncResult__;
+    void* asyncResult_;
     NSString* operation_;
     id<ICEObjectPrx> proxy_;
 }
--(ICEAsyncResult*)initWithAsyncResult__:(const Ice::AsyncResultPtr&)arg operation:(NSString*)op proxy:(id<ICEObjectPrx>)p;
--(Ice::AsyncResult*) asyncResult__;
-+(ICEAsyncResult*)asyncResultWithAsyncResult__:(const Ice::AsyncResultPtr&)arg;
-+(ICEAsyncResult*)asyncResultWithAsyncResult__:(const Ice::AsyncResultPtr&)arg operation:(NSString*)op proxy:(id<ICEObjectPrx>)p;
+-(ICEAsyncResult*)initWithAsyncResult:(const Ice::AsyncResultPtr&)arg operation:(NSString*)op proxy:(id<ICEObjectPrx>)p;
+-(Ice::AsyncResult*) asyncResult;
++(ICEAsyncResult*)asyncResultWithAsyncResult:(const Ice::AsyncResultPtr&)arg;
++(ICEAsyncResult*)asyncResultWithAsyncResult:(const Ice::AsyncResultPtr&)arg operation:(NSString*)op proxy:(id<ICEObjectPrx>)p;
 -(NSString*)operation;
 @end
 
 @interface ICEObjectPrx ()
--(ICEObjectPrx*)initWithObjectPrx__:(const Ice::ObjectPrx&)arg;
--(IceProxy::Ice::Object*) objectPrx__;
-+(ICEObjectPrx*)objectPrxWithObjectPrx__:(const Ice::ObjectPrx&)arg;
+-(ICEObjectPrx*)iceInitWithObjectPrx:(const Ice::ObjectPrx&)arg;
+-(IceProxy::Ice::Object*) iceObjectPrx;
++(ICEObjectPrx*)iceObjectPrxWithObjectPrx:(const Ice::ObjectPrx&)arg;
 @end
diff --git a/objective-c/src/Ice/Request.m b/objective-c/src/Ice/Request.m
index 71c6cdd32df..37d559be0fa 100644
--- a/objective-c/src/Ice/Request.m
+++ b/objective-c/src/Ice/Request.m
@@ -46,7 +46,7 @@
         [is rewind];
         [os reset:NO];
     }
-    [servant dispatch__:current is:is os:os];
+    [servant iceDispatch:current is:is os:os];
 }
 
 -(void) dealloc
diff --git a/objective-c/src/Ice/SlicedData.mm b/objective-c/src/Ice/SlicedData.mm
index f4c746141a2..da6e9ed1b25 100644
--- a/objective-c/src/Ice/SlicedData.mm
+++ b/objective-c/src/Ice/SlicedData.mm
@@ -21,20 +21,20 @@
     {
         return nil;
     }
-    self->slicedData__ = slicedData;
-    self->slicedData__->__incRef();
+    self->slicedData_ = slicedData;
+    self->slicedData_->__incRef();
     return self;
 }
 
 -(void) dealloc
 {
-    self->slicedData__->__decRef();
+    self->slicedData_->__decRef();
     [super dealloc];
 }
 
 -(Ice::SlicedData*) slicedData
 {
-    return slicedData__;
+    return slicedData_;
 }
 
 @end
@@ -70,13 +70,13 @@
     return [[slicedData_ retain] autorelease];
 }
 
--(void) write__:(id<ICEOutputStream>)os
+-(void) iceWrite:(id<ICEOutputStream>)os
 {
     [os startValue:slicedData_];
     [os endValue];
 }
 
--(void) read__:(id<ICEInputStream>)is
+-(void) iceRead:(id<ICEInputStream>)is
 {
     [is startValue];
     slicedData_ = [is endValue:YES];
diff --git a/objective-c/src/Ice/SlicedDataI.h b/objective-c/src/Ice/SlicedDataI.h
index 5742a829c9f..14872443bad 100644
--- a/objective-c/src/Ice/SlicedDataI.h
+++ b/objective-c/src/Ice/SlicedDataI.h
@@ -14,7 +14,7 @@
 @interface ICESlicedData : NSObject<ICESlicedData>
 {
 @private
-    Ice::SlicedData* slicedData__;
+    Ice::SlicedData* slicedData_;
 }
 -(id) initWithSlicedData:(Ice::SlicedData*)slicedData;
 -(Ice::SlicedData*) slicedData;
diff --git a/objective-c/src/Ice/Stream.mm b/objective-c/src/Ice/Stream.mm
index 85b518ec903..a311f40c882 100644
--- a/objective-c/src/Ice/Stream.mm
+++ b/objective-c/src/Ice/Stream.mm
@@ -50,7 +50,7 @@ public:
     {
         @try
         {
-            [_obj write__:static_cast<ICEOutputStream*>(stream->getClosure())];
+            [_obj iceWrite:static_cast<ICEOutputStream*>(stream->getClosure())];
         }
         @catch(id ex)
         {
@@ -63,7 +63,7 @@ public:
     {
         @try
         {
-            [_obj read__:static_cast<ICEInputStream*>(stream->getClosure())];
+            [_obj iceRead:static_cast<ICEInputStream*>(stream->getClosure())];
         }
         @catch(id ex)
         {
@@ -270,7 +270,7 @@ public:
     virtual bool
     _usesClasses() const
     {
-        return [_ex usesClasses__];
+        return [_ex iceUsesClasses];
     }
 
     virtual std::string
@@ -294,13 +294,13 @@ public:
     virtual void
     _write(Ice::OutputStream* s) const
     {
-        [_ex write__:static_cast<ICEOutputStream*>(s->getClosure())];
+        [_ex iceWrite:static_cast<ICEOutputStream*>(s->getClosure())];
     }
 
     virtual void
     _read(Ice::InputStream* s)
     {
-        [_ex read__:static_cast<ICEInputStream*>(s->getClosure())];
+        [_ex iceRead:static_cast<ICEInputStream*>(s->getClosure())];
     }
 
     ICEUserException*
@@ -917,7 +917,7 @@ private:
     {
         Ice::ObjectPrx p;
         is_->read(p);
-        return p ? [[type alloc] initWithObjectPrx__:p] : nil;
+        return p ? [[type alloc] iceInitWithObjectPrx:p] : nil;
     }
     catch(const std::exception& ex)
     {
@@ -1922,7 +1922,7 @@ private:
     NSException* nsex = nil;
     try
     {
-        os_->write(Ice::ObjectPrx([(ICEObjectPrx*)v objectPrx__]));
+        os_->write(Ice::ObjectPrx([(ICEObjectPrx*)v iceObjectPrx]));
     }
     catch(const std::exception& ex)
     {
@@ -2779,7 +2779,7 @@ private:
 
     @try
     {
-        [p read__:stream];
+        [p iceRead:stream];
     }
     @catch(NSException *ex)
     {
@@ -2799,7 +2799,7 @@ private:
         obj = [[self getType] new];
         @try
         {
-            [obj write__:stream];
+            [obj iceWrite:stream];
         }
         @finally
         {
@@ -2808,7 +2808,7 @@ private:
     }
     else
     {
-        [obj write__:stream];
+        [obj iceWrite:stream];
     }
 }
 +(id) readOptionalRetained:(id<ICEInputStream>)stream tag:(ICEInt)tag
diff --git a/objective-c/src/Ice/Util.mm b/objective-c/src/Ice/Util.mm
index 74cc4b8eb65..506919905e9 100644
--- a/objective-c/src/Ice/Util.mm
+++ b/objective-c/src/Ice/Util.mm
@@ -157,7 +157,7 @@ ICEAsyncResult* beginCppCall(void (^fn)(Ice::AsyncResultPtr&), ICEObjectPrx* prx
     {
         Ice::AsyncResultPtr r;
         fn(r);
-        return [ICEAsyncResult asyncResultWithAsyncResult__:r operation:nil proxy:prx];
+        return [ICEAsyncResult asyncResultWithAsyncResult:r operation:nil proxy:prx];
     }
     catch(const std::exception& ex)
     {
@@ -179,7 +179,7 @@ ICEAsyncResult* beginCppCall(void (^fn)(Ice::AsyncResultPtr&, const Ice::Callbac
         Ice::AsyncResultPtr r;
         Ice::CallbackPtr callback = Ice::newCallback(cb, &AsyncCallback::completed, &AsyncCallback::sent);
         fn(r, callback);
-        return [ICEAsyncResult asyncResultWithAsyncResult__:r operation:nil proxy:prx];
+        return [ICEAsyncResult asyncResultWithAsyncResult:r operation:nil proxy:prx];
     }
     catch(const std::exception& ex)
     {
@@ -199,7 +199,7 @@ ICEAsyncResult* beginCppCall(void (^fn)(Ice::AsyncResultPtr&, const Ice::Context
         fromNSDictionary(context, ctx);
         Ice::AsyncResultPtr r;
         fn(r, ctx);
-        return [ICEAsyncResult asyncResultWithAsyncResult__:r operation:nil proxy:prx];
+        return [ICEAsyncResult asyncResultWithAsyncResult:r operation:nil proxy:prx];
     }
     catch(const std::exception& ex)
     {
@@ -224,7 +224,7 @@ ICEAsyncResult* beginCppCall(void (^fn)(Ice::AsyncResultPtr&, const Ice::Context
         Ice::AsyncResultPtr r;
         Ice::CallbackPtr callback = Ice::newCallback(cb, &AsyncCallback::completed, &AsyncCallback::sent);
         fn(r, ctx, callback);
-        return [ICEAsyncResult asyncResultWithAsyncResult__:r operation:nil proxy:prx];
+        return [ICEAsyncResult asyncResultWithAsyncResult:r operation:nil proxy:prx];
     }
     catch(const std::exception& ex)
     {
@@ -238,7 +238,7 @@ void endCppCall(void (^fn)(const Ice::AsyncResultPtr&), ICEAsyncResult* r)
     NSException* nsex = nil;
     try
     {
-        fn([r asyncResult__]);
+        fn([r asyncResult]);
         return;
     }
     catch(const std::exception& ex)