ORBit and ANSI C disaster

From: Drazen Kacar <dave srce hr>
To: gnome-list gnome org
Cc: orbit-list cuc edu
Subject: ORBit and ANSI C disaster
Date: Sat, 6 Mar 1999 18:46:02 +0100

This is cc'ed to orbit-list@cuc.edu. I found that address in one of the
files in ORBit's docs directory. I don't know if that list still exists or
if it accepts postings from non-subscribers. If it's closed, could somebody
remail this to ORBit people? I'm too frustrated to deal with that thing
any more.

In short, ORBit can't be compiled without gcc and files produced with
orbit-idl also can't be compiled without gcc. I wouldn't have anything against
that if there was a warning about it somewhere. Configure script should
have refused to work without gcc, but it didn't, of course.

I tried to compile it on Solaris 7 using cc 5.0 in 32 bit environment. But...

The first bug was simple: popt/popthelp.c needs `#include <alloca.h>'.

Then src/daemons/interface_repository/interface_repository.idl could not
be compiled. It turned out that Solaris' lex & yacc weren't doing what
they were supposed to do. Configure, of course, didn't have anything against
them. I don't know if the bug is in Solaris utilities or in ORGit's code
(although I suspect the latter) and I don't know if the problem is in
only one of them or both. So I installed flex and bison and things worked.

Then there was trouble with indent. There is a #define in
idl-compiler/orbit-c-backend.c which binds command line flags to it, but
Solaris' indent also needs `-st' to behave as authors intended. Configure,
needless to say, didn't do a thing about it.

Then the troubles with non-ANSI C started. The code is full of statements
like this:

   (uchar *)a->b += c;

That is an error. Casts don't yield an lvalue, so you can't assign something
to it. gcc groks that, but that has never been in any standard. As far
as I know. There is a 16K patch attached which corrects things like that
in several files. It should be applied in src/orb directory. ORBit version
is 0.4.0.

