From: Michal Sojka <sojkam1@fel.cvut.cz>
Date: Wed, 26 Nov 2008 13:22:57 +0000 (+0100)
Subject: CDR_* functions and types renamed to FORB_CDR_*
X-Git-Url: https://rtime.felk.cvut.cz/gitweb/frescor/forb.git/commitdiff_plain/81dda5e37534a253678b9033d7f0d367d588359f

CDR_* functions and types renamed to FORB_CDR_*

This is to avoid namespace collision when linking with ORTE.
---

diff --git a/forb-idl/forb-idl-c-common.c b/forb-idl/forb-idl-c-common.c
index 47ffbee..bf1a1eb 100644
--- a/forb-idl/forb-idl-c-common.c
+++ b/forb-idl/forb-idl-c-common.c
@@ -118,7 +118,7 @@ cc_output_ser_struct(OIDL_C_Info *ci,
 	char *id;
 	id = IDL_ns_ident_to_qstring(IDL_IDENT_TO_NS(IDL_TYPE_STRUCT(s).ident), "_", 0);
 	
-	fprintf(ci->fh, "CORBA_boolean %s_serialize(CDR_Codec *codec, const %s *ptr)\n", id, id);
+	fprintf(ci->fh, "CORBA_boolean %s_serialize(FORB_CDR_Codec *codec, const %s *ptr)\n", id, id);
 	fprintf(ci->fh, "{\n");
 	for(cur = IDL_TYPE_STRUCT(s).member_list; cur; cur = IDL_LIST(cur).next) {
 		for(curmem = IDL_MEMBER(IDL_LIST(cur).data).dcls; curmem; curmem = IDL_LIST(curmem).next) {
@@ -137,7 +137,7 @@ cc_output_ser_struct(OIDL_C_Info *ci,
 			"  return CORBA_FALSE;\n"
 			"}\n\n");
 
-	fprintf(ci->fh, "CORBA_boolean %s_deserialize(CDR_Codec *codec, %s *ptr)\n", id, id);
+	fprintf(ci->fh, "CORBA_boolean %s_deserialize(FORB_CDR_Codec *codec, %s *ptr)\n", id, id);
 	fprintf(ci->fh, "{\n");
 	for(cur = IDL_TYPE_STRUCT(s).member_list; cur; cur = IDL_LIST(cur).next) {
 		for(curmem = IDL_MEMBER(IDL_LIST(cur).data).dcls; curmem; curmem = IDL_LIST(curmem).next) {
@@ -184,7 +184,7 @@ cc_output_ser_seqence(OIDL_C_Info *ci,
 		return;
 	}
 
-	fprintf(ci->fh, "CORBA_boolean %s_serialize(CDR_Codec *codec, const %s *seq)\n", id, id);
+	fprintf(ci->fh, "CORBA_boolean %s_serialize(FORB_CDR_Codec *codec, const %s *seq)\n", id, id);
 	fprintf(ci->fh, "{\n"
 			"  int i;\n"
 			"  CORBA_boolean ok;\n"
@@ -195,7 +195,7 @@ cc_output_ser_seqence(OIDL_C_Info *ci,
 	fprintf(ci->fh, "  return ok;\n"
 			"}\n\n");
 
-	fprintf(ci->fh, "CORBA_boolean %s_deserialize(CDR_Codec *codec, %s *seq)\n", id, id);
+	fprintf(ci->fh, "CORBA_boolean %s_deserialize(FORB_CDR_Codec *codec, %s *seq)\n", id, id);
 	fprintf(ci->fh, "{\n"
 			"  int i;\n"
 			"  CORBA_boolean ok;\n"
@@ -225,7 +225,7 @@ cc_output_ser_typedef_array(OIDL_C_Info *ci,
 	for(cur = IDL_TYPE_DCL(tree).dcls; cur; cur = IDL_LIST(cur).next) {
 		if (IDL_NODE_TYPE(IDL_LIST(cur).data) == IDLN_TYPE_ARRAY) {
 			id = IDL_ns_ident_to_qstring(IDL_IDENT_TO_NS(IDL_TYPE_ARRAY(IDL_LIST(cur).data).ident), "_", 0);
-			fprintf(ci->fh, "CORBA_boolean %s_serialize(CDR_Codec *codec, const %s array)\n", id, id);
+			fprintf(ci->fh, "CORBA_boolean %s_serialize(FORB_CDR_Codec *codec, const %s array)\n", id, id);
 			fprintf(ci->fh, "{\n");
 			forb_cbe_write_ser_var(
 				ci->fh,
@@ -239,7 +239,7 @@ cc_output_ser_typedef_array(OIDL_C_Info *ci,
 				"  return CORBA_FALSE;\n"
 				"}\n\n");
 
-			fprintf(ci->fh, "CORBA_boolean %s_deserialize(CDR_Codec *codec, %s array)\n", id, id);
+			fprintf(ci->fh, "CORBA_boolean %s_deserialize(FORB_CDR_Codec *codec, %s array)\n", id, id);
 			fprintf(ci->fh, "{\n");
 			forb_cbe_write_ser_var(
 				ci->fh,
diff --git a/forb-idl/forb-idl-c-headers.c b/forb-idl/forb-idl-c-headers.c
index 78b4549..061bd48 100644
--- a/forb-idl/forb-idl-c-headers.c
+++ b/forb-idl/forb-idl-c-headers.c
@@ -583,8 +583,8 @@ ch_output_type_dcl(IDL_tree tree, OIDL_Run_Info *rinfo, OIDL_C_Info *ci)
 					 IDL_INTEGER (IDL_LIST (sub).data).value);
 
 			fprintf (ci->fh, ";\n");
-			fprintf(ci->fh, "CORBA_boolean %s_serialize(CDR_Codec *codec, const %s array);\n", ctmp, ctmp);
-			fprintf(ci->fh, "CORBA_boolean %s_deserialize(CDR_Codec *codec, %s array);\n", ctmp, ctmp);
+			fprintf(ci->fh, "CORBA_boolean %s_serialize(FORB_CDR_Codec *codec, const %s array);\n", ctmp, ctmp);
+			fprintf(ci->fh, "CORBA_boolean %s_deserialize(FORB_CDR_Codec *codec, %s array);\n", ctmp, ctmp);
 /* 			fprintf (ci->fh, "typedef "); */
 /* 			forb_cbe_write_typespec (ci->fh, IDL_TYPE_DCL (tree).type_spec); */
 /* 			fprintf (ci->fh, " %s_slice", ctmp); */
@@ -647,8 +647,8 @@ ch_output_type_struct(IDL_tree tree, OIDL_Run_Info *rinfo, OIDL_C_Info *ci)
     fprintf(ci->fh, "int dummy;\n");
   fprintf(ci->fh, "};\n");
 
-  fprintf(ci->fh, "CORBA_boolean %s_serialize(CDR_Codec *codec, const %s *ptr);\n", id, id);
-  fprintf(ci->fh, "CORBA_boolean %s_deserialize(CDR_Codec *codec, %s *ptr);\n", id, id);
+  fprintf(ci->fh, "CORBA_boolean %s_serialize(FORB_CDR_Codec *codec, const %s *ptr);\n", id, id);
+  fprintf(ci->fh, "CORBA_boolean %s_deserialize(FORB_CDR_Codec *codec, %s *ptr);\n", id, id);
 
   /* ch_type_alloc_and_tc(tree, rinfo, ci, TRUE); */
 
@@ -848,8 +848,8 @@ ch_prep_sequence(IDL_tree tree, OIDL_Run_Info *rinfo, OIDL_C_Info *ci)
       forb_cbe_write_typespec(ci->fh, tree);
       fprintf(ci->fh, ";\n#endif\n");
 
-      fprintf(ci->fh, "CORBA_boolean %s_serialize(CDR_Codec *codec, const %s *ptr);\n", fullname, fullname);
-      fprintf(ci->fh, "CORBA_boolean %s_deserialize(CDR_Codec *codec, %s *ptr);\n", fullname, fullname);
+      fprintf(ci->fh, "CORBA_boolean %s_serialize(FORB_CDR_Codec *codec, const %s *ptr);\n", fullname, fullname);
+      fprintf(ci->fh, "CORBA_boolean %s_deserialize(FORB_CDR_Codec *codec, %s *ptr);\n", fullname, fullname);
       /* ch_type_alloc_and_tc(tree, rinfo, ci, TRUE); */
 
 /*       tc = forb_cbe_get_typecode_name (forb_cbe_get_typespec (tree)); */
@@ -1194,7 +1194,7 @@ ch_output_inherited_protos(IDL_tree curif, InheritedOutputInfo *ioi)
 /*   id = IDL_ns_ident_to_qstring(IDL_IDENT_TO_NS(IDL_OP_DCL(cur).ident), "_", 0); */
 
 /*   fprintf(ci->fh, "void _forb_skel_%s(" */
-/* 	  "CDR_Codec *codec, %s *obj", */
+/* 	  "FORB_CDR_Codec *codec, %s *obj", */
 /* 	  id, ifid); */
 /* /\*   forb_cbe_op_write_proto(ci->fh, cur, "_impl_", TRUE); *\/ */
 /*   fprintf(ci->fh, ");\n"); */
diff --git a/forb-idl/forb-idl-c-skels.c b/forb-idl/forb-idl-c-skels.c
index 096cdd9..12bd674 100644
--- a/forb-idl/forb-idl-c-skels.c
+++ b/forb-idl/forb-idl-c-skels.c
@@ -276,7 +276,7 @@ static void ck_output_op_skel(IDL_tree op, char *intf_id, OIDL_Run_Info *rinfo,
 	id = IDL_ns_ident_to_qstring(IDL_IDENT_TO_NS(IDL_OP_DCL(op).ident), "_", 0);
 	id_plain = IDL_IDENT(IDL_OP_DCL(op).ident).str;
 	fprintf(ci->fh, "static void\n"
-		"forb_skel_%s(CDR_Codec *cin, CDR_Codec *cout, %s _obj, struct forb_env *env)\n"
+		"forb_skel_%s(FORB_CDR_Codec *cin, FORB_CDR_Codec *cout, %s _obj, struct forb_env *env)\n"
 		"{\n",
 		id, intf_id);
 /* 	fprintf(ci->fh, "  if (_obj->interface != %s_interface) {\n", intf_id); */
diff --git a/src/cdr.c b/src/cdr.c
index 0bf15d4..3948a69 100644
--- a/src/cdr.c
+++ b/src/cdr.c
@@ -41,10 +41,10 @@
 #define ALIGN_ADDRESS(this, boundary) \
   ((void*)((( ((unsigned long)(this)) + (((unsigned long)(boundary)) -1)) & (~(((unsigned long)(boundary))-1)))))
 
-#define CDR_GROW_AMOUNT 128
+#define FORB_CDR_GROW_AMOUNT 128
 
 CORBA_boolean 
-CDR_buffer_init(CDR_Codec *codec, const unsigned int size, const unsigned int first)
+FORB_CDR_buffer_init(FORB_CDR_Codec *codec, const unsigned int size, const unsigned int first)
 {
 
 	if(codec->release_buffer) {
@@ -60,14 +60,14 @@ CDR_buffer_init(CDR_Codec *codec, const unsigned int size, const unsigned int fi
 	}
 	codec->buf_len=size;
         codec->wptr_max=size;
-	CDR_buffer_reset(codec, first);
+	FORB_CDR_buffer_reset(codec, first);
         codec->release_buffer=CORBA_TRUE;
 
 	return CORBA_TRUE;
 }
 
 CORBA_boolean 
-CDR_buffer_reset(CDR_Codec *codec, const unsigned int first)
+FORB_CDR_buffer_reset(FORB_CDR_Codec *codec, const unsigned int first)
 {
 	if (first > codec->buf_len) {
 		return CORBA_FALSE;
@@ -77,7 +77,7 @@ CDR_buffer_reset(CDR_Codec *codec, const unsigned int first)
 }
 
 CORBA_boolean 
-CDR_buffer_prepend(CDR_Codec *codec, const unsigned int len)
+FORB_CDR_buffer_prepend(FORB_CDR_Codec *codec, const unsigned int len)
 {
 	if (codec->rptr < len) {
 		return CORBA_FALSE;
@@ -91,13 +91,13 @@ CDR_buffer_prepend(CDR_Codec *codec, const unsigned int len)
 
 /*
 CORBA_boolean 
-CDR_buffer_grow(CDR_Codec *codec, const unsigned int growth)
+FORB_CDR_buffer_grow(FORB_CDR_Codec *codec, const unsigned int growth)
 {
 	unsigned int real_growth,quot;
 
 	if(codec->release_buffer) {
-                quot = growth / CDR_GROW_AMOUNT;
-		real_growth=CDR_GROW_AMOUNT * (quot+1);
+                quot = growth / FORB_CDR_GROW_AMOUNT;
+		real_growth=FORB_CDR_GROW_AMOUNT * (quot+1);
 		
 		codec->buffer=(CORBA_octet *)REALLOC(codec->buffer,
 						     codec->buf_len
@@ -108,7 +108,7 @@ CDR_buffer_grow(CDR_Codec *codec, const unsigned int growth)
 }
 */
 CORBA_boolean 
-CDR_buffer_puts(CDR_Codec *codec, const void *data, const unsigned int len)
+FORB_CDR_buffer_puts(FORB_CDR_Codec *codec, const void *data, const unsigned int len)
 {
 	if(codec->wptr+len > codec->wptr_max) {
 		return CORBA_FALSE; 
@@ -122,7 +122,7 @@ CDR_buffer_puts(CDR_Codec *codec, const void *data, const unsigned int len)
 }
 
 CORBA_boolean 
-CDR_buffer_gets(CDR_Codec *codec, void *dest, const unsigned int len)
+FORB_CDR_buffer_gets(FORB_CDR_Codec *codec, void *dest, const unsigned int len)
 {
 	if(codec->rptr+len > codec->buf_len) {
 		return CORBA_FALSE; 
@@ -135,7 +135,7 @@ CDR_buffer_gets(CDR_Codec *codec, void *dest, const unsigned int len)
 }
 
 CORBA_boolean 
-CDR_buffer_put(CDR_Codec *codec, void *datum)
+FORB_CDR_buffer_put(FORB_CDR_Codec *codec, void *datum)
 {
 	if(codec->wptr+1 > codec->wptr_max) {
 		return(CORBA_FALSE);
@@ -147,7 +147,7 @@ CDR_buffer_put(CDR_Codec *codec, void *datum)
 }
 
 CORBA_boolean 
-CDR_buffer_get(CDR_Codec *codec, void *dest)
+FORB_CDR_buffer_get(FORB_CDR_Codec *codec, void *dest)
 {
 	if(codec->rptr+1 > codec->buf_len) {
 		return(CORBA_FALSE);
@@ -157,17 +157,17 @@ CDR_buffer_get(CDR_Codec *codec, void *dest)
 	return CORBA_TRUE;
 }
 
-#define CDR_buffer_put2(codec, datum) CDR_buffer_putn(codec, datum, 2)
-#define CDR_buffer_put4(codec, datum) CDR_buffer_putn(codec, datum, 4)
-#define CDR_buffer_put8(codec, datum) CDR_buffer_putn(codec, datum, 8)
-#define CDR_buffer_put16(codec, datum) CDR_buffer_putn(codec, datum, 16)
-#define CDR_buffer_get2(codec, dest) CDR_buffer_getn(codec, dest, 2)
-#define CDR_buffer_get4(codec, dest) CDR_buffer_getn(codec, dest, 4)
-#define CDR_buffer_get8(codec, dest) CDR_buffer_getn(codec, dest, 8)
-#define CDR_buffer_get16(codec, dest) CDR_buffer_getn(codec, dest, 16)
+#define FORB_CDR_buffer_put2(codec, datum) FORB_CDR_buffer_putn(codec, datum, 2)
+#define FORB_CDR_buffer_put4(codec, datum) FORB_CDR_buffer_putn(codec, datum, 4)
+#define FORB_CDR_buffer_put8(codec, datum) FORB_CDR_buffer_putn(codec, datum, 8)
+#define FORB_CDR_buffer_put16(codec, datum) FORB_CDR_buffer_putn(codec, datum, 16)
+#define FORB_CDR_buffer_get2(codec, dest) FORB_CDR_buffer_getn(codec, dest, 2)
+#define FORB_CDR_buffer_get4(codec, dest) FORB_CDR_buffer_getn(codec, dest, 4)
+#define FORB_CDR_buffer_get8(codec, dest) FORB_CDR_buffer_getn(codec, dest, 8)
+#define FORB_CDR_buffer_get16(codec, dest) FORB_CDR_buffer_getn(codec, dest, 16)
 
 static CORBA_boolean
-CDR_buffer_getn(CDR_Codec *codec, void *dest, int bsize)
+FORB_CDR_buffer_getn(FORB_CDR_Codec *codec, void *dest, int bsize)
 {
 	codec->rptr = (unsigned long)ALIGN_ADDRESS(codec->rptr, bsize);
 	if(codec->host_endian==codec->data_endian)
@@ -180,7 +180,7 @@ CDR_buffer_getn(CDR_Codec *codec, void *dest, int bsize)
 }
 
 static CORBA_boolean
-CDR_buffer_putn(CDR_Codec *codec, void *datum, int bsize)
+FORB_CDR_buffer_putn(FORB_CDR_Codec *codec, void *datum, int bsize)
 {
         unsigned long forward,i;
 	
@@ -204,7 +204,7 @@ CDR_buffer_putn(CDR_Codec *codec, void *datum, int bsize)
 	return CORBA_TRUE;
 }
 
-CORBA_boolean CDR_put_align(CDR_Codec *codec, unsigned bsize)
+CORBA_boolean FORB_CDR_put_align(FORB_CDR_Codec *codec, unsigned bsize)
 {
         unsigned long forward,i;
 	
@@ -222,181 +222,181 @@ CORBA_boolean CDR_put_align(CDR_Codec *codec, unsigned bsize)
 	return CORBA_TRUE;
 }
 
-CORBA_boolean CDR_get_align(CDR_Codec *codec, unsigned bsize)
+CORBA_boolean FORB_CDR_get_align(FORB_CDR_Codec *codec, unsigned bsize)
 {
 	codec->rptr = (unsigned long)ALIGN_ADDRESS(codec->rptr, bsize);
 	return codec->rptr <= codec->wptr_max;
 }
 
-#define CDR_swap2(d,s) forb_byteswap((d), (s), 2)
-#define CDR_swap4(d,s) forb_byteswap((d), (s), 4)
-#define CDR_swap8(d,s) forb_byteswap((d), (s), 8)
-#define CDR_swap16(d,s) forb_byteswap((d), (s), 16)
+#define FORB_CDR_swap2(d,s) forb_byteswap((d), (s), 2)
+#define FORB_CDR_swap4(d,s) forb_byteswap((d), (s), 4)
+#define FORB_CDR_swap8(d,s) forb_byteswap((d), (s), 8)
+#define FORB_CDR_swap16(d,s) forb_byteswap((d), (s), 16)
 
 inline CORBA_boolean 
-CDR_put_short(CDR_Codec *codec, CORBA_short s)
+FORB_CDR_put_short(FORB_CDR_Codec *codec, CORBA_short s)
 {
-	return CDR_buffer_put2(codec, &s);
+	return FORB_CDR_buffer_put2(codec, &s);
 }
 
 inline CORBA_boolean 
-CDR_get_short(CDR_Codec *codec, CORBA_short *s)
+FORB_CDR_get_short(FORB_CDR_Codec *codec, CORBA_short *s)
 {
-	return CDR_buffer_get2(codec, s);
+	return FORB_CDR_buffer_get2(codec, s);
 }
 
 inline CORBA_boolean 
-CDR_put_ushort(CDR_Codec *codec, CORBA_unsigned_short us)
+FORB_CDR_put_ushort(FORB_CDR_Codec *codec, CORBA_unsigned_short us)
 {
-	return CDR_buffer_put2(codec, &us);
+	return FORB_CDR_buffer_put2(codec, &us);
 }
 
 inline CORBA_boolean 
-CDR_get_ushort(CDR_Codec *codec, CORBA_unsigned_short *us)
+FORB_CDR_get_ushort(FORB_CDR_Codec *codec, CORBA_unsigned_short *us)
 {
-	return CDR_buffer_get2(codec, us);
+	return FORB_CDR_buffer_get2(codec, us);
 }
 
 inline CORBA_boolean 
-CDR_put_long(CDR_Codec *codec, CORBA_long l)
+FORB_CDR_put_long(FORB_CDR_Codec *codec, CORBA_long l)
 {
-	return CDR_buffer_put4(codec, &l);
+	return FORB_CDR_buffer_put4(codec, &l);
 }
 
 inline CORBA_boolean 
-CDR_get_long(CDR_Codec *codec, CORBA_long *l)
+FORB_CDR_get_long(FORB_CDR_Codec *codec, CORBA_long *l)
 {
-	return CDR_buffer_get4(codec, l);
+	return FORB_CDR_buffer_get4(codec, l);
 }
 
 inline CORBA_boolean 
-CDR_put_ulong(CDR_Codec *codec, CORBA_unsigned_long ul)
+FORB_CDR_put_ulong(FORB_CDR_Codec *codec, CORBA_unsigned_long ul)
 {
-	return CDR_buffer_put4(codec, &ul);
+	return FORB_CDR_buffer_put4(codec, &ul);
 }
 
 inline CORBA_boolean 
-CDR_get_ulong(CDR_Codec *codec, CORBA_unsigned_long *ul)
+FORB_CDR_get_ulong(FORB_CDR_Codec *codec, CORBA_unsigned_long *ul)
 {
-	return CDR_buffer_get4(codec, ul);
+	return FORB_CDR_buffer_get4(codec, ul);
 }
 
 //#ifdef HAVE_CORBA_LONG_LONG
 inline CORBA_boolean 
-CDR_get_long_long(CDR_Codec *codec, CORBA_long_long *ul)
+FORB_CDR_get_long_long(FORB_CDR_Codec *codec, CORBA_long_long *ul)
 {
-	return CDR_buffer_get8(codec, ul);
+	return FORB_CDR_buffer_get8(codec, ul);
 }
 
 inline CORBA_boolean 
-CDR_put_long_long(CDR_Codec *codec, CORBA_long_long ll)
+FORB_CDR_put_long_long(FORB_CDR_Codec *codec, CORBA_long_long ll)
 {
-	return CDR_buffer_put8(codec, &ll);
+	return FORB_CDR_buffer_put8(codec, &ll);
 }
 
 inline CORBA_boolean 
-CDR_put_ulong_long(CDR_Codec *codec, CORBA_unsigned_long_long ll)
+FORB_CDR_put_ulong_long(FORB_CDR_Codec *codec, CORBA_unsigned_long_long ll)
 {
-	return CDR_buffer_put8(codec, &ll);
+	return FORB_CDR_buffer_put8(codec, &ll);
 }
 
 inline CORBA_boolean 
-CDR_get_ulong_long(CDR_Codec *codec, CORBA_unsigned_long_long *ull)
+FORB_CDR_get_ulong_long(FORB_CDR_Codec *codec, CORBA_unsigned_long_long *ull)
 {
-	return CDR_buffer_get8(codec, ull);
+	return FORB_CDR_buffer_get8(codec, ull);
 }
 //#endif /* HAVE_CORBA_LONG_LONG */
 
 inline CORBA_boolean 
-CDR_put_float(CDR_Codec *codec, CORBA_float f)
+FORB_CDR_put_float(FORB_CDR_Codec *codec, CORBA_float f)
 {
-	return CDR_buffer_put4(codec, &f);
+	return FORB_CDR_buffer_put4(codec, &f);
 }
 
 inline CORBA_boolean 
-CDR_get_float(CDR_Codec *codec, CORBA_float *f)
+FORB_CDR_get_float(FORB_CDR_Codec *codec, CORBA_float *f)
 {
-	return CDR_buffer_get4(codec, f);
+	return FORB_CDR_buffer_get4(codec, f);
 }
 
 inline CORBA_boolean 
-CDR_put_double(CDR_Codec *codec, CORBA_double d)
+FORB_CDR_put_double(FORB_CDR_Codec *codec, CORBA_double d)
 {
-	return CDR_buffer_put8(codec, &d);
+	return FORB_CDR_buffer_put8(codec, &d);
 }
 
 inline CORBA_boolean 
-CDR_get_double(CDR_Codec *codec, CORBA_double *d)
+FORB_CDR_get_double(FORB_CDR_Codec *codec, CORBA_double *d)
 {
-	return CDR_buffer_get8(codec, d);
+	return FORB_CDR_buffer_get8(codec, d);
 }
 
 inline CORBA_boolean 
-CDR_put_long_double(CDR_Codec *codec, CORBA_long_double ld)
+FORB_CDR_put_long_double(FORB_CDR_Codec *codec, CORBA_long_double ld)
 {
-	return CDR_buffer_put16(codec, &ld);
+	return FORB_CDR_buffer_put16(codec, &ld);
 }
 
 inline CORBA_boolean 
-CDR_put_octet(CDR_Codec *codec, CORBA_octet datum)
+FORB_CDR_put_octet(FORB_CDR_Codec *codec, CORBA_octet datum)
 {
-	return CDR_buffer_put(codec, &datum);
+	return FORB_CDR_buffer_put(codec, &datum);
 }
 
 inline CORBA_boolean 
-CDR_get_octet(CDR_Codec *codec, CORBA_octet *datum)
+FORB_CDR_get_octet(FORB_CDR_Codec *codec, CORBA_octet *datum)
 {
-	return(CDR_buffer_get(codec, datum));
+	return(FORB_CDR_buffer_get(codec, datum));
 }
 
 inline CORBA_boolean 
-CDR_put_octets(CDR_Codec *codec, void *data, unsigned long len)
+FORB_CDR_put_octets(FORB_CDR_Codec *codec, void *data, unsigned long len)
 {
-	return CDR_buffer_puts(codec, data, len);
+	return FORB_CDR_buffer_puts(codec, data, len);
 }
 
 inline CORBA_boolean 
-CDR_put_char(CDR_Codec *codec, CORBA_char c)
+FORB_CDR_put_char(FORB_CDR_Codec *codec, CORBA_char c)
 {
-	return CDR_buffer_put(codec, &c);
+	return FORB_CDR_buffer_put(codec, &c);
 }
 
 inline CORBA_boolean 
-CDR_get_char(CDR_Codec *codec, CORBA_char *c)
+FORB_CDR_get_char(FORB_CDR_Codec *codec, CORBA_char *c)
 {
-	return CDR_buffer_get(codec, c);
+	return FORB_CDR_buffer_get(codec, c);
 }
 
 inline CORBA_boolean 
-CDR_put_boolean(CDR_Codec *codec, CORBA_boolean datum)
+FORB_CDR_put_boolean(FORB_CDR_Codec *codec, CORBA_boolean datum)
 {
 	datum = datum&&1;
-	return CDR_buffer_put(codec, &datum);
+	return FORB_CDR_buffer_put(codec, &datum);
 }
 
 inline CORBA_boolean 
-CDR_get_boolean(CDR_Codec *codec, CORBA_boolean *b)
+FORB_CDR_get_boolean(FORB_CDR_Codec *codec, CORBA_boolean *b)
 {
-	return CDR_buffer_get(codec, b);
+	return FORB_CDR_buffer_get(codec, b);
 }
 
 CORBA_boolean 
-CDR_put_string(CDR_Codec *codec, const CORBA_char *str)
+FORB_CDR_put_string(FORB_CDR_Codec *codec, const CORBA_char *str)
 {
 	unsigned int len;
 
 	len=strlen(str)+1;
 
-	if (CDR_put_ulong(codec, len)==CORBA_FALSE) return -1;
-	return CDR_buffer_puts(codec, str, len);
+	if (FORB_CDR_put_ulong(codec, len)==CORBA_FALSE) return -1;
+	return FORB_CDR_buffer_puts(codec, str, len);
 }
 
 CORBA_boolean 
-CDR_get_string_static(CDR_Codec *codec,CORBA_char **str)
+FORB_CDR_get_string_static(FORB_CDR_Codec *codec,CORBA_char **str)
 {
 	CORBA_unsigned_long len;
 
-	if(CDR_get_ulong(codec, (CORBA_unsigned_long *)&len)==CORBA_FALSE)
+	if(FORB_CDR_get_ulong(codec, (CORBA_unsigned_long *)&len)==CORBA_FALSE)
 		return CORBA_FALSE;
 
 	if((codec->rptr + len) > codec->buf_len)
@@ -410,11 +410,11 @@ CDR_get_string_static(CDR_Codec *codec,CORBA_char **str)
 }
 
 CORBA_boolean 
-CDR_get_string(CDR_Codec *codec, CORBA_char **str)
+FORB_CDR_get_string(FORB_CDR_Codec *codec, CORBA_char **str)
 {
 	CORBA_unsigned_long len;
 
-	if(CDR_get_ulong(codec, (CORBA_unsigned_long *)&len)==CORBA_FALSE)
+	if(FORB_CDR_get_ulong(codec, (CORBA_unsigned_long *)&len)==CORBA_FALSE)
 		return(CORBA_FALSE);
 
 	if(len==0)
@@ -422,7 +422,7 @@ CDR_get_string(CDR_Codec *codec, CORBA_char **str)
 
 	*str=forb_malloc(len);
 
-	if(CDR_buffer_gets(codec, *str, len)==CORBA_FALSE) {
+	if(FORB_CDR_buffer_gets(codec, *str, len)==CORBA_FALSE) {
 		forb_free(*str);
 		return(CORBA_FALSE);
 	}
@@ -435,17 +435,17 @@ CDR_get_string(CDR_Codec *codec, CORBA_char **str)
 }
 
 CORBA_boolean 
-CDR_get_string_buff(CDR_Codec *codec, CORBA_char *str)
+FORB_CDR_get_string_buff(FORB_CDR_Codec *codec, CORBA_char *str)
 {
 	CORBA_unsigned_long len;
 
-	if(CDR_get_ulong(codec, (CORBA_unsigned_long *)&len)==CORBA_FALSE)
+	if(FORB_CDR_get_ulong(codec, (CORBA_unsigned_long *)&len)==CORBA_FALSE)
 		return(CORBA_FALSE);
 
 	if(len==0)
 		return(CORBA_FALSE);
 
-	if(CDR_buffer_gets(codec, str, len)==CORBA_FALSE) {
+	if(FORB_CDR_buffer_gets(codec, str, len)==CORBA_FALSE) {
 		return(CORBA_FALSE);
 	}
 
@@ -457,15 +457,15 @@ CDR_get_string_buff(CDR_Codec *codec, CORBA_char *str)
 }
 
 CORBA_boolean 
-CDR_get_seq_begin(CDR_Codec *codec, CORBA_unsigned_long *ul)
+FORB_CDR_get_seq_begin(FORB_CDR_Codec *codec, CORBA_unsigned_long *ul)
 {
-	return(CDR_get_ulong(codec, (CORBA_unsigned_long *)ul));
+	return(FORB_CDR_get_ulong(codec, (CORBA_unsigned_long *)ul));
 }
 
-CDR_Codec *
-CDR_codec_init_static(CDR_Codec *codec, forb_orb orb)
+FORB_CDR_Codec *
+FORB_CDR_codec_init_static(FORB_CDR_Codec *codec, forb_orb orb)
 {
-	memset(codec, 0, sizeof(CDR_Codec));
+	memset(codec, 0, sizeof(FORB_CDR_Codec));
 
 	codec->host_endian = FLAG_ENDIANNESS;
 	codec->data_endian = FLAG_ENDIANNESS;
@@ -474,21 +474,21 @@ CDR_codec_init_static(CDR_Codec *codec, forb_orb orb)
 	return codec;
 }
 
-CDR_Codec *
-CDR_codec_init(forb_orb orb)
+FORB_CDR_Codec *
+FORB_CDR_codec_init(forb_orb orb)
 {
-	CDR_Codec *c;
+	FORB_CDR_Codec *c;
 
-	c=forb_malloc(sizeof(CDR_Codec));
+	c=forb_malloc(sizeof(FORB_CDR_Codec));
 	if (c) {
-		CDR_codec_init_static(c, orb);
+		FORB_CDR_codec_init_static(c, orb);
 	}
 
 	return(c);
 }
 
 void 
-CDR_codec_release_buffer(CDR_Codec *codec)
+FORB_CDR_codec_release_buffer(FORB_CDR_Codec *codec)
 {
 	if(codec->release_buffer) {
 		forb_free(codec->buffer);
@@ -498,8 +498,8 @@ CDR_codec_release_buffer(CDR_Codec *codec)
 
 
 void 
-CDR_codec_free(CDR_Codec *codec)
+FORB_CDR_codec_free(FORB_CDR_Codec *codec)
 {
-	CDR_codec_release_buffer(codec);
+	FORB_CDR_codec_release_buffer(codec);
 	forb_free(codec);
 }
diff --git a/src/cdr.h b/src/cdr.h
index c947c07..8eaa1d3 100644
--- a/src/cdr.h
+++ b/src/cdr.h
@@ -40,8 +40,8 @@
  * 
  * 
  */
-#ifndef _ORTE_CDR_H_
-#define _ORTE_CDR_H_
+#ifndef _FORB_CDR_H_
+#define _FORB_CDR_H_
 
 #include "basic_types.h"
 #include "cdr_codec.h"
@@ -67,10 +67,11 @@
 typedef enum {
 	BigEndian=0,
 	LittleEndian=1
-} CDR_Endianness;
+} FORB_CDR_Endianness;
 
 /**
- * struct CDR_Codec - used for serialization/deserialization
+ * Codec used for serialization/deserialization
+ * 
  * @host_endian: 
  * @data_endian: 
  * @buffer: buffer for data
@@ -83,11 +84,11 @@ typedef enum {
  * @release_buffer: use CORBA_TRUE if is necessary to free buffer memory after destruction of structure
  * @orb: Needed for deserialization of object references.
  *
- * Struct @CDR_Codec is used by serialization and deserialization functions.
+ * Struct @FORB_CDR_Codec is used by serialization and deserialization functions.
  */
-struct CDR_Codec {
-	CDR_Endianness host_endian;
-	CDR_Endianness data_endian;
+struct FORB_CDR_Codec {
+	FORB_CDR_Endianness host_endian;
+	FORB_CDR_Endianness data_endian;
 	CORBA_octet *buffer;
 	unsigned int buf_len;
 	unsigned int wptr_max;
@@ -102,111 +103,88 @@ struct CDR_Codec {
 #define HEXDIGIT(c) (isdigit((guchar)(c))?(c)-'0':tolower((guchar)(c))-'a'+10)
 #define HEXOCTET(a,b) ((HEXDIGIT((a)) << 4) | HEXDIGIT((b)))
 
-static inline CORBA_long CDR_data_size(CDR_Codec *codec)
+static inline CORBA_long FORB_CDR_data_size(FORB_CDR_Codec *codec)
 {
 	return codec->wptr_last - codec->rptr;
 }
 
-extern CORBA_boolean CDR_buffer_init(CDR_Codec *codec, const unsigned int size, const unsigned int first);
-extern CORBA_boolean CDR_buffer_reset(CDR_Codec *codec, const unsigned int first);
-extern CORBA_boolean CDR_buffer_prepend(CDR_Codec *codec, const unsigned int len);
-extern CDR_Codec *CDR_codec_init(forb_orb orb);
-extern CDR_Codec *CDR_codec_init_static(CDR_Codec *codec, forb_orb orb);
-extern void CDR_codec_release_buffer(CDR_Codec *codec);
-extern void CDR_codec_free(CDR_Codec *);
+extern CORBA_boolean FORB_CDR_buffer_init(FORB_CDR_Codec *codec, const unsigned int size, const unsigned int first);
+extern CORBA_boolean FORB_CDR_buffer_reset(FORB_CDR_Codec *codec, const unsigned int first);
+extern CORBA_boolean FORB_CDR_buffer_prepend(FORB_CDR_Codec *codec, const unsigned int len);
+extern FORB_CDR_Codec *FORB_CDR_codec_init(forb_orb orb);
+extern FORB_CDR_Codec *FORB_CDR_codec_init_static(FORB_CDR_Codec *codec, forb_orb orb);
+extern void FORB_CDR_codec_release_buffer(FORB_CDR_Codec *codec);
+extern void FORB_CDR_codec_free(FORB_CDR_Codec *);
 
-extern CORBA_boolean CDR_buffer_puts(CDR_Codec *codec, const void *data, const unsigned int len);
-extern CORBA_boolean CDR_buffer_gets(CDR_Codec *codec, void *dest, const unsigned int len);
+extern CORBA_boolean FORB_CDR_buffer_puts(FORB_CDR_Codec *codec, const void *data, const unsigned int len);
+extern CORBA_boolean FORB_CDR_buffer_gets(FORB_CDR_Codec *codec, void *dest, const unsigned int len);
 
-extern CORBA_boolean CDR_put_short(CDR_Codec *codec, CORBA_short s);
-extern CORBA_boolean CDR_put_ushort(CDR_Codec *codec, CORBA_unsigned_short us);
-extern CORBA_boolean CDR_put_long(CDR_Codec *codec, CORBA_long l);
-extern CORBA_boolean CDR_put_ulong(CDR_Codec *codec, CORBA_unsigned_long ul);
+extern CORBA_boolean FORB_CDR_put_short(FORB_CDR_Codec *codec, CORBA_short s);
+extern CORBA_boolean FORB_CDR_put_ushort(FORB_CDR_Codec *codec, CORBA_unsigned_short us);
+extern CORBA_boolean FORB_CDR_put_long(FORB_CDR_Codec *codec, CORBA_long l);
+extern CORBA_boolean FORB_CDR_put_ulong(FORB_CDR_Codec *codec, CORBA_unsigned_long ul);
 /* #ifdef HAVE_CORBA_LONG_LONG */
-extern CORBA_boolean CDR_put_long_long(CDR_Codec *codec, CORBA_long_long ll);
-extern CORBA_boolean CDR_put_ulong_long(CDR_Codec *codec, CORBA_unsigned_long_long ull);
-extern CORBA_boolean CDR_get_ulong_long(CDR_Codec *codec, CORBA_unsigned_long_long *ul);
-extern CORBA_boolean CDR_get_long_long(CDR_Codec *codec, CORBA_long_long *ul);
+extern CORBA_boolean FORB_CDR_put_long_long(FORB_CDR_Codec *codec, CORBA_long_long ll);
+extern CORBA_boolean FORB_CDR_put_ulong_long(FORB_CDR_Codec *codec, CORBA_unsigned_long_long ull);
+extern CORBA_boolean FORB_CDR_get_ulong_long(FORB_CDR_Codec *codec, CORBA_unsigned_long_long *ul);
+extern CORBA_boolean FORB_CDR_get_long_long(FORB_CDR_Codec *codec, CORBA_long_long *ul);
 /* #endif */
-extern CORBA_boolean CDR_put_float(CDR_Codec *codec, CORBA_float f);
-extern CORBA_boolean CDR_put_double(CDR_Codec *codec, CORBA_double d);
-extern CORBA_boolean CDR_put_long_double(CDR_Codec *codec, CORBA_long_double ld);
-extern CORBA_boolean CDR_put_octet(CDR_Codec *codec, CORBA_octet datum);
-extern CORBA_boolean CDR_put_octets(CDR_Codec *codec, void *data, unsigned long len);
-extern CORBA_boolean CDR_put_char(CDR_Codec *codec, CORBA_char c);
-extern CORBA_boolean CDR_put_boolean(CDR_Codec *codec, CORBA_boolean datum);
-extern CORBA_boolean CDR_put_string(CDR_Codec *codec, const CORBA_char *str);
-extern CORBA_boolean CDR_buffer_gets(CDR_Codec *codec, void *dest, const unsigned int len);
-extern CORBA_boolean CDR_get_short(CDR_Codec *codec, CORBA_short *us);
-extern CORBA_boolean CDR_get_ushort(CDR_Codec *codec, CORBA_unsigned_short *us);
-extern CORBA_boolean CDR_get_long(CDR_Codec *codec, CORBA_long *l);
-extern CORBA_boolean CDR_get_ulong(CDR_Codec *codec, CORBA_unsigned_long *ul);
-extern CORBA_boolean CDR_get_octet(CDR_Codec *codec, CORBA_octet *datum);
-extern CORBA_boolean CDR_get_boolean(CDR_Codec *codec, CORBA_boolean *b);
-extern CORBA_boolean CDR_get_char(CDR_Codec *codec, CORBA_char *c);
-extern CORBA_boolean CDR_get_string(CDR_Codec *codec, CORBA_char **str);
-extern CORBA_boolean CDR_get_string_buff(CDR_Codec *codec, CORBA_char *str);
-extern CORBA_boolean CDR_get_string_static(CDR_Codec *codec, CORBA_char **str);
-extern CORBA_boolean CDR_get_seq_begin(CDR_Codec *codec, CORBA_unsigned_long *ul);
-extern CORBA_boolean CDR_get_float(CDR_Codec *codec, CORBA_float *f);
-extern CORBA_boolean CDR_get_double(CDR_Codec *codec, CORBA_double *d);
+extern CORBA_boolean FORB_CDR_put_float(FORB_CDR_Codec *codec, CORBA_float f);
+extern CORBA_boolean FORB_CDR_put_double(FORB_CDR_Codec *codec, CORBA_double d);
+extern CORBA_boolean FORB_CDR_put_long_double(FORB_CDR_Codec *codec, CORBA_long_double ld);
+extern CORBA_boolean FORB_CDR_put_octet(FORB_CDR_Codec *codec, CORBA_octet datum);
+extern CORBA_boolean FORB_CDR_put_octets(FORB_CDR_Codec *codec, void *data, unsigned long len);
+extern CORBA_boolean FORB_CDR_put_char(FORB_CDR_Codec *codec, CORBA_char c);
+extern CORBA_boolean FORB_CDR_put_boolean(FORB_CDR_Codec *codec, CORBA_boolean datum);
+extern CORBA_boolean FORB_CDR_put_string(FORB_CDR_Codec *codec, const CORBA_char *str);
+extern CORBA_boolean FORB_CDR_buffer_gets(FORB_CDR_Codec *codec, void *dest, const unsigned int len);
+extern CORBA_boolean FORB_CDR_get_short(FORB_CDR_Codec *codec, CORBA_short *us);
+extern CORBA_boolean FORB_CDR_get_ushort(FORB_CDR_Codec *codec, CORBA_unsigned_short *us);
+extern CORBA_boolean FORB_CDR_get_long(FORB_CDR_Codec *codec, CORBA_long *l);
+extern CORBA_boolean FORB_CDR_get_ulong(FORB_CDR_Codec *codec, CORBA_unsigned_long *ul);
+extern CORBA_boolean FORB_CDR_get_octet(FORB_CDR_Codec *codec, CORBA_octet *datum);
+extern CORBA_boolean FORB_CDR_get_boolean(FORB_CDR_Codec *codec, CORBA_boolean *b);
+extern CORBA_boolean FORB_CDR_get_char(FORB_CDR_Codec *codec, CORBA_char *c);
+extern CORBA_boolean FORB_CDR_get_string(FORB_CDR_Codec *codec, CORBA_char **str);
+extern CORBA_boolean FORB_CDR_get_string_buff(FORB_CDR_Codec *codec, CORBA_char *str);
+extern CORBA_boolean FORB_CDR_get_string_static(FORB_CDR_Codec *codec, CORBA_char **str);
+extern CORBA_boolean FORB_CDR_get_seq_begin(FORB_CDR_Codec *codec, CORBA_unsigned_long *ul);
+extern CORBA_boolean FORB_CDR_get_float(FORB_CDR_Codec *codec, CORBA_float *f);
+extern CORBA_boolean FORB_CDR_get_double(FORB_CDR_Codec *codec, CORBA_double *d);
 
-extern CORBA_boolean CDR_put_align(CDR_Codec *codec, unsigned bsize);
-extern CORBA_boolean CDR_get_align(CDR_Codec *codec, unsigned bsize);
+extern CORBA_boolean FORB_CDR_put_align(FORB_CDR_Codec *codec, unsigned bsize);
+extern CORBA_boolean FORB_CDR_get_align(FORB_CDR_Codec *codec, unsigned bsize);
 
 
 /* serialization functions */
-#define CORBA_short_serialize(x,y)             CDR_put_short((x),*(y))
-#define CORBA_long_serialize(x,y)              CDR_put_long((x),*(y))
-#define CORBA_long_long_serialize(x,y)         CDR_put_long_long((x),*(y))
-#define CORBA_unsigned_short_serialize(x,y)    CDR_put_ushort((x),*(y))
-#define CORBA_unsigned_long_serialize(x,y)     CDR_put_ulong((x),*(y))
-#define CORBA_unsigned_long_long_serialize(x,y) CDR_put_ulong_long((x),*(y))
-#define CORBA_float_serialize(x,y)             CDR_put_float((x),*(y))
-#define CORBA_double_serialize(x,y)            CDR_put_double((x),*(y))
-#define CORBA_char_serialize(x,y)              CDR_put_char((x),*(y))
-#define CORBA_boolean_serialize(x,y)           CDR_put_boolean((x),*(y))
-#define CORBA_octet_serialize(x,y)             CDR_put_octet((x),*(y))
-#define CORBA_long_double_serialize(x,y)       CDR_put_long_double((x),*(y))
-#define CORBA_string_serialize(x,y)            CDR_put_string((x),*(y))
+#define CORBA_short_serialize(x,y)             FORB_CDR_put_short((x),*(y))
+#define CORBA_long_serialize(x,y)              FORB_CDR_put_long((x),*(y))
+#define CORBA_long_long_serialize(x,y)         FORB_CDR_put_long_long((x),*(y))
+#define CORBA_unsigned_short_serialize(x,y)    FORB_CDR_put_ushort((x),*(y))
+#define CORBA_unsigned_long_serialize(x,y)     FORB_CDR_put_ulong((x),*(y))
+#define CORBA_unsigned_long_long_serialize(x,y) FORB_CDR_put_ulong_long((x),*(y))
+#define CORBA_float_serialize(x,y)             FORB_CDR_put_float((x),*(y))
+#define CORBA_double_serialize(x,y)            FORB_CDR_put_double((x),*(y))
+#define CORBA_char_serialize(x,y)              FORB_CDR_put_char((x),*(y))
+#define CORBA_boolean_serialize(x,y)           FORB_CDR_put_boolean((x),*(y))
+#define CORBA_octet_serialize(x,y)             FORB_CDR_put_octet((x),*(y))
+#define CORBA_long_double_serialize(x,y)       FORB_CDR_put_long_double((x),*(y))
+#define CORBA_string_serialize(x,y)            FORB_CDR_put_string((x),*(y))
 
 /* deserialization functions */
-#define CORBA_short_deserialize(x,y)           CDR_get_short((x),(y))
-#define CORBA_long_deserialize(x,y)            CDR_get_long((x),(y))
-#define CORBA_long_long_deserialize(x,y)       CDR_get_long_long((x),(y))
-#define CORBA_unsigned_short_deserialize(x,y)  CDR_get_ushort((x),(y))
-#define CORBA_unsigned_long_deserialize(x,y)   CDR_get_ulong((x),(y))
-#define CORBA_unsigned_long_long_deserialize(x,y) CDR_get_ulong_long((x),(y))
-#define CORBA_float_deserialize(x,y)           CDR_get_float((x),(y))
-#define CORBA_double_deserialize(x,y)          CDR_get_double((x),(y))
-#define CORBA_char_deserialize(x,y)            CDR_get_char((x),(y))
-#define CORBA_boolean_deserialize(x,y)         CDR_get_boolean((x),(y))
-#define CORBA_octet_deserialize(x,y)           CDR_get_octet((x),(y))
-#define CORBA_long_double_deserialize(x,y)     CDR_get_long_double((x),(y))
-#define CORBA_string_deserialize(x,y)          CDR_get_string((x),(y))
+#define CORBA_short_deserialize(x,y)           FORB_CDR_get_short((x),(y))
+#define CORBA_long_deserialize(x,y)            FORB_CDR_get_long((x),(y))
+#define CORBA_long_long_deserialize(x,y)       FORB_CDR_get_long_long((x),(y))
+#define CORBA_unsigned_short_deserialize(x,y)  FORB_CDR_get_ushort((x),(y))
+#define CORBA_unsigned_long_deserialize(x,y)   FORB_CDR_get_ulong((x),(y))
+#define CORBA_unsigned_long_long_deserialize(x,y) FORB_CDR_get_ulong_long((x),(y))
+#define CORBA_float_deserialize(x,y)           FORB_CDR_get_float((x),(y))
+#define CORBA_double_deserialize(x,y)          FORB_CDR_get_double((x),(y))
+#define CORBA_char_deserialize(x,y)            FORB_CDR_get_char((x),(y))
+#define CORBA_boolean_deserialize(x,y)         FORB_CDR_get_boolean((x),(y))
+#define CORBA_octet_deserialize(x,y)           FORB_CDR_get_octet((x),(y))
+#define CORBA_long_double_deserialize(x,y)     FORB_CDR_get_long_double((x),(y))
+#define CORBA_string_deserialize(x,y)          FORB_CDR_get_string((x),(y))
 
-/* get_max_size functions */
-#define CORBA_short_get_max_size(x)            ((x)->csize=\
-	(unsigned long)ALIGN_ADDRESS((x)->csize,ORTE_ALIGNOF_CORBA_SHORT)+ORTE_ALIGNOF_CORBA_SHORT)
-#define CORBA_long_get_max_size(x)             ((x)->csize=\
-	(unsigned long)ALIGN_ADDRESS((x)->csize,ORTE_ALIGNOF_CORBA_LONG)+ORTE_ALIGNOF_CORBA_LONG)
-#define CORBA_unsigned_short_get_max_size(x)   ((x)->csize=\
-	(unsigned long)ALIGN_ADDRESS((x)->csize,ORTE_ALIGNOF_CORBA_SHORT)+ORTE_ALIGNOF_CORBA_SHORT)
-#define CORBA_unsigned_long_get_max_size(x)    ((x)->csize=\
-	(unsigned long)ALIGN_ADDRESS((x)->csize,ORTE_ALIGNOF_CORBA_LONG)+ORTE_ALIGNOF_CORBA_LONG)
-#define CORBA_float_get_max_size(x)            ((x)->csize=\
-	(unsigned long)ALIGN_ADDRESS((x)->csize,ORTE_ALIGNOF_CORBA_FLOAT)+ORTE_ALIGNOF_CORBA_FLOAT)
-#define CORBA_double_get_max_size(x)           ((x)->csize=\
-	(unsigned long)ALIGN_ADDRESS((x)->csize,ORTE_ALIGNOF_CORBA_DOUBLE)+ORTE_ALIGNOF_CORBA_DOUBLE)
-#define CORBA_char_get_max_size(x)             ((x)->csize=\
-	(unsigned long)ALIGN_ADDRESS((x)->csize,ORTE_ALIGNOF_CORBA_CHAR)+ORTE_ALIGNOF_CORBA_CHAR)
-#define CORBA_boolean_get_max_size(x)          ((x)->csize=\
-	(unsigned long)ALIGN_ADDRESS((x)->csize,ORTE_ALIGNOF_CORBA_BOOLEAN)+ORTE_ALIGNOF_CORBA_BOOLEAN)
-#define CORBA_octet_get_max_size(x)            ((x)->csize=\
-	(unsigned long)ALIGN_ADDRESS((x)->csize,ORTE_ALIGNOF_CORBA_OCTET)+ORTE_ALIGNOF_CORBA_OCTET)
-#define CORBA_long_double_get_max_size(x)      ((x)->csize=\
-	(unsigned long)ALIGN_ADDRESS((x)->csize,ORTE_ALIGNOF_CORBA_LONG_DOUBLE)+ORTE_ALIGNOF_CORBA_DOUBLE)
-#define CORBA_string_get_max_size(x,y)         \
-	((x)->csize=(unsigned long)ALIGN_ADDRESS((x)->csize,ORTE_ALIGNOF_CORBA_LONG) + ORTE_ALIGNOF_CORBA_LONG + y + 1)
 
-#endif /* !_ORTE_CDR_H_ */
+#endif /* !_FORB_CDR_H_ */
diff --git a/src/cdr_codec.h b/src/cdr_codec.h
index 3574e6b..96cda1b 100644
--- a/src/cdr_codec.h
+++ b/src/cdr_codec.h
@@ -49,15 +49,15 @@
  * @author Michal Sojka <sojkam1@fel.cvut.cz>
  * @date   Sun Oct 12 16:53:47 2008
  * 
- * @brief  Definition of CDR_Codec type.
+ * @brief  Definition of FORB_CDR_Codec type.
  * 
  * The definition here is incomplete, which means we can use pointers
  * to this type without having knowledge about internal structorue of
  * this type.
  */
-#ifndef CDR_CODEC_H
-#define CDR_CODEC_H
+#ifndef FORB_CDR_CODEC_H
+#define FORB_CDR_CODEC_H
 
-typedef struct CDR_Codec CDR_Codec;
+typedef struct FORB_CDR_Codec FORB_CDR_Codec;
 
 #endif
diff --git a/src/exec_req.c b/src/exec_req.c
index 20d0de4..b9cc5f9 100644
--- a/src/exec_req.c
+++ b/src/exec_req.c
@@ -65,14 +65,14 @@ extern UL_LOG_CUST(ulogd_forb_exec_req);
 
 void forb_exec_req_process(forb_exec_req_t *exec_req)
 {
-	CDR_Codec reply_codec;
+	FORB_CDR_Codec reply_codec;
 	struct forb_env env;
 	const forb_skel_func *skeletons;
 	forb_t *forb = forb_object_to_forb(exec_req->obj);
 	CORBA_boolean ret;
 	
-	CDR_codec_init_static(&reply_codec, exec_req->obj->orb);	
-	ret = CDR_buffer_init(&reply_codec, 4096,
+	FORB_CDR_codec_init_static(&reply_codec, exec_req->obj->orb);	
+	ret = FORB_CDR_buffer_init(&reply_codec, 4096,
 			      forb_iop_MESSAGE_HEADER_SIZE +
 			      forb_iop_REPLY_HEADER_SIZE);
 	if (!ret) {
diff --git a/src/exec_req.h b/src/exec_req.h
index f1be902..7dd7250 100644
--- a/src/exec_req.h
+++ b/src/exec_req.h
@@ -72,7 +72,7 @@ typedef struct forb_exec_req {
 	forb_server_id source;	/**< Source of this request. */
 	forb_object obj;	/**< Object which is requested */
 	unsigned method_index;	/**< Mehotd number to be invoked on the object @a obj. */
-	CDR_Codec codec;	/**< Bufffer with serialized request parameters. */
+	FORB_CDR_Codec codec;	/**< Bufffer with serialized request parameters. */
 	ul_list_node_t node;	/**< Node for forb_executor_t::requests. */
 } forb_exec_req_t;
 
diff --git a/src/forb-internal.h b/src/forb-internal.h
index ab4e10b..938b6ca 100644
--- a/src/forb-internal.h
+++ b/src/forb-internal.h
@@ -112,8 +112,8 @@ typedef struct forb {
 	fosa_thread_id_t execution_thread; /**< Thread which executes remote requests for this forb::orb interface. */
 } forb_t;
 
-typedef void (*forb_skel_func)(CDR_Codec *cin,
-			       CDR_Codec *cout,
+typedef void (*forb_skel_func)(FORB_CDR_Codec *cin,
+			       FORB_CDR_Codec *cout,
 			       struct forb_object *obj,
 			       struct forb_env *env);
 
diff --git a/src/iop.c b/src/iop.c
index 5813e7e..25ff899 100644
--- a/src/iop.c
+++ b/src/iop.c
@@ -72,7 +72,7 @@ extern UL_LOG_CUST(ulogd_forb_iop);
 
 
 CORBA_boolean
-forb_iop_prepend_message_header(CDR_Codec *codec, forb_iop_message_type mt)
+forb_iop_prepend_message_header(FORB_CDR_Codec *codec, forb_iop_message_type mt)
 {
 	CORBA_boolean ret;
 	forb_iop_message_header mh;
@@ -80,8 +80,8 @@ forb_iop_prepend_message_header(CDR_Codec *codec, forb_iop_message_type mt)
 	mh.proto_version.minor = VER_MINOR;
 	mh.message_type = mt;
 	mh.flags = (codec->data_endian == LittleEndian) ? forb_iop_LITTLE_ENDIAN : 0;
-	mh.message_size = CDR_data_size(codec);
-	ret = CDR_buffer_prepend(codec, forb_iop_MESSAGE_HEADER_SIZE);
+	mh.message_size = FORB_CDR_data_size(codec);
+	ret = FORB_CDR_buffer_prepend(codec, forb_iop_MESSAGE_HEADER_SIZE);
 	if (ret) {
 		ret = forb_iop_message_header_serialize(codec, &mh);
 	}
@@ -105,16 +105,16 @@ forb_iop_prepare_request(forb_request_t *req,
 	ret = forb_iop_request_header_serialize(&req->cdr_request, &rh);
 	if (ret) {
 		/* Request body is 8 byte aligned */
-		ret = CDR_put_align(&req->cdr_request, 8);
+		ret = FORB_CDR_put_align(&req->cdr_request, 8);
 	}
 	return ret;
 }
 
 CORBA_boolean
-forb_iop_prepare_hello(CDR_Codec *codec,
+forb_iop_prepare_hello(FORB_CDR_Codec *codec,
 		       const forb_server_id *server_id,
 		       const void *src_addr,
-		       CORBA_boolean (*serialize_addr)(CDR_Codec *codec, const void *addr))
+		       CORBA_boolean (*serialize_addr)(FORB_CDR_Codec *codec, const void *addr))
 {
 	if (!forb_server_id_serialize(codec, server_id)) return CORBA_FALSE;
 	if (serialize_addr) {
@@ -125,7 +125,7 @@ forb_iop_prepare_hello(CDR_Codec *codec,
 }
 
 bool
-forb_iop_process_message_header(forb_iop_message_header *mh, CDR_Codec *codec)
+forb_iop_process_message_header(forb_iop_message_header *mh, FORB_CDR_Codec *codec)
 {
 	/* FIXME: If we have multiple protocol versions, use different
 	 * type (independent from version) for return value instead of
@@ -155,13 +155,13 @@ forb_iop_process_message_header(forb_iop_message_header *mh, CDR_Codec *codec)
 }
 
 static inline CORBA_boolean
-forb_exception_serialize(CDR_Codec *codec, struct forb_env *env)
+forb_exception_serialize(FORB_CDR_Codec *codec, struct forb_env *env)
 {
 	return CORBA_long_serialize(codec, &env->major);
 }
 
 static inline CORBA_boolean
-forb_exception_deserialize(CDR_Codec *codec, struct forb_env *env)
+forb_exception_deserialize(FORB_CDR_Codec *codec, struct forb_env *env)
 {
 	/* TODO: Declare exceptions in IDL and don't typecast here. */
 	return CORBA_long_deserialize(codec, (CORBA_long*)&env->major);
@@ -170,7 +170,7 @@ forb_exception_deserialize(CDR_Codec *codec, struct forb_env *env)
 void
 forb_iop_send_reply(forb_t *forb,
 	   forb_server_id *dest,
-	   CDR_Codec *codec,
+	   FORB_CDR_Codec *codec,
 	   CORBA_long request_id,
 	   struct forb_env *env)
 {
@@ -183,14 +183,14 @@ forb_iop_send_reply(forb_t *forb,
 	reply_header.flags = 0;
 	if (forb_exception_occurred(env)) {
 		reply_header.flags |= forb_iop_FLAG_EXCEPTION;
-		CDR_buffer_reset(codec, forb_iop_MESSAGE_HEADER_SIZE +
-				 	forb_iop_REPLY_HEADER_SIZE);
+		FORB_CDR_buffer_reset(codec, forb_iop_MESSAGE_HEADER_SIZE +
+				      	     forb_iop_REPLY_HEADER_SIZE);
 		forb_exception_serialize(codec, env);
 	}
 	/* forb_iop_REPLY_HEADER_SIZE equals to 8 even if the real
 	 * header is shorter. We want reply data to be 8 byte
 	 * aligned */
-	ret = CDR_buffer_prepend(codec, forb_iop_REPLY_HEADER_SIZE);
+	ret = FORB_CDR_buffer_prepend(codec, forb_iop_REPLY_HEADER_SIZE);
 	if (!ret) {
 		goto err;
 	}
@@ -217,7 +217,7 @@ err:
 
 
 static void
-process_request(forb_port_t *port, CDR_Codec *codec, uint32_t message_size)
+process_request(forb_port_t *port, FORB_CDR_Codec *codec, uint32_t message_size)
 {
 	forb_iop_request_header request_header;
 	CORBA_boolean ret;
@@ -225,26 +225,26 @@ process_request(forb_port_t *port, CDR_Codec *codec, uint32_t message_size)
 	size_t n;
 	forb_t *forb = port->forb;
 	struct forb_env env;
-	CDR_Codec reply_codec;
+	FORB_CDR_Codec reply_codec;
 	forb_exec_req_t *exec_req;
 	uint32_t req_size, data_size, header_size;
 	char str[32];
 
-	data_size = CDR_data_size(codec);
+	data_size = FORB_CDR_data_size(codec);
 	ret = forb_iop_request_header_deserialize(codec, &request_header);
 	if (!ret) {
 		ul_logerr("Malformed request recevied\n");
 		env.major = FORB_EX_COMM_FAILURE;
 		goto out;
 	}
-	ret = CDR_get_align(codec, 8);
+	ret = FORB_CDR_get_align(codec, 8);
 	if (!ret) {
 		ul_logerr("Malformed request recevied\n");
 		env.major = FORB_EX_COMM_FAILURE;
 		goto out;
 	}
 
-	header_size = data_size - CDR_data_size(codec);
+	header_size = data_size - FORB_CDR_data_size(codec);
 	req_size = message_size - header_size;
 
 	ul_logdeb("rcvd request: src=%s, id=%u, iface=%s, method=%hd\n",
@@ -287,8 +287,8 @@ process_request(forb_port_t *port, CDR_Codec *codec, uint32_t message_size)
 		exec_req->obj = obj;
 		exec_req->method_index = request_header.method_index;
 		/* Copy the request to exec_req */
-		CDR_codec_init_static(&exec_req->codec, codec->orb);
-		ret = CDR_buffer_init(&exec_req->codec,
+		FORB_CDR_codec_init_static(&exec_req->codec, codec->orb);
+		ret = FORB_CDR_buffer_init(&exec_req->codec,
 				      req_size,
 				      0);
 		if (!ret) {
@@ -298,7 +298,7 @@ process_request(forb_port_t *port, CDR_Codec *codec, uint32_t message_size)
 			goto send_execption;
 		}
 		exec_req->codec.data_endian = codec->data_endian;
-		CDR_buffer_gets(codec, exec_req->codec.buffer, req_size);
+		FORB_CDR_buffer_gets(codec, exec_req->codec.buffer, req_size);
 		/* TODO: Use better data structure for incomming
 		   buffer to achieve zero-copy behaviour. */
 		forb_exec_req_ins_tail(obj->executor, exec_req);
@@ -312,8 +312,8 @@ out:
 	return;
 	
 send_execption:
-	CDR_codec_init_static(&reply_codec, codec->orb);	
-	ret = CDR_buffer_init(&reply_codec, 4096,
+	FORB_CDR_codec_init_static(&reply_codec, codec->orb);	
+	ret = FORB_CDR_buffer_init(&reply_codec, 4096,
 			      forb_iop_MESSAGE_HEADER_SIZE +
 			      forb_iop_REPLY_HEADER_SIZE);
 	if (!ret) {
@@ -323,11 +323,11 @@ send_execption:
 
 	forb_iop_send_reply(port->forb, &request_header.source,
 			    &reply_codec, request_header.request_id, &env);
-	CDR_codec_release_buffer(&reply_codec);
+	FORB_CDR_codec_release_buffer(&reply_codec);
 }
 
 static void
-process_reply(forb_port_t *port, CDR_Codec *codec)
+process_reply(forb_port_t *port, FORB_CDR_Codec *codec)
 {
 	forb_iop_reply_header rh;
 	forb_t *forb = port->forb;
@@ -335,7 +335,7 @@ process_reply(forb_port_t *port, CDR_Codec *codec)
 
 	forb_iop_reply_header_deserialize(codec, &rh);
 	/* Reply data are 8 byte aligned */
-	CDR_get_align(codec, 8);
+	FORB_CDR_get_align(codec, 8);
 	ul_logdeb("rcvd reply: id=%u\n", rh.request_id);
 	req = forb_request_find(forb, &rh.request_id);
 	if (!req) {
@@ -373,7 +373,7 @@ process_reply(forb_port_t *port, CDR_Codec *codec)
  * @param codec Buffer with the hello message
  */
 static void
-process_hello(forb_port_t *port, CDR_Codec *codec)
+process_hello(forb_port_t *port, FORB_CDR_Codec *codec)
 {
 	forb_server_id server_id;
 	void *addr = NULL;
@@ -428,9 +428,9 @@ process_hello(forb_port_t *port, CDR_Codec *codec)
 
 static void
 process_message(forb_port_t *port, const forb_iop_message_header *mh,
-		CDR_Codec *codec)
+		FORB_CDR_Codec *codec)
 {
-	CORBA_long data_size = CDR_data_size(codec);
+	CORBA_long data_size = FORB_CDR_data_size(codec);
 	/* TODO: Check destination address, whether the message is for
 	 * us or should be routed. */
 
@@ -450,8 +450,8 @@ process_message(forb_port_t *port, const forb_iop_message_header *mh,
 			ul_logmsg("rcvd unknown message type\n");
 			break;
 	}
-	if (CDR_data_size(codec) != data_size - mh->message_size) {
-		size_t processed = data_size - CDR_data_size(codec);
+	if (FORB_CDR_data_size(codec) != data_size - mh->message_size) {
+		size_t processed = data_size - FORB_CDR_data_size(codec);
 		ul_logmsg("Message of type %d handled incorrectly (size=%d, processed=%d); fixing\n",
 			  mh->message_type, mh->message_size, processed);
 			  ;
@@ -470,7 +470,7 @@ void *forb_iop_receiver_thread(void *arg)
 {
 	forb_port_t *port = arg;
 	const forb_proto_t *proto = port->proto;
-	CDR_Codec *c = &port->codec;
+	FORB_CDR_Codec *c = &port->codec;
 	size_t rcvd, len;
 	forb_iop_message_header mh;
 	bool header_received = false;
@@ -478,7 +478,7 @@ void *forb_iop_receiver_thread(void *arg)
 	while (!port->finish) {
 		if (c->rptr == c->wptr) {
 			/* The buffer is empty now - start writing from begining*/
-			CDR_buffer_reset(c, 0);
+			FORB_CDR_buffer_reset(c, 0);
 		}
 		/* TODO: If there is not enough space for reception,
 		 * we should shift the already received data to the
@@ -490,8 +490,8 @@ void *forb_iop_receiver_thread(void *arg)
                 c->wptr_last = c->wptr;
 
 		/* While there are some data in the buffer, process them. */
-		while (CDR_data_size(c) > 0) {
-			len = CDR_data_size(c);
+		while (FORB_CDR_data_size(c) > 0) {
+			len = FORB_CDR_data_size(c);
 			/* Wait for and then process message header */
 			if (!header_received) {
 				if (len >= forb_iop_MESSAGE_HEADER_SIZE) {
@@ -499,7 +499,7 @@ void *forb_iop_receiver_thread(void *arg)
 						ul_logerr("Header doesn't start at 8 byte bounday\n");
 					}
 					header_received = forb_iop_process_message_header(&mh, c);
-					len = CDR_data_size(c);
+					len = FORB_CDR_data_size(c);
 				} else {
 					break; /* Wait for more data to arrive*/
 				}
@@ -523,7 +523,7 @@ void *forb_iop_receiver_thread(void *arg)
 static void
 discovery_cleanup(void *codec)
 {
-	CDR_codec_release_buffer((CDR_Codec*)codec);
+	FORB_CDR_codec_release_buffer((FORB_CDR_Codec*)codec);
 	/* TODO: Broadcast some kind of bye bye message */
 }
 
@@ -541,13 +541,13 @@ void *forb_iop_discovery_thread(void *arg)
 {
 	forb_port_t *port = arg;
 	const forb_proto_t *proto = port->proto;
-	CDR_Codec codec;
+	FORB_CDR_Codec codec;
 	fosa_abs_time_t hello_time;
 	fosa_rel_time_t hello_interval = fosa_msec_to_rel_time(1000*proto->hello_interval);
 	int ret;
 
-	CDR_codec_init_static(&codec, port->forb->orb);
-	CDR_buffer_init(&codec, 1024, 0);
+	FORB_CDR_codec_init_static(&codec, port->forb->orb);
+	FORB_CDR_buffer_init(&codec, 1024, 0);
 
 	pthread_cleanup_push(discovery_cleanup, &codec);
 	
@@ -567,12 +567,12 @@ void *forb_iop_discovery_thread(void *arg)
 
 		if (port->finish) break;
 
-		CDR_buffer_reset(&codec, forb_iop_MESSAGE_HEADER_SIZE);
+		FORB_CDR_buffer_reset(&codec, forb_iop_MESSAGE_HEADER_SIZE);
 		forb_iop_prepare_hello(&codec, &port->forb->server_id, port->addr,
 				       proto->serialize_addr);
 /* 		printf("Broadcasting hello from port %p\n", port);  */
 		proto->broadcast(port, &codec.buffer[codec.rptr],
-				 CDR_data_size(&codec));
+				 FORB_CDR_data_size(&codec));
 	}
 
 	pthread_cleanup_pop(1);
diff --git a/src/iop.h b/src/iop.h
index 974301b..c2d2e68 100644
--- a/src/iop.h
+++ b/src/iop.h
@@ -62,7 +62,7 @@
 #include <forb/request.h>
 
 CORBA_boolean
-forb_iop_prepend_message_header(CDR_Codec *codec, forb_iop_message_type mt);
+forb_iop_prepend_message_header(FORB_CDR_Codec *codec, forb_iop_message_type mt);
 
 CORBA_boolean
 forb_iop_prepare_request(forb_request_t *req,
@@ -71,21 +71,21 @@ forb_iop_prepare_request(forb_request_t *req,
 			 CORBA_Environment *env);
 
 CORBA_boolean
-forb_iop_prepare_hello(CDR_Codec *codec,
+forb_iop_prepare_hello(FORB_CDR_Codec *codec,
 		       const forb_server_id *server_id,
 		       const void *src_addr,
-		       CORBA_boolean (*serialize_addr)(CDR_Codec *codec, const void *addr));
+		       CORBA_boolean (*serialize_addr)(FORB_CDR_Codec *codec, const void *addr));
 
 bool
-forb_iop_process_message_header(forb_iop_message_header *mh, CDR_Codec *codec);
+forb_iop_process_message_header(forb_iop_message_header *mh, FORB_CDR_Codec *codec);
 
 void
-forb_iop_process_message(forb_iop_message_header *mh, CDR_Codec *codec);
+forb_iop_process_message(forb_iop_message_header *mh, FORB_CDR_Codec *codec);
 
 void
 forb_iop_send_reply(forb_t *forb,
 		    forb_server_id *dest,
-		    CDR_Codec *codec,
+		    FORB_CDR_Codec *codec,
 		    CORBA_long request_id,
 		    struct forb_env *env);
 
diff --git a/src/object.c b/src/object.c
index 0d459b6..ec170e4 100644
--- a/src/object.c
+++ b/src/object.c
@@ -289,7 +289,7 @@ forb_object_duplicate(const forb_object obj)
  * @return CORBA_TRUE on success, CORBA_FALSE on error.
  */
 CORBA_boolean
-forb_object_serialize(CDR_Codec *codec, const forb_object *obj)
+forb_object_serialize(FORB_CDR_Codec *codec, const forb_object *obj)
 {
 	if (!forb_server_id_serialize(codec, &(*obj)->server))
 		return CORBA_FALSE;
@@ -299,7 +299,7 @@ forb_object_serialize(CDR_Codec *codec, const forb_object *obj)
 }
 
 /** 
- * Creates the object reference by deserialization from ::CDR_Codec.
+ * Creates the object reference by deserialization from ::FORB_CDR_Codec.
  * 
  * @param codec 
  * @param obj 
@@ -307,7 +307,7 @@ forb_object_serialize(CDR_Codec *codec, const forb_object *obj)
  * @return CORBA_TRUE on success, CORBA_FALSE on error.
  */
 CORBA_boolean
-forb_object_deserialize(CDR_Codec *codec, forb_object *obj)
+forb_object_deserialize(FORB_CDR_Codec *codec, forb_object *obj)
 {
 	forb_server_id server_id;
 	forb_object_key objkey;
diff --git a/src/object.h b/src/object.h
index 992f343..56ce523 100644
--- a/src/object.h
+++ b/src/object.h
@@ -250,8 +250,8 @@ forb_object_is_remote(forb_object obj)
 }
 
 CORBA_boolean
-forb_object_serialize(CDR_Codec *codec, const forb_object *obj);
+forb_object_serialize(FORB_CDR_Codec *codec, const forb_object *obj);
 CORBA_boolean
-forb_object_deserialize(CDR_Codec *codec, forb_object *obj);
+forb_object_deserialize(FORB_CDR_Codec *codec, forb_object *obj);
 
 #endif
diff --git a/src/port.c b/src/port.c
index 74f985c..6aefe43 100644
--- a/src/port.c
+++ b/src/port.c
@@ -91,8 +91,8 @@ int forb_register_port(forb_t *forb, forb_port_t *port)
 	forb_syncobj_init(&port->hello, 0);
 	forb_syncobj_init(&port->reply_processed, 0);
 
-	CDR_codec_init_static(&port->codec, forb->orb);
-	if (!CDR_buffer_init(&port->codec, CONFIG_FORB_RECV_BUF_SIZE, 0)) {
+	FORB_CDR_codec_init_static(&port->codec, forb->orb);
+	if (!FORB_CDR_buffer_init(&port->codec, CONFIG_FORB_RECV_BUF_SIZE, 0)) {
 		ret = FOSA_ENOMEM;
 		goto err;
 	}
@@ -115,7 +115,7 @@ err3:
 	pthread_join(port->receiver_thread.pthread_id, NULL);
 	pthread_join(port->discovery_thread.pthread_id, NULL);
 err2:
-	CDR_codec_release_buffer(&port->codec);
+	FORB_CDR_codec_release_buffer(&port->codec);
 err:
 	fosa_mutex_lock(&forb->port_mutex);
 	forb_port_delete(forb, port);
@@ -160,7 +160,7 @@ void forb_destroy_port(forb_port_t *port)
 	 * after receiver thread is stopped. */
 	forb_peer_delete_by_port(forb, port);
 
-	CDR_codec_release_buffer(&port->codec);
+	FORB_CDR_codec_release_buffer(&port->codec);
 
 	fosa_mutex_lock(&forb->port_mutex);
 	forb_port_delete(forb, port);
diff --git a/src/port.h b/src/port.h
index 6728e53..2b7d4f5 100644
--- a/src/port.h
+++ b/src/port.h
@@ -79,7 +79,7 @@ typedef struct forb_port {
 	fosa_thread_id_t discovery_thread;/**< The thread for periodic sending HELLO messages */
 	forb_syncobj_t hello;		  /**< Synchronization object for signaling the discovery thread to send the hello messages now. */
 	forb_syncobj_t reply_processed;	  /**< Synchronization object for signaling the receiver thread to continue processing after the reply is processed by a stub. */
-	CDR_Codec codec;		  /**< Receiving buffer for receiver thread */
+	FORB_CDR_Codec codec;		  /**< Receiving buffer for receiver thread */
 	void *addr; 			  /**< Port's address in a protocol specific format. */
 	ul_list_node_t node;		  /**< Node in forb's port list */
 	ul_list_head_t peers; 		  /**< Peers discovered on this port by discovery protocol */
diff --git a/src/proto.c b/src/proto.c
index b0c7187..2f7058b 100644
--- a/src/proto.c
+++ b/src/proto.c
@@ -62,7 +62,7 @@
 
 extern UL_LOG_CUST(ulogd_forb_proto);
 
-size_t forb_proto_send(forb_peer_t *peer, CDR_Codec *codec)
+size_t forb_proto_send(forb_peer_t *peer, FORB_CDR_Codec *codec)
 {
 	
 #if 0
@@ -83,7 +83,7 @@ size_t forb_proto_send(forb_peer_t *peer, CDR_Codec *codec)
 #endif
 	
 	return peer->port->proto->send(peer, &codec->buffer[codec->rptr],
-				       CDR_data_size(codec));
+				       FORB_CDR_data_size(codec));
 }
 
 
diff --git a/src/proto.h b/src/proto.h
index bff2533..0abf8f1 100644
--- a/src/proto.h
+++ b/src/proto.h
@@ -136,13 +136,13 @@ struct forb_proto {
 	size_t (*broadcast)(forb_port_t *port, const void *buf, size_t len);
 
 	/** Serializes the protocol specific address */
-	CORBA_boolean (*serialize_addr)(CDR_Codec *codec, const void *addr);
+	CORBA_boolean (*serialize_addr)(FORB_CDR_Codec *codec, const void *addr);
 
 	/** Deserializes the protocol specific address */
-	CORBA_boolean (*deserialize_addr)(CDR_Codec *codec, void **addr);
+	CORBA_boolean (*deserialize_addr)(FORB_CDR_Codec *codec, void **addr);
 };
 
-size_t forb_proto_send(forb_peer_t *peer, CDR_Codec *codec);
+size_t forb_proto_send(forb_peer_t *peer, FORB_CDR_Codec *codec);
 
 forb_peer_t *
 forb_get_next_hop(forb_t *forb, forb_server_id *server, fosa_abs_time_t *timeout);
diff --git a/src/request.c b/src/request.c
index 7be87db..bf83fa7 100644
--- a/src/request.c
+++ b/src/request.c
@@ -103,8 +103,8 @@ forb_request_init(forb_request_t *req, forb_object obj)
 	req->request_id = forb->request_id++;
 	fosa_mutex_unlock(&forb->request_id_mutex);
 
-	CDR_codec_init_static(&req->cdr_request, obj->orb);
-	bret = CDR_buffer_init(&req->cdr_request, 256, forb_iop_MESSAGE_HEADER_SIZE);
+	FORB_CDR_codec_init_static(&req->cdr_request, obj->orb);
+	bret = FORB_CDR_buffer_init(&req->cdr_request, 256, forb_iop_MESSAGE_HEADER_SIZE);
 	if (bret == CORBA_FALSE) {
 		return FOSA_ENOMEM;
 	}
@@ -119,7 +119,7 @@ forb_request_destroy(forb_request_t *req)
 	forb_t *forb = forb_object_to_forb(req->obj);
 
 	forb_request_delete(forb, req);
-	CDR_codec_release_buffer(&req->cdr_request);
+	FORB_CDR_codec_release_buffer(&req->cdr_request);
 	forb_syncobj_destroy(&req->reply_ready);
 }
 
@@ -215,7 +215,7 @@ forb_request_send(forb_request_t *req, CORBA_Environment *env)
 		return;
 	}
 
-	len = CDR_data_size(&req->cdr_request);
+	len = FORB_CDR_data_size(&req->cdr_request);
 	size = forb_proto_send(peer, &req->cdr_request);
 	if (size <= 0 || size != len) {
 		env->major = FORB_EX_COMM_FAILURE;
diff --git a/src/request.h b/src/request.h
index ee0ab54..0458760 100644
--- a/src/request.h
+++ b/src/request.h
@@ -77,8 +77,8 @@
  */
 struct forb_request {
 	CORBA_unsigned_long request_id;	/**< Numeric ID of this request. Used to match replies agains this request. */
-	CDR_Codec cdr_request;	/**< Buffer for the request serialization. */
-	CDR_Codec *cdr_reply;	/**< Buffer with received reply. */
+	FORB_CDR_Codec cdr_request;	/**< Buffer for the request serialization. */
+	FORB_CDR_Codec *cdr_reply;	/**< Buffer with received reply. */
 	gavl_node_t node;	/**< forb_t::requests node */
 	forb_object obj;	/**< Object being requested. */
 	struct forb_env *env; 	/**< Where to store exception returned in reply */