Unify parameters of forb_sequence_*()

Now, all macros take the pointer to the sequence.

diff --git a/forb-idl/forb-idl-c-common.c b/forb-idl/forb-idl-c-common.c
index c5b10c9b739e6b1cb111b2d0268d931e79e4ab59..b2e4ec7f959de9224308a352159568689a7e35ea 100644 (file)
--- a/forb-idl/forb-idl-c-common.c
+++ b/forb-idl/forb-idl-c-common.c
@@ -201,7 +201,7 @@ cc_output_ser_seqence(OIDL_C_Info *ci,
                        "  CORBA_boolean ok;\n"
                        "  ok = CORBA_unsigned_long_deserialize(codec, &i);\n"
                        "  if (ok) {\n"
-                       "    ok = forb_sequence_alloc_buf(*seq, i);\n"
+                       "    ok = forb_sequence_alloc_buf(seq, i);\n"
                        "    seq->_length = i;\n"
                        "    CORBA_sequence_set_release(seq, CORBA_TRUE);\n"
                        "  }\n"

diff --git a/src/basic_types.h b/src/basic_types.h
index 8aa5dc767dfc0c0ee1bb240b5bce43789bccfffa..68f84e7b8d042e0bdf2c5c0446756a06ae42b6ae 100644 (file)
--- a/src/basic_types.h
+++ b/src/basic_types.h
@@ -105,36 +105,36 @@ __forb_sequence_alloc_buf_internal(void *seq, size_t seq_size,
  * @return CORBA_TRUE if the allocation was sucessfull, CORBA_FALSE if wasn't.
  */
 #define forb_sequence_alloc_buf(seq, num_elements)                     \
-       __forb_sequence_alloc_buf_internal(&(seq), sizeof(seq),         \
-                                          (void**)&(seq)._buffer, &(seq)._maximum, \
-                                          (num_elements), sizeof(*(seq)._buffer))
-
-#define forb_sequence_alloc(seq_ptr, num_elements) do {                        \
-               (seq_ptr) = forb_malloc(sizeof(*(seq_ptr)));            \
-               memset((seq_ptr), 0, sizeof(*(seq_ptr)));               \
-               forb_sequence_alloc_buf(*(seq_ptr), (num_elements));    \
+       __forb_sequence_alloc_buf_internal((seq), sizeof(*(seq)),       \
+                                          (void**)&(seq)->_buffer, &(seq)->_maximum, \
+                                          (num_elements), sizeof(*(seq)->_buffer))
+
+#define forb_sequence_alloc(seq, num_elements) do {            \
+               (seq) = forb_malloc(sizeof(*(seq)));            \
+               memset((seq), 0, sizeof(*(seq)));               \
+               forb_sequence_alloc_buf((seq), (num_elements)); \
        } while(0)
 
 static inline void forb_no_destructor() {}
 
 #define forb_sequence_free_buf(seq, elem_destructor) do {              \
-               if (CORBA_sequence_get_release(&(seq))) {               \
+               if (CORBA_sequence_get_release(seq)) {                  \
                        CORBA_unsigned_long i;                          \
-                       for (i=0; i<(seq)._length; i++) { \
-                               elem_destructor(&(seq)._buffer[i]);     \
+                       for (i=0; i<(seq)->_length; i++) {              \
+                               elem_destructor(&(seq)->_buffer[i]);    \
                        }                                               \
-                       forb_free((seq)._buffer);                       \
+                       forb_free((seq)->_buffer);                      \
                }                                                       \
        } while(0)
 
-#define forb_sequence_free(seq_ptr, elem_destructor) do {              \
-               forb_sequence_free_buf(*(seq_ptr), (elem_destructor));  \
-               forb_free(seq_ptr);                                     \
+#define forb_sequence_free(seq, elem_destructor) do {                  \
+               forb_sequence_free_buf((seq), (elem_destructor));       \
+               forb_free(seq);                                         \
        } while(0)
 
-#define forb_sequence_elem(seq, index) ((seq)._buffer[index])
+#define forb_sequence_elem(seq, index) ((seq)->_buffer[(index)])
 
-#define forb_sequence_length(seq) ((seq)._length)
+#define forb_sequence_length(seq) ((seq)->_length)
 
 #define forb_sequence_foreach(seq, elemptr)          \
        for ((elemptr)=&forb_sequence_elem((seq), 0); \

diff --git a/src/forb.c b/src/forb.c
index ce20b275b178f7af8d7b8d9acef98e3da1504f51..dee15872072afbba395de57e31d456172ace6ab3 100644 (file)
--- a/src/forb.c
+++ b/src/forb.c
@@ -486,7 +486,8 @@ forb_get_req_source(const forb_object obj, forb_server_id *req_source)
  * @param num_elements
  * @param elem_size
  *
- * @return CORBA_TRUE if the allocation was sucessfull, CORBA_FALSE if wasn't.
+ * @return CORBA_TRUE if the allocation was sucessfull, CORBA_FALSE if
+ * it wasn't.
  */
 CORBA_boolean
 __forb_sequence_alloc_buf_internal(void *seq, size_t seq_size,

diff --git a/src/tests/sequence.c b/src/tests/sequence.c
index 5bf48a3c35036c2e7e0c048fe28d79de8cb50a56..9ff38e2b54581b03d6695abc99d6f48571debfc4 100644 (file)
--- a/src/tests/sequence.c
+++ b/src/tests/sequence.c
@@ -18,16 +18,16 @@ WVTEST_MAIN("sequence manipulation")
        forb_sequence_alloc(s, 10);
        WVPASS(s);
        CORBA_sequence_set_release(s, 1);
-       WVPASS(forb_sequence_length(*s) == 0);
+       WVPASS(forb_sequence_length(s) == 0);
        forb_sequence_free(s, destructor);
        WVPASS(destructor_called == 0);
 
        forb_sequence_alloc(s, 10);
        WVPASS(s);
        for (i=0; i<10; i++)
-               forb_sequence_elem(*s, i) = i;
-       forb_sequence_length(*s) = 10;
-       WVPASS(forb_sequence_length(*s) == 10);
+               forb_sequence_elem(s, i) = i;
+       forb_sequence_length(s) = 10;
+       WVPASS(forb_sequence_length(s) == 10);
        forb_sequence_free(s, destructor);
        WVPASS(destructor_called == 0);
 
@@ -35,11 +35,11 @@ WVTEST_MAIN("sequence manipulation")
        WVPASS(s);
        CORBA_sequence_set_release(s, 1);
        for (i=0; i<10; i++)
-               forb_sequence_elem(*s, i) = i;
-       forb_sequence_length(*s) = 10;
-       WVPASS(forb_sequence_length(*s) == 10);
+               forb_sequence_elem(s, i) = i;
+       forb_sequence_length(s) = 10;
+       WVPASS(forb_sequence_length(s) == 10);
 
-       forb_sequence_foreach(*s, e) {
+       forb_sequence_foreach(s, e) {
                foreach_retuned_sum += *e;
        }
        WVPASS(foreach_retuned_sum == 45);