Next, macros in orb/allocator-defs.h are, as the comment there says, a crap.
This was the first time I've seen a compiler which produces
"warning: syntax error" kind of message and compiles anyway. Most of
the macros expand to ` ; <some-statement>'. Semicolon outside of a function
body is a syntax error.

After fixing all that, my compiler happily showed hundreds of warnings
(actually errors) in interface_repository-stubs.c. And that file was
produced by orbit-idl. All of the errors were assignments to a cast.
At that point it became meaningless to mess with the whole thing.

-- 
 .-.   .-.    Life is a sexually transmitted disease.
(_  \ /  _)
     |        dave@srce.hr
     |        dave@fly.cc.fer.hr

--- corba_any.c.orig	Sat Mar  6 17:29:15 1999
+++ corba_any.c	Sat Mar  6 17:53:58 1999
@@ -111,40 +111,40 @@
     case CORBA_tk_short:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_SHORT);
 	giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(buf), *val, sizeof(CORBA_short));
-	(guchar *)*val += sizeof(CORBA_short);
+	*val = (guchar *)*val + sizeof(CORBA_short);
 	break;
     case CORBA_tk_enum:
     case CORBA_tk_long:
     case CORBA_tk_ulong:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG);
 	giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(buf), *val, sizeof(CORBA_long));
-	(guchar *)*val += sizeof(CORBA_long);
+	*val = (guchar *)*val + sizeof(CORBA_long);
 	break;
     case CORBA_tk_float:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_FLOAT);
 	giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(buf), *val, sizeof(CORBA_float));
-	(guchar *)*val += sizeof(CORBA_float);
+	*val = (guchar *)*val + sizeof(CORBA_float);
 	break;
     case CORBA_tk_double:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_DOUBLE);
 	giop_message_buffer_append_mem_a(GIOP_MESSAGE_BUFFER(buf), *val, sizeof(CORBA_double));
-	(guchar *)*val += sizeof(CORBA_double);
+	*val = (guchar *)*val + sizeof(CORBA_double);
 	break;
     case CORBA_tk_boolean:
     case CORBA_tk_char:
     case CORBA_tk_octet:
 	giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(buf), *val, sizeof(CORBA_octet));
-	(guchar *)*val += sizeof(CORBA_octet);
+	*val = (guchar *)*val + sizeof(CORBA_octet);
 	break;
     case CORBA_tk_any:
 	*val = ALIGN_ADDRESS(*val, MAX(ALIGNOF_CORBA_STRUCT, ALIGNOF_CORBA_POINTER));
 	ORBit_marshal_any(buf, *val);
-	(guchar *)*val += sizeof(CORBA_any);
+	*val = (guchar *)*val + sizeof(CORBA_any);
 	break;
     case CORBA_tk_TypeCode:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_POINTER);
 	ORBit_encode_CORBA_TypeCode(*val, buf);
-	(guchar *)*val += sizeof(CORBA_TypeCode);
+	*val = (guchar *)*val + sizeof(CORBA_TypeCode);
 	break;
     case CORBA_tk_Principal:
 	*val = ALIGN_ADDRESS(*val,
@@ -157,12 +157,12 @@
 	giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(buf),
 				       *(char**)((char *)*val+sizeof(CORBA_unsigned_long)),
 				       ulval);
-	(guchar *)*val += sizeof(CORBA_Principal);
+	*val = (guchar *)*val + sizeof(CORBA_Principal);
 	break;
     case CORBA_tk_objref:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_POINTER);
 	ORBit_marshal_object(buf, *val);
-	(guchar *)*val += sizeof(CORBA_Object);
+	*val = (guchar *)*val + sizeof(CORBA_Object);
 	break;
     case CORBA_tk_except:
     case CORBA_tk_struct:
@@ -194,7 +194,7 @@
 					       sizeof(CORBA_unsigned_long));
 	giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(buf), *(char **)*val, ulval);
 	
-	(guchar *)*val += sizeof(char *);
+	*val = (guchar *)*val + sizeof(char *);
 	break;
     case CORBA_tk_string:
 	ulval = strlen(*(char **)*val) + 1;
@@ -206,7 +206,7 @@
 					       sizeof(CORBA_unsigned_long));
 	giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(buf), *(char **)*val, ulval);
 	
-	(guchar *)*val += sizeof(char *);
+	*val = (guchar *)*val +sizeof(char *);
 	break;
     case CORBA_tk_sequence:
 	{
@@ -224,7 +224,7 @@
 	    for(i = 0; i < sval->_length; i++)
 		ORBit_marshal_value(buf, &subval, tc->subtypes[0], mi);
 	    
-	    (guchar *)*val += sizeof(CORBA_sequence_octet);
+	    *val = (guchar *)*val + sizeof(CORBA_sequence_octet);
 	}
 	break;
     case CORBA_tk_array:
@@ -460,7 +460,7 @@
     return retval;
 }
 
-#define DM_GET_ATOM(x, n) G_STMT_START{ GIOP_RECV_BUFFER(buf)->decoder(x, (GIOP_RECV_BUFFER(buf)->cur), n); ((char *)GIOP_RECV_BUFFER(buf)->cur) += n; }G_STMT_END
+#define DM_GET_ATOM(x, n) G_STMT_START{ GIOP_RECV_BUFFER(buf)->decoder(x, (GIOP_RECV_BUFFER(buf)->cur), n); GIOP_RECV_BUFFER(buf)->cur = ((char *)GIOP_RECV_BUFFER(buf)->cur) + n; }G_STMT_END
 
 static void
 ORBit_demarshal_value(GIOPRecvBuffer *buf,
@@ -483,7 +483,7 @@
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_SHORT);
 	buf->cur = ALIGN_ADDRESS(buf->cur, sizeof(CORBA_short));
 	DM_GET_ATOM(*val, sizeof(CORBA_short));
-	(guchar *)*val += sizeof(CORBA_short);
+	*val = (guchar *)*val + sizeof(CORBA_short);
 	break;
     case CORBA_tk_long:
     case CORBA_tk_ulong:
@@ -491,38 +491,38 @@
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG);
 	buf->cur = ALIGN_ADDRESS(buf->cur, sizeof(CORBA_long));
 	DM_GET_ATOM(*val, sizeof(CORBA_long));
-	(guchar *)*val += sizeof(CORBA_long);
+	*val = (guchar *)*val + sizeof(CORBA_long);
 	break;
     case CORBA_tk_longlong:
     case CORBA_tk_ulonglong:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG_LONG);
 	buf->cur = ALIGN_ADDRESS(buf->cur, sizeof(CORBA_long_long));
 	DM_GET_ATOM(*val, sizeof(CORBA_long_long));
-	(guchar *)*val += sizeof(CORBA_long_long);
+	*val = (guchar *)*val +sizeof(CORBA_long_long);
 	break;
     case CORBA_tk_longdouble:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG_DOUBLE);
 	buf->cur = ALIGN_ADDRESS(buf->cur, sizeof(CORBA_long_double));
 	DM_GET_ATOM(*val, sizeof(CORBA_long_double));
-	(guchar *)*val += sizeof(CORBA_long_double);
+	*val = (guchar *)*val + sizeof(CORBA_long_double);
 	break;
     case CORBA_tk_float:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_FLOAT);
 	buf->cur = ALIGN_ADDRESS(buf->cur, sizeof(CORBA_float));
 	DM_GET_ATOM(*val, sizeof(CORBA_float));
-	(guchar *)*val += sizeof(CORBA_float);
+	*val = (guchar *)*val + sizeof(CORBA_float);
 	break;
     case CORBA_tk_double:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_DOUBLE);
 	buf->cur = ALIGN_ADDRESS(buf->cur, sizeof(CORBA_double));
 	DM_GET_ATOM(*val, sizeof(CORBA_double));
-	(guchar *)*val += sizeof(CORBA_double);
+	*val = (guchar *)*val + sizeof(CORBA_double);
 	break;
     case CORBA_tk_boolean:
     case CORBA_tk_char:
     case CORBA_tk_octet:
 	DM_GET_ATOM(*val, sizeof(CORBA_octet));
-	(guchar *)*val += sizeof(CORBA_octet);
+	*val = (guchar *)*val + sizeof(CORBA_octet);
 	break;
     case CORBA_tk_any:
 	{
@@ -534,14 +534,14 @@
 	    decoded = *val;
 	    decoded->_release = CORBA_FALSE;
 	    ORBit_demarshal_any(buf, decoded, dup_strings, orb);
-	    (guchar *)*val += sizeof(CORBA_any);
+	    *val = (guchar *)*val + sizeof(CORBA_any);
 	}
 	break;
     case CORBA_tk_TypeCode:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_POINTER);
 	ORBit_decode_CORBA_TypeCode(*val, buf);
 	CORBA_Object_duplicate(*(CORBA_Object *)*val, NULL);
-	(guchar *)*val += sizeof(CORBA_TypeCode);
+	*val = (guchar *)*val + sizeof(CORBA_TypeCode);
 	break;
     case CORBA_tk_Principal:
 	{
@@ -556,14 +556,14 @@
 	    DM_GET_ATOM(&p->_length, sizeof(CORBA_long));
 	    p->_buffer = ORBit_alloc(p->_length, NULL, GINT_TO_POINTER(1));
 	    memcpy(p->_buffer, buf->cur, p->_length);
-	    (char *)buf->cur += p->_length;
-	    (guchar *)*val += sizeof(CORBA_sequence_octet);
+	    buf->cur = (char *)buf->cur + p->_length;
+	    *val = (guchar *)*val + sizeof(CORBA_sequence_octet);
 	}
 	break;
     case CORBA_tk_objref:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_POINTER);
 	*(CORBA_Object *)*val = ORBit_demarshal_object(buf, orb);
-	(guchar *)*val += sizeof(CORBA_Object);
+	*val = (guchar *)*val + sizeof(CORBA_Object);
 	break;
     case CORBA_tk_except:
     case CORBA_tk_struct:
@@ -597,7 +597,7 @@
 	    *(char **)*val = CORBA_string_dup(buf->cur);
 	else
 	    *(char **)*val = buf->cur;
-	(guchar *)*val += sizeof(CORBA_char *);
+	*val = (guchar *)*val + sizeof(CORBA_char *);
 	break;
     case CORBA_tk_sequence:
 	{
@@ -616,7 +616,7 @@
 		   all atoms... */
 		p->_buffer = ORBit_alloc(p->_length, NULL, GINT_TO_POINTER(1));
 		memcpy(p->_buffer, buf->cur, p->_length);
-		(char *)buf->cur += p->_length;
+		buf->cur = (char *)buf->cur + p->_length;
 	    } else {
 		p->_buffer = ORBit_demarshal_allocate_mem(tc->subtypes[0],
 							  p->_length);
@@ -629,7 +629,7 @@
 					  orb);
 	    }
 
-	    (guchar *)*val += sizeof(CORBA_sequence_octet);
+	    *val = (guchar *)*val + sizeof(CORBA_sequence_octet);
 	}
 	break;
     case CORBA_tk_array:
@@ -694,8 +694,8 @@
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_SHORT);
 	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_SHORT);
 	*(CORBA_short *)*newval = *(CORBA_short *)*val;
-	(guchar *)*val += sizeof(CORBA_short);
-	(guchar *)*newval += sizeof(CORBA_short);
+	*val = (guchar *)*val + sizeof(CORBA_short);
+	*newval = (guchar *)*newval + sizeof(CORBA_short);
 	break;
     case CORBA_tk_enum:
     case CORBA_tk_long:
@@ -703,44 +703,44 @@
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG);
 	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_LONG);
 	*(CORBA_long *)*newval = *(CORBA_long *)*val;
-	(guchar *)*val += sizeof(CORBA_long);
-	(guchar *)*newval += sizeof(CORBA_long);
+	*val = (guchar *)*val + sizeof(CORBA_long);
+	*newval = (guchar *)*newval + sizeof(CORBA_long);
 	break;
     case CORBA_tk_longlong:
     case CORBA_tk_ulonglong:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG_LONG);
 	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_LONG_LONG);
 	*(CORBA_long_long *)*newval = *(CORBA_long_long *)*val;
-	(guchar *)*val += sizeof(CORBA_long_long);
-	(guchar *)*newval += sizeof(CORBA_long_long);
+	*val = (guchar *)*val + sizeof(CORBA_long_long);
+	*newval = (guchar *)*newval + sizeof(CORBA_long_long);
 	break;
     case CORBA_tk_longdouble:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_LONG_DOUBLE);
 	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_LONG_DOUBLE);
 	*(CORBA_long_double *)*newval = *(CORBA_long_double *)*val;
-	(guchar *)*val += sizeof(CORBA_long_double);
-	(guchar *)*newval += sizeof(CORBA_long_double);
+	*val = (guchar *)*val + sizeof(CORBA_long_double);
+	*newval = (guchar *)*newval + sizeof(CORBA_long_double);
 	break;
     case CORBA_tk_float:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_FLOAT);
 	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_FLOAT);
 	*(CORBA_long *)*newval = *(CORBA_long *)*val;
-	(guchar *)*val += sizeof(CORBA_float);
-	(guchar *)*newval += sizeof(CORBA_float);
+	*val = (guchar *)*val + sizeof(CORBA_float);
+	*newval = (guchar *)*newval + sizeof(CORBA_float);
 	break;
     case CORBA_tk_double:
 	*val = ALIGN_ADDRESS(*val, ALIGNOF_CORBA_DOUBLE);
 	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_DOUBLE);
 	*(CORBA_double *)*newval = *(CORBA_double *)*val;
-	(guchar *)*val += sizeof(CORBA_double);
-	(guchar *)*newval += sizeof(CORBA_double);
+	*val = (guchar *)*val + sizeof(CORBA_double);
+	*newval = (guchar *)*newval + sizeof(CORBA_double);
 	break;
     case CORBA_tk_boolean:
     case CORBA_tk_char:
     case CORBA_tk_octet:
 	*(CORBA_octet *)*newval = *(CORBA_octet *)*val;
-	(guchar *)*val += sizeof(CORBA_octet);
-	(guchar *)*newval += sizeof(CORBA_octet);
+	*val = (guchar *)*val + sizeof(CORBA_octet);
+	*newval = (guchar *)*newval + sizeof(CORBA_octet);
 	break;
     case CORBA_tk_any:
 	{
@@ -754,8 +754,8 @@
                == FALSE? */
 	    newany->_value = ORBit_copy_value(oldany->_value, oldany->_type);
 	    newany->_release = CORBA_TRUE;
-	    (guchar *)*val += sizeof(CORBA_any);
-	    (guchar *)*newval += sizeof(CORBA_any);
+	    *val = (guchar *)*val + sizeof(CORBA_any);
+	    *newval = (guchar *)*newval + sizeof(CORBA_any);
 	}
 	break;
     case CORBA_tk_Principal:
@@ -773,8 +773,8 @@
 	memcpy(((CORBA_Principal *)*newval)->_buffer,
 	       ((CORBA_Principal *)*val)->_buffer,
 	       ((CORBA_Principal *)*val)->_length);
-	(guchar *)*val += sizeof(CORBA_Principal);
-	(guchar *)*newval += sizeof(CORBA_Principal);
+	*val = (guchar *)*val + sizeof(CORBA_Principal);
+	*newval = (guchar *)*newval + sizeof(CORBA_Principal);
 	break;
     case CORBA_tk_TypeCode:
     case CORBA_tk_objref:
@@ -782,8 +782,8 @@
 	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_POINTER);
 	*(CORBA_Object *)*newval = CORBA_Object_duplicate(*(CORBA_Object *)*val,
 							  NULL);
-	(guchar *)*val += sizeof(CORBA_Object);
-	(guchar *)*newval += sizeof(CORBA_Object);
+	*val = (guchar *)*val + sizeof(CORBA_Object);
+	*newval = (guchar *)*newval + sizeof(CORBA_Object);
 	break;
     case CORBA_tk_struct:
     case CORBA_tk_except:
@@ -812,8 +812,8 @@
 	*newval = ALIGN_ADDRESS(*newval, ALIGNOF_CORBA_POINTER);
 	
 	*(CORBA_char **)*newval = CORBA_string_dup(*(CORBA_char **)*val);
-	(guchar *)*val += sizeof(CORBA_char *);
-	(guchar *)*newval += sizeof(CORBA_char *);
+	*val = (guchar *)*val + sizeof(CORBA_char *);
+	*newval = (guchar *)*newval + sizeof(CORBA_char *);
 	break;
     case CORBA_tk_sequence:
 	*val = ALIGN_ADDRESS(*val,
@@ -834,8 +834,8 @@
 	for(i = 0; i < ((CORBA_Principal *)*newval)->_length; i++) {
 	    _ORBit_copy_value(&pval1, &pval2, tc->subtypes[0]);
 	}
-	(guchar *)*val += sizeof(CORBA_sequence_octet);
-	(guchar *)*newval += sizeof(CORBA_sequence_octet);
+	*val = (guchar *)*val + sizeof(CORBA_sequence_octet);
+	*newval = (guchar *)*newval + sizeof(CORBA_sequence_octet);
 	break;
     case CORBA_tk_array:
 	for(i = 0; i < tc->length; i++) {
--- env.c.orig	Sat Mar  6 16:29:24 1999
+++ env.c	Sat Mar  6 16:31:44 1999
@@ -213,11 +213,11 @@
 
 	rb->cur = ALIGN_ADDRESS(rb->cur, sizeof(len));
 	rb->decoder(&len, rb->cur, sizeof(len));
-	(guchar *)rb->cur += sizeof(len);
+	rb->cur = (guchar *)rb->cur + sizeof(len);
 
 	if(len) {
 		my_repoid = rb->cur;
-		(guchar *)rb->cur += len;
+		rb->cur = (guchar *)rb->cur + len;
 	} else
 		my_repoid = NULL;
 
@@ -225,7 +225,7 @@
 		ev->_major = CORBA_SYSTEM_EXCEPTION;
 		rb->cur = ALIGN_ADDRESS(rb->cur, sizeof(minor));
 		rb->decoder(&minor, rb->cur, sizeof(len));
-		(guchar *)rb->cur += sizeof(len);
+		rb->cur = (guchar *)rb->cur + sizeof(len);
 
 		for(minor = 1; exception_table[minor].repo_id; minor++) {
 			if(!strcmp(exception_table[minor].repo_id, my_repoid))
@@ -234,7 +234,7 @@
 
 		rb->cur = ALIGN_ADDRESS(rb->cur, sizeof(completion_status));
 		rb->decoder(&completion_status, rb->cur, sizeof(completion_status));
-		(guchar *)rb->cur += sizeof(completion_status);
+		rb->cur = (guchar *)rb->cur + sizeof(completion_status);
 
 		new=ORBit_alloc(sizeof(CORBA_SystemException), NULL, NULL);
 
--- orbit_object.c.orig	Sat Mar  6 16:40:01 1999
+++ orbit_object.c	Sat Mar  6 17:26:32 1999
@@ -177,7 +177,7 @@
 	obj->interface = epv;
 }
 
-#define GET_ATOM(x) G_STMT_START{ GIOP_RECV_BUFFER(recv_buffer)->decoder(&x, (GIOP_RECV_BUFFER(recv_buffer)->cur), sizeof(x)); ((guchar *)GIOP_RECV_BUFFER(recv_buffer)->cur) += sizeof(x); }G_STMT_END
+#define GET_ATOM(x) G_STMT_START{ GIOP_RECV_BUFFER(recv_buffer)->decoder(&x, (GIOP_RECV_BUFFER(recv_buffer)->cur), sizeof(x)); GIOP_RECV_BUFFER(recv_buffer)->cur = ((guchar *)GIOP_RECV_BUFFER(recv_buffer)->cur) + sizeof(x); }G_STMT_END
 #define ALIGNFOR(x) recv_buffer->cur = ALIGN_ADDRESS(recv_buffer->cur, sizeof(x))
 
 CORBA_Object
@@ -244,7 +244,7 @@
 		CDR_codec_init_static(codec);
 		codec->buffer = recv_buffer->cur;
 		codec->release_buffer = CORBA_FALSE;
-		((guchar *)recv_buffer->cur) += subpart_len;
+		recv_buffer->cur = (guchar *)recv_buffer->cur + subpart_len;
 
 		codec->readonly = CORBA_TRUE;
 		codec->host_endian = codec->data_endian = FLAG_ENDIANNESS;
@@ -281,7 +281,7 @@
 		GET_ATOM(subpart_len);
 		g_warning("IOP_TAG_MULTIPLE_COMPONENTS decoding needs finishing");
 		object_info->profile_type = IOP_TAG_MULTIPLE_COMPONENTS;
-		((guchar *)recv_buffer->cur) += subpart_len;
+		recv_buffer->cur = (guchar *)recv_buffer->cur + subpart_len;
 		return(object_info);
 		break;
 
@@ -290,7 +290,7 @@
 		CDR_codec_init_static(codec);
 		codec->buffer = recv_buffer->cur;
 		codec->release_buffer = CORBA_FALSE;
-		((guchar *)recv_buffer->cur) += subpart_len;
+		recv_buffer->cur = (guchar *)recv_buffer->cur + subpart_len;
 
 		codec->readonly = CORBA_TRUE;
 		codec->host_endian = codec->data_endian = FLAG_ENDIANNESS;
@@ -346,7 +346,7 @@
 	if(len == 0)
 		return(NULL);
 
-	((guchar *)recv_buffer->cur) += len;
+	recv_buffer->cur = (guchar *)recv_buffer + len;
 
 	/* Decode the sequence<TaggedProfile> */
 	ALIGNFOR(CORBA_unsigned_long);
@@ -391,7 +391,7 @@
 		return CORBA_OBJECT_NIL;
 
 	type_id = recv_buffer->cur;
-	((guchar *)recv_buffer->cur) += len;
+	recv_buffer->cur = (guchar *)recv_buffer->cur + len;
 
 	/* Decode the sequence<TaggedProfile> */
 	ALIGNFOR(CORBA_unsigned_long);
--- orbit_typecode.c.orig	Sat Mar  6 17:27:45 1999
+++ orbit_typecode.c	Sat Mar  6 17:28:32 1999
@@ -161,7 +161,7 @@
 	for(l=ctx.prior_tcs;l;l=l->next)
 		g_free(l->data);
 	g_slist_free(ctx.prior_tcs);
-	((guchar *)buf->cur) += codec->rptr;
+	buf->cur = (guchar *)buf->cur + codec->rptr;
 }

[Date Prev][Date Next] [Thread Prev][Thread Next] [Thread Index] [Date Index] [Author Index]