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 47ffbeea0e69149ca21deccf5869978adf164c4b..bf1a1eb0a1c479161775b060a1292cb2c55304b4 100644 (file)
--- 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 78b45496cb345e3025eba1141e489a253c742a88..061bd48ade37cbc7f6d6024d48585318136265f1 100644 (file)
--- 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 096cdd998d86bdd0415696e8e5c4e463a479c9e5..12bd67471046f0e9e5d886c5fb79b802ecaa5aad 100644 (file)
--- 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 0bf15d4bac9929cccb66d43f07b9b098035d2940..3948a6929511453aa867489d9b24aa7f129db0b3 100644 (file)
--- 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 c947c073f5a8b6386f7955ef133db43f59a45865..8eaa1d3a50b13e77e74c9d20350e3254a9ae8f6d 100644 (file)
--- 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 3574e6bf5ed3948f877c79d0f8a8adf5e5ce7aed..96cda1b84083ba8fc21aebc05acc238012214b88 100644 (file)
--- 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 20d0de41e4015ff74390e0af387c8ff11c94ec21..b9cc5f99062be867e98a837dff578237f6456590 100644 (file)
--- 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 f1be90252a86b690b6c21410687a0e012b750b61..7dd725086abebd2b1207ae013db1343d4dd29348 100644 (file)
--- 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 ab4e10b5c0d395c88d682d279ac4d9ed2b039791..938b6ca9cbf8d833504ad47be1d35fd24614c9c2 100644 (file)
--- 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 5813e7e234a2c7f943aeedcde31f5b9130d41445..25ff89921ea6035e3ac66f608378fb521e039d60 100644 (file)
--- 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 974301b1c898bf4cf29744c2dfd656db8783a632..c2d2e68ac48ad6eef0964443ddd7d0f990d8c34c 100644 (file)
--- 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 0d459b63e44d0af4ace9da16a1a9bda49e17d79f..ec170e48747169bb0d504892d23570f479393fdd 100644 (file)
--- 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 992f34371b75c88773242302531a2f0ff3ac2644..56ce5236e457b5fd41d6c125042d90dcd077d3f1 100644 (file)
--- 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 74f985c92a0c39788b1d626404e630af4bbe8d7d..6aefe43f28f94d813354f202afb8af80c3578312 100644 (file)
--- 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 6728e5367e51feb32daa3ba19cf9d0c804b2cb3d..2b7d4f5d49d0addf0f58234b4cc088c9b7d36059 100644 (file)
--- 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 b0c718772d0509f3d897cf4f154aec56b350490f..2f7058b425ca1cc785bfe412925c55d28159b4cd 100644 (file)
--- 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 bff2533a1c320ef926aaa31758835e49996862cb..0abf8f112ad4e8fb107af1fc9f4811bf009cb1ec 100644 (file)
--- 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 7be87db04b8ea594f589b47eea809456ba5e8ef6..bf83fa71d3be558eba15ecc67c417e2ccd0d5682 100644 (file)
--- 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 ee0ab54e2f2f13dbc4ca21ece8f227ac8de969e1..0458760819f071e30017e58ed233109f8a5e64ae 100644 (file)
--- 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 */