ran the indent program on the source files to make them consistent.

2006-02-18 22:34:36 +00:00
parent 21b373c75c
commit b1d46ffa8c
72 changed files with 10446 additions and 11551 deletions
@@ -40,181 +40,170 @@
 #include <stddef.h>
 #include "sbuf.h"

-void sbuf_init(
-  STATIC_BUFFER *b, /* static buffer structure */
-  char *data, /* actual size, in bytes, of the data block or array of data */
-  unsigned size) /* number of bytes used */
-{
-  if (b)
-  {
-    b->data = data;
-    b->size = size;
-    b->count = 0;
-  }
+void sbuf_init(STATIC_BUFFER * b,       /* static buffer structure */
+    char *data,                 /* actual size, in bytes, of the data block or array of data */
+    unsigned size)
+{                               /* number of bytes used */
+    if (b) {
+        b->data = data;
+        b->size = size;
+        b->count = 0;
+    }

-  return;
+    return;
 }

 /* returns true if count==0, false if count > 0 */
 bool sbuf_empty(STATIC_BUFFER const *b)
 {
-  return (b?(b->count == 0):false);
+    return (b ? (b->count == 0) : false);
 }

 char *sbuf_data(STATIC_BUFFER const *b)
 {
-  return (b?b->data:NULL);
+    return (b ? b->data : NULL);
 }

-unsigned sbuf_size(STATIC_BUFFER *b)
+unsigned sbuf_size(STATIC_BUFFER * b)
 {
-  return (b?b->size:0);
+    return (b ? b->size : 0);
 }

-unsigned sbuf_count(STATIC_BUFFER *b)
+unsigned sbuf_count(STATIC_BUFFER * b)
 {
-  return (b?b->count:0);
+    return (b ? b->count : 0);
 }

 /* returns true if successful, false if not enough room to append data */
-bool sbuf_put(
-  STATIC_BUFFER *b, /* static buffer structure */
-  unsigned offset, /* where to start */
-  char *data, /* number of bytes used */
-  unsigned data_size)  /* how many to add */
-{
-  bool status = false; /* return value */
+bool sbuf_put(STATIC_BUFFER * b,        /* static buffer structure */
+    unsigned offset,            /* where to start */
+    char *data,                 /* number of bytes used */
+    unsigned data_size)
+{                               /* how many to add */
+    bool status = false;        /* return value */

-  if (b && b->data)
-  {
-    if (((offset + data_size) < b->size))
-    {
-      b->count = offset + data_size;
-      while (data_size)
-      {
-        b->data[offset] = *data;
-        offset++;
-        data++;
-        data_size--;
-      }
-      status = true;
+    if (b && b->data) {
+        if (((offset + data_size) < b->size)) {
+            b->count = offset + data_size;
+            while (data_size) {
+                b->data[offset] = *data;
+                offset++;
+                data++;
+                data_size--;
+            }
+            status = true;
+        }
    }
-  }

-  return status;  
+    return status;
 }

 /* returns true if successful, false if not enough room to append data */
-bool sbuf_append(
-  STATIC_BUFFER *b, /* static buffer structure */
-  char *data, /* number of bytes used */
-  unsigned data_size)  /* how many to add */
-{
-  unsigned count = 0;
-  
-  if (b)
-    count = b->count;
-  
-  return sbuf_put(b, count, data, data_size);
+bool sbuf_append(STATIC_BUFFER * b,     /* static buffer structure */
+    char *data,                 /* number of bytes used */
+    unsigned data_size)
+{                               /* how many to add */
+    unsigned count = 0;
+
+    if (b)
+        count = b->count;
+
+    return sbuf_put(b, count, data, data_size);
 }

 /* returns true if successful, false if not enough room to append data */
-bool sbuf_truncate(
-  STATIC_BUFFER *b, /* static buffer structure */
-  unsigned count) /* total number of bytes in use */
-{
-  bool status = false; /* return value */
+bool sbuf_truncate(STATIC_BUFFER * b,   /* static buffer structure */
+    unsigned count)
+{                               /* total number of bytes in use */
+    bool status = false;        /* return value */

-  if (b)
-  {
-    if (count < b->size)
-    {
-      b->count = count;
-      status = true;
+    if (b) {
+        if (count < b->size) {
+            b->count = count;
+            status = true;
+        }
    }
-  }
-  
-  return status;  
+
+    return status;
 }
-  
+
 #ifdef TEST
 #include <assert.h>
 #include <string.h>

 #include "ctest.h"

-void testStaticBuffer(Test* pTest)
+void testStaticBuffer(Test * pTest)
 {
-  STATIC_BUFFER sbuffer;
-  char *data1 = "Joshua";
-  char *data2 = "Anna";
-  char *data3 = "Christopher";
-  char *data4 = "Mary";
-  char data_buffer[480] = "";
-  char test_data_buffer[480] = "";
-  char *data;
-  unsigned count;
+    STATIC_BUFFER sbuffer;
+    char *data1 = "Joshua";
+    char *data2 = "Anna";
+    char *data3 = "Christopher";
+    char *data4 = "Mary";
+    char data_buffer[480] = "";
+    char test_data_buffer[480] = "";
+    char *data;
+    unsigned count;

-  sbuf_init(&sbuffer,NULL,0);
-  ct_test(pTest,sbuf_empty(&sbuffer) == true);
-  ct_test(pTest,sbuf_data(&sbuffer) == NULL);
-  ct_test(pTest,sbuf_size(&sbuffer) == 0);
-  ct_test(pTest,sbuf_count(&sbuffer) == 0);
-  ct_test(pTest,sbuf_append(&sbuffer,data1,strlen(data1)) == false);
+    sbuf_init(&sbuffer, NULL, 0);
+    ct_test(pTest, sbuf_empty(&sbuffer) == true);
+    ct_test(pTest, sbuf_data(&sbuffer) == NULL);
+    ct_test(pTest, sbuf_size(&sbuffer) == 0);
+    ct_test(pTest, sbuf_count(&sbuffer) == 0);
+    ct_test(pTest, sbuf_append(&sbuffer, data1, strlen(data1)) == false);

-  sbuf_init(&sbuffer,data_buffer,sizeof(data_buffer));
-  ct_test(pTest,sbuf_empty(&sbuffer) == true);
-  ct_test(pTest,sbuf_data(&sbuffer) == data_buffer);
-  ct_test(pTest,sbuf_size(&sbuffer) == sizeof(data_buffer));
-  ct_test(pTest,sbuf_count(&sbuffer) == 0);
-  
-  ct_test(pTest,sbuf_append(&sbuffer,data1,strlen(data1)) == true);
-  ct_test(pTest,sbuf_append(&sbuffer,data2,strlen(data2)) == true);
-  ct_test(pTest,sbuf_append(&sbuffer,data3,strlen(data3)) == true);
-  ct_test(pTest,sbuf_append(&sbuffer,data4,strlen(data4)) == true);
-  strcat(test_data_buffer,data1);
-  strcat(test_data_buffer,data2);
-  strcat(test_data_buffer,data3);
-  strcat(test_data_buffer,data4);
-  ct_test(pTest,sbuf_count(&sbuffer) == strlen(test_data_buffer));
+    sbuf_init(&sbuffer, data_buffer, sizeof(data_buffer));
+    ct_test(pTest, sbuf_empty(&sbuffer) == true);
+    ct_test(pTest, sbuf_data(&sbuffer) == data_buffer);
+    ct_test(pTest, sbuf_size(&sbuffer) == sizeof(data_buffer));
+    ct_test(pTest, sbuf_count(&sbuffer) == 0);

-  data = sbuf_data(&sbuffer);
-  count = sbuf_count(&sbuffer);
-  ct_test(pTest,memcmp(data,test_data_buffer,count) == 0);
-  ct_test(pTest,count == strlen(test_data_buffer));
-  
-  ct_test(pTest,sbuf_truncate(&sbuffer,0) == true);
-  ct_test(pTest,sbuf_count(&sbuffer) == 0);
-  ct_test(pTest,sbuf_size(&sbuffer) == sizeof(data_buffer));
-  ct_test(pTest,sbuf_append(&sbuffer,data4,strlen(data4)) == true);
-  data = sbuf_data(&sbuffer);
-  count = sbuf_count(&sbuffer);
-  ct_test(pTest,memcmp(data,data4,count) == 0);
-  ct_test(pTest,count == strlen(data4));
+    ct_test(pTest, sbuf_append(&sbuffer, data1, strlen(data1)) == true);
+    ct_test(pTest, sbuf_append(&sbuffer, data2, strlen(data2)) == true);
+    ct_test(pTest, sbuf_append(&sbuffer, data3, strlen(data3)) == true);
+    ct_test(pTest, sbuf_append(&sbuffer, data4, strlen(data4)) == true);
+    strcat(test_data_buffer, data1);
+    strcat(test_data_buffer, data2);
+    strcat(test_data_buffer, data3);
+    strcat(test_data_buffer, data4);
+    ct_test(pTest, sbuf_count(&sbuffer) == strlen(test_data_buffer));

-  return;
+    data = sbuf_data(&sbuffer);
+    count = sbuf_count(&sbuffer);
+    ct_test(pTest, memcmp(data, test_data_buffer, count) == 0);
+    ct_test(pTest, count == strlen(test_data_buffer));
+
+    ct_test(pTest, sbuf_truncate(&sbuffer, 0) == true);
+    ct_test(pTest, sbuf_count(&sbuffer) == 0);
+    ct_test(pTest, sbuf_size(&sbuffer) == sizeof(data_buffer));
+    ct_test(pTest, sbuf_append(&sbuffer, data4, strlen(data4)) == true);
+    data = sbuf_data(&sbuffer);
+    count = sbuf_count(&sbuffer);
+    ct_test(pTest, memcmp(data, data4, count) == 0);
+    ct_test(pTest, count == strlen(data4));
+
+    return;
 }

 #ifdef TEST_STATIC_BUFFER
 int main(void)
 {
-  Test *pTest;
-  bool rc;
+    Test *pTest;
+    bool rc;

-  pTest = ct_create("static buffer", NULL);
+    pTest = ct_create("static buffer", NULL);

-  /* individual tests */
-  rc = ct_addTestFunction(pTest, testStaticBuffer);
-  assert(rc);
+    /* individual tests */
+    rc = ct_addTestFunction(pTest, testStaticBuffer);
+    assert(rc);

-  ct_setStream(pTest, stdout);
-  ct_run(pTest);
-  (void)ct_report(pTest);
+    ct_setStream(pTest, stdout);
+    ct_run(pTest);
+    (void) ct_report(pTest);

-  ct_destroy(pTest);
+    ct_destroy(pTest);

-  return 0;
+    return 0;
 }
-#endif /* TEST_STATIC_BUFFER */
-#endif /* TEST */
-
+#endif                          /* TEST_STATIC_BUFFER */
+#endif                          /* TEST */