astyle.

more BSD style in return (FOO);

1 files changed, 44 insertions, 44 deletions

diff --git a/src/data/dat.c b/src/data/dat.c
index 35aa3d5..82fd42e 100644
--- a/src/data/dat.c
+++ b/src/data/dat.c
@@ -1,13 +1,13 @@
 /*:*
  *: File: ./src/data/dat.c
  *: A simple interpreter
- *: 
+ *:
  *: WWW		: http://fype.buetow.org
  *: E-Mail	: fype@dev.buetow.org
- *: 
- *: Copyright (c) 2005 2006 2007 2008, Paul C. Buetow 
+ *:
+ *: Copyright (c) 2005 2006 2007 2008, Paul C. Buetow
  *: All rights reserved.
- *: 
+ *:
  *: Redistribution and use in source and binary forms, with or without modi-
  *: fication, are permitted provided that the following conditions are met:
  *:  * Redistributions of source code must retain the above copyright
@@ -15,20 +15,20 @@
  *:  * Redistributions in binary form must reproduce the above copyright
  *:    notice, this list of conditions and the following disclaimer in the
  *:    documentation and/or other materials provided with the distribution.
- *:  * Neither the name of P. B. Labs nor the names of its contributors may 
- *:    be used to endorse or promote products derived from this software 
+ *:  * Neither the name of P. B. Labs nor the names of its contributors may
+ *:    be used to endorse or promote products derived from this software
  *:    without specific prior written permission.
- *: 
- *: THIS SOFTWARE IS PROVIDED BY Paul Buetow AS IS'' AND ANY EXPRESS OR 
- *: IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+ *:
+ *: THIS SOFTWARE IS PROVIDED BY Paul Buetow AS IS'' AND ANY EXPRESS OR
+ *: IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  *: WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- *: DISCLAIMED. IN NO EVENT SHALL Paul Buetow BE LIABLE FOR ANY DIRECT, 
- *: INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
- *: (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
- *:  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
+ *: DISCLAIMED. IN NO EVENT SHALL Paul Buetow BE LIABLE FOR ANY DIRECT,
+ *: INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ *: (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ *:  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  *: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- *: STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
- *: IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+ *: STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ *: IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  *: POSSIBILITY OF SUCH DAMAGE.
  *:*/
 
@@ -44,12 +44,12 @@ dat_new() {
    p_dat->p_last = 0;
    p_dat->i_size = 0;
 
-   return p_dat;
+   return (p_dat);
 }
 
 DatElem*
 datelem_new() {
-   return datelem_new_t(TYPE_UNKNOWN);
+   return (datelem_new_t(TYPE_UNKNOWN));
 }
 
 DatElem*
@@ -60,15 +60,15 @@ datelem_new_t(TYPE type) {
    p_elem->p_val = 0;
    p_elem->type = type;
 
-   return p_elem;
+   return (p_elem);
 }
 
 _Bool
 dat_empty(Dat *p_dat) {
    if (p_dat == NULL)
-      return 0;
+      return (false);
 
-   return p_dat->i_size == 0;
+   return (p_dat->i_size == 0);
 }
 
 void
@@ -92,13 +92,13 @@ dat_push_t(Dat *p_dat, void *p_val, TYPE type) {
 void*
 dat_pop(Dat *p_dat) {
    TYPE type;
-   return dat_pop_t(p_dat, &type);
+   return (dat_pop_t(p_dat, &type));
 }
 
 void*
 dat_pop_t(Dat *p_dat, TYPE *p_type) {
    if (dat_empty(p_dat))
-      return 0;
+      return (NULL);
 
    DatElem *p_elem = p_dat->p_first;
    p_dat->p_first = p_elem->p_next;
@@ -108,7 +108,7 @@ dat_pop_t(Dat *p_dat, TYPE *p_type) {
    void *p_ret =  p_elem->p_val;
    *p_type = p_elem->type;
    free(p_elem);
-   return p_ret;
+   return (p_ret);
 }
 
 void
@@ -124,7 +124,7 @@ dat_delete(Dat *p_dat) {
 
 unsigned
 dat_size(Dat *p_dat) {
-   return p_dat->i_size;
+   return (p_dat->i_size);
 }
 
 void
@@ -163,52 +163,52 @@ dat_iterate_tl(Dat *p_dat, void (*func)(void *, TYPE, _Bool)) {
 void*
 dat_first(Dat *p_dat) {
    if (dat_empty(p_dat))
-      return NULL;
+      return (NULL);
 
-   return p_dat->p_first->p_val;
+   return (p_dat->p_first->p_val);
 }
 
 void*
 dat_second(Dat *p_dat) {
-   if ( 2 > dat_size(p_dat))
-      return NULL;
+   if (2 > dat_size(p_dat))
+      return (NULL);
 
-   return p_dat->p_first->p_next->p_val;
+   return (p_dat->p_first->p_next->p_val);
 }
 
 void*
 dat_last(Dat *p_dat) {
    if (dat_empty(p_dat))
-      return NULL;
+      return (NULL);
 
-   return p_dat->p_last->p_val;
+   return (p_dat->p_last->p_val);
 }
 
 void*
 dat_first_t(Dat *p_dat, TYPE *p_type) {
    if (dat_empty(p_dat))
-      return NULL;
+      return (NULL);
 
    *p_type = p_dat->p_first->type;
-   return p_dat->p_first->p_val;
+   return (p_dat->p_first->p_val);
 }
 
 void*
 dat_second_t(Dat *p_dat, TYPE *p_type) {
-   if ( 2 > dat_size(p_dat))
-      return NULL;
+   if (2 > dat_size(p_dat))
+      return (NULL);
 
    *p_type = p_dat->p_first->p_next->type;
-   return p_dat->p_first->p_next->p_val;
+   return (p_dat->p_first->p_next->p_val);
 }
 
 void*
 dat_last_t(Dat *p_dat, TYPE *p_type) {
    if (dat_empty(p_dat))
-      return NULL;
+      return (NULL);
 
    *p_type = p_dat->p_last->type;
-   return p_dat->p_last->p_val;
+   return (p_dat->p_last->p_val);
 }
 
 DatIter*
@@ -221,7 +221,7 @@ datiter_new(Dat *p_dat) {
    p_iter->i_left = dat_size(p_dat);
    p_iter->p_dat = p_dat;
 
-   return p_iter;
+   return (p_iter);
 }
 
 void
@@ -238,13 +238,13 @@ datiter_skip(DatIter *p_iter, unsigned i_num) {
 void*
 datiter_next(DatIter *p_iter) {
    TYPE type;
-   return datiter_next_t(p_iter, &type);
+   return (datiter_next_t(p_iter, &type));
 }
 
 void*
 datiter_next_t(DatIter *p_iter, TYPE *p_type) {
    if (p_iter->p_next == NULL)
-      return NULL;
+      return (NULL);
 
    void *p_ret = p_iter->p_next->p_val;
    *p_type = p_iter->p_next->type;
@@ -252,16 +252,16 @@ datiter_next_t(DatIter *p_iter, TYPE *p_type) {
    p_iter->p_next = p_iter->p_next->p_next;
    --p_iter->i_left;
 
-   return p_ret;
+   return (p_ret);
 }
 
 unsigned
 datiter_left(DatIter *p_iter) {
-   return p_iter->i_left;
+   return (p_iter->i_left);
 }
 
 Dat*
 datiter_dat(DatIter *p_iter) {
-   return p_iter->p_dat;
+   return (p_iter->p_dat);
 }