Changed style of the code to the K&R standard

1 files changed, 240 insertions, 254 deletions

diff --git a/src/base/space.c b/src/base/space.c
index dff34c5..0988011 100644
--- a/src/base/space.c
+++ b/src/base/space.c
@@ -9,378 +9,364 @@
 #include "space.h"
 #include "index.h"
 
-zone_t *
-newZone()
+zone_t *newZone()
 {
-    zone_t *new;
+	zone_t *new;
 
-    new = malloc(sizeof(zone_t));
-    new->list = newList();
+	new = malloc(sizeof(zone_t));
+	new->list = newList();
 
-    return new;
+	return new;
 }
 
-void
-destroyZone(zone_t * p)
+void destroyZone(zone_t * p)
 {
-    assert(p != NULL);
+	assert(p != NULL);
 
-    destroyList(p->list);
-    free(p);
+	destroyList(p->list);
+	free(p);
 }
 
 static int
 my_conflictSpace(int x1, int y1, int w1, int h1, int x2, int y2, int w2,
-                 int h2)
+				 int h2)
 {
-    return (x1 < x2 + w2 && x2 < x1 + w1 && y1 < y2 + h2 && y2 < y1 + h1);
+	return (x1 < x2 + w2 && x2 < x1 + w1 && y1 < y2 + h2 && y2 < y1 + h1);
 }
 
-space_t *
-newSpace(int w, int h, int segW, int segH,
-         void (*getStatus) (void *p, int *id, int *x, int *y, int *w, int *h),
-         void (*setStatus) (void *p, int x, int y, int w, int h))
+space_t *newSpace(int w, int h, int segW, int segH,
+				  void (*getStatus) (void *p, int *id, int *x, int *y, int *w,
+									 int *h), void (*setStatus) (void *p,
+																 int x, int y,
+																 int w, int h))
 {
-    space_t *new;
-    int i, j;
+	space_t *new;
+	int i, j;
 
-    new = malloc(sizeof(space_t));
-    memset(new, 0, sizeof(space_t));
+	new = malloc(sizeof(space_t));
+	memset(new, 0, sizeof(space_t));
 
-    new->w = w / segW + 1;
-    new->h = h / segH + 1;
-    new->segW = segW;
-    new->segH = segH;
-    new->getStatus = getStatus;
-    new->setStatus = setStatus;
-    new->listIndex = newIndex();
+	new->w = w / segW + 1;
+	new->h = h / segH + 1;
+	new->segW = segW;
+	new->segH = segH;
+	new->getStatus = getStatus;
+	new->setStatus = setStatus;
+	new->listIndex = newIndex();
 
-    new->zone = malloc(new->w * sizeof(list_t **));
+	new->zone = malloc(new->w * sizeof(list_t **));
 
-    for (i = 0; i < new->w; i++) {
-        new->zone[i] = malloc(new->h * sizeof(list_t *));
-    }
+	for (i = 0; i < new->w; i++) {
+		new->zone[i] = malloc(new->h * sizeof(list_t *));
+	}
 
-    for (i = 0; i < new->h; i++) {
-        for (j = 0; j < new->w; j++) {
-            new->zone[j][i] = newZone();
-        }
-    }
+	for (i = 0; i < new->h; i++) {
+		for (j = 0; j < new->w; j++) {
+			new->zone[j][i] = newZone();
+		}
+	}
 
-    return new;
+	return new;
 }
 
 static void
 getSegment(space_t * p, int x, int y, int w, int h,
-           int *segX, int *segY, int *segW, int *segH)
+		   int *segX, int *segY, int *segW, int *segH)
 {
-    *segX = x / p->segW;
-    *segY = y / p->segH;
-    *segW = ((x + w) / p->segW + 1) - *segX;
-    *segH = ((y + h) / p->segH + 1) - *segY;
+	*segX = x / p->segW;
+	*segY = y / p->segH;
+	*segW = ((x + w) / p->segW + 1) - *segX;
+	*segH = ((y + h) / p->segH + 1) - *segY;
 }
 
-int
-getSpaceCount(space_t * p)
+int getSpaceCount(space_t * p)
 {
-    return p->listIndex->count;
+	return p->listIndex->count;
 }
 
-void *
-getItemFromSpace(space_t * p, int offset)
+void *getItemFromSpace(space_t * p, int offset)
 {
-    index_item_t *this;
+	index_item_t *this;
 
-    this = (index_item_t *) p->listIndex->list[offset];
-    return this->data;
+	this = (index_item_t *) p->listIndex->list[offset];
+	return this->data;
 }
 
-void
-addObjectToSpace(space_t * p, void *item)
+void addObjectToSpace(space_t * p, void *item)
 {
-    int segX, segY, segW, segH;
-    int id, x, y, w, h;
-    int i, j;
+	int segX, segY, segW, segH;
+	int id, x, y, w, h;
+	int i, j;
 
-    p->getStatus(item, &id, &x, &y, &w, &h);
-    getSegment(p, x, y, w, h, &segX, &segY, &segW, &segH);
+	p->getStatus(item, &id, &x, &y, &w, &h);
+	getSegment(p, x, y, w, h, &segX, &segY, &segW, &segH);
 
-    for (i = segY; i < segY + segH; i++) {
-        for (j = segX; j < segX + segW; j++) {
-            if (j < 0 || j >= p->w || i < 0 || i >= p->h) {
-                continue;
-            }
+	for (i = segY; i < segY + segH; i++) {
+		for (j = segX; j < segX + segW; j++) {
+			if (j < 0 || j >= p->w || i < 0 || i >= p->h) {
+				continue;
+			}
 
-            addList(p->zone[j][i]->list, item);
-        }
-    }
+			addList(p->zone[j][i]->list, item);
+		}
+	}
 
-    addToIndex(p->listIndex, id, item);
+	addToIndex(p->listIndex, id, item);
 }
 
-void
-getObjectFromSpace(space_t * p, int x, int y, int w, int h, list_t * list)
+void getObjectFromSpace(space_t * p, int x, int y, int w, int h, list_t * list)
 {
-    int segX, segY, segW, segH;
-    int id, this_x, this_y, this_w, this_h;
-    int i, j, k;
-
-    getSegment(p, x, y, w, h, &segX, &segY, &segW, &segH);
-
-    for (i = segY; i < segY + segH; i++) {
-        for (j = segX; j < segX + segW; j++) {
-            void *this;
-
-            if (j < 0 || j >= p->w || i < 0 || i >= p->h) {
-                continue;
-            }
-
-            for (k = 0; k < p->zone[j][i]->list->count; k++) {
-                this = p->zone[j][i]->list->list[k];
-                p->getStatus(this, &id, &this_x, &this_y, &this_w, &this_h);
-
-                if (my_conflictSpace
-                    (x, y, w, h, this_x, this_y, this_w, this_h)
-                    && searchListItem(list, this) == -1) {
-                    addList(list, this);
-                }
-            }
-        }
-    }
+	int segX, segY, segW, segH;
+	int id, this_x, this_y, this_w, this_h;
+	int i, j, k;
+
+	getSegment(p, x, y, w, h, &segX, &segY, &segW, &segH);
+
+	for (i = segY; i < segY + segH; i++) {
+		for (j = segX; j < segX + segW; j++) {
+			void *this;
+
+			if (j < 0 || j >= p->w || i < 0 || i >= p->h) {
+				continue;
+			}
+
+			for (k = 0; k < p->zone[j][i]->list->count; k++) {
+				this = p->zone[j][i]->list->list[k];
+				p->getStatus(this, &id, &this_x, &this_y, &this_w, &this_h);
+
+				if (my_conflictSpace
+					(x, y, w, h, this_x, this_y, this_w, this_h)
+					&& searchListItem(list, this) == -1) {
+					addList(list, this);
+				}
+			}
+		}
+	}
 }
 
-void *
-getObjectFromSpaceWithID(space_t * space, int id)
+void *getObjectFromSpaceWithID(space_t * space, int id)
 {
-    return getFromIndex(space->listIndex, id);
+	return getFromIndex(space->listIndex, id);
 }
 
-int
-isConflictWithObjectFromSpace(space_t * p, int x, int y, int w, int h)
+int isConflictWithObjectFromSpace(space_t * p, int x, int y, int w, int h)
 {
-    int segX, segY, segW, segH;
-    int id, this_x, this_y, this_w, this_h;
-    int i, j, k;
+	int segX, segY, segW, segH;
+	int id, this_x, this_y, this_w, this_h;
+	int i, j, k;
 
-    getSegment(p, x, y, w, h, &segX, &segY, &segW, &segH);
+	getSegment(p, x, y, w, h, &segX, &segY, &segW, &segH);
 
-    for (i = segY; i < segY + segH; i++) {
-        for (j = segX; j < segX + segW; j++) {
-            void *this;
+	for (i = segY; i < segY + segH; i++) {
+		for (j = segX; j < segX + segW; j++) {
+			void *this;
 
-            if (j < 0 || j >= p->w || i < 0 || i >= p->h) {
-                continue;
-            }
+			if (j < 0 || j >= p->w || i < 0 || i >= p->h) {
+				continue;
+			}
 
-            for (k = 0; k < p->zone[j][i]->list->count; k++) {
-                this = p->zone[j][i]->list->list[k];
-                p->getStatus(this, &id, &this_x, &this_y, &this_w, &this_h);
+			for (k = 0; k < p->zone[j][i]->list->count; k++) {
+				this = p->zone[j][i]->list->list[k];
+				p->getStatus(this, &id, &this_x, &this_y, &this_w, &this_h);
 
-                if (my_conflictSpace
-                    (x, y, w, h, this_x, this_y, this_w, this_h)) {
-                    return 1;
-                }
-            }
-        }
-    }
+				if (my_conflictSpace
+					(x, y, w, h, this_x, this_y, this_w, this_h)) {
+					return 1;
+				}
+			}
+		}
+	}
 
-    return 0;
+	return 0;
 }
 
 int
 isConflictWithObjectFromSpaceBut(space_t * p, int x, int y, int w, int h,
-                                 void *but)
+								 void *but)
 {
-    int segX, segY, segW, segH;
-    int id, this_x, this_y, this_w, this_h;
-    int i, j, k;
+	int segX, segY, segW, segH;
+	int id, this_x, this_y, this_w, this_h;
+	int i, j, k;
 
-    getSegment(p, x, y, w, h, &segX, &segY, &segW, &segH);
+	getSegment(p, x, y, w, h, &segX, &segY, &segW, &segH);
 
-    for (i = segY; i < segY + segH; i++) {
-        for (j = segX; j < segX + segW; j++) {
-            void *this;
+	for (i = segY; i < segY + segH; i++) {
+		for (j = segX; j < segX + segW; j++) {
+			void *this;
 
-            if (j < 0 || j >= p->w || i < 0 || i >= p->h) {
-                continue;
-            }
+			if (j < 0 || j >= p->w || i < 0 || i >= p->h) {
+				continue;
+			}
 
-            for (k = 0; k < p->zone[j][i]->list->count; k++) {
-                this = p->zone[j][i]->list->list[k];
+			for (k = 0; k < p->zone[j][i]->list->count; k++) {
+				this = p->zone[j][i]->list->list[k];
 
-                if (this == but) {
-                    continue;
-                }
+				if (this == but) {
+					continue;
+				}
 
-                p->getStatus(this, &id, &this_x, &this_y, &this_w, &this_h);
+				p->getStatus(this, &id, &this_x, &this_y, &this_w, &this_h);
 
-                if (my_conflictSpace
-                    (x, y, w, h, this_x, this_y, this_w, this_h)) {
-                    return 1;
-                }
-            }
-        }
-    }
+				if (my_conflictSpace
+					(x, y, w, h, this_x, this_y, this_w, this_h)) {
+					return 1;
+				}
+			}
+		}
+	}
 
-    return 0;
+	return 0;
 }
 
-void
-delObjectFromSpace(space_t * p, void *item)
+void delObjectFromSpace(space_t * p, void *item)
 {
-    int segX, segY, segW, segH;
-    int id, x, y, w, h;
-    int index;
-    int i, j;
-
-    p->getStatus(item, &id, &x, &y, &w, &h);
-    getSegment(p, x, y, w, h, &segX, &segY, &segW, &segH);
-
-    for (i = segY; i < segY + segH; i++) {
-        for (j = segX; j < segX + segW; j++) {
-            if (j < 0 || j >= p->w || i < 0 || i >= p->h) {
-                continue;
-            }
-
-            index = searchListItem(p->zone[j][i]->list, item);
-            assert(index != -1);
-            delList(p->zone[j][i]->list, index);
-        }
-    }
-
-    delFromIndex(p->listIndex, id);
+	int segX, segY, segW, segH;
+	int id, x, y, w, h;
+	int index;
+	int i, j;
+
+	p->getStatus(item, &id, &x, &y, &w, &h);
+	getSegment(p, x, y, w, h, &segX, &segY, &segW, &segH);
+
+	for (i = segY; i < segY + segH; i++) {
+		for (j = segX; j < segX + segW; j++) {
+			if (j < 0 || j >= p->w || i < 0 || i >= p->h) {
+				continue;
+			}
+
+			index = searchListItem(p->zone[j][i]->list, item);
+			assert(index != -1);
+			delList(p->zone[j][i]->list, index);
+		}
+	}
+
+	delFromIndex(p->listIndex, id);
 }
 
-void
-delObjectFromSpaceWithObject(space_t * p, void *item, void *f)
+void delObjectFromSpaceWithObject(space_t * p, void *item, void *f)
 {
-    void (*fce) (void *param);
+	void (*fce) (void *param);
 
-    fce = f;
+	fce = f;
 
-    delObjectFromSpace(p, item);
-    fce(item);
+	delObjectFromSpace(p, item);
+	fce(item);
 }
 
-void
-moveObjectInSpace(space_t * p, void *item, int move_x, int move_y)
+void moveObjectInSpace(space_t * p, void *item, int move_x, int move_y)
 {
-    int old_segX, old_segY, old_segW, old_segH;
-    int new_segX, new_segY, new_segW, new_segH;
-    int id, x, y, w, h;
-
-    p->getStatus(item, &id, &x, &y, &w, &h);
-    getSegment(p, x, y, w, h, &old_segX, &old_segY, &old_segW, &old_segH);
-    getSegment(p, move_x, move_y, w, h, &new_segX, &new_segY, &new_segW,
-               &new_segH);
+	int old_segX, old_segY, old_segW, old_segH;
+	int new_segX, new_segY, new_segW, new_segH;
+	int id, x, y, w, h;
+
+	p->getStatus(item, &id, &x, &y, &w, &h);
+	getSegment(p, x, y, w, h, &old_segX, &old_segY, &old_segW, &old_segH);
+	getSegment(p, move_x, move_y, w, h, &new_segX, &new_segY, &new_segW,
+			   &new_segH);
 /*
 	printf("%d %d %d %d  -> %d %d %d %d \n",
 		old_segX, old_segY, old_segW, old_segH,
 		new_segX, new_segY, new_segW, new_segH);
 */
-    if (old_segX != new_segX || old_segY != new_segY ||
-        old_segW != new_segW || old_segH != new_segH) {
-        delObjectFromSpace(p, item);
-        p->setStatus(item, move_x, move_y, w, h);
-        addObjectToSpace(p, item);
-        return;
-    }
-
-    p->setStatus(item, move_x, move_y, w, h);
+	if (old_segX != new_segX || old_segY != new_segY ||
+		old_segW != new_segW || old_segH != new_segH) {
+		delObjectFromSpace(p, item);
+		p->setStatus(item, move_x, move_y, w, h);
+		addObjectToSpace(p, item);
+		return;
+	}
+
+	p->setStatus(item, move_x, move_y, w, h);
 }
 
-void
-printSpace(space_t * p)
+void printSpace(space_t * p)
 {
-    int i, j;
+	int i, j;
 
-    printf("print space : \n");
+	printf("print space : \n");
 
-    for (i = 0; i < p->h; i++) {
-        for (j = 0; j < p->w; j++) {
-            printf("%3d ", p->zone[j][i]->list->count);
-        }
+	for (i = 0; i < p->h; i++) {
+		for (j = 0; j < p->w; j++) {
+			printf("%3d ", p->zone[j][i]->list->count);
+		}
 
-        putchar('\n');
-    }
+		putchar('\n');
+	}
 }
 
-void
-actionSpace(space_t * space, void *f, void *p)
+void actionSpace(space_t * space, void *f, void *p)
 {
-    void (*fce) (space_t * space, void *f, void *p);
-    int len;
-    int i;
+	void (*fce) (space_t * space, void *f, void *p);
+	int len;
+	int i;
 
-    fce = f;
-    len = space->listIndex->count;
+	fce = f;
+	len = space->listIndex->count;
 
-    for (i = 0; i < len; i++) {
-        fce(space, getItemFromSpace(space, i), p);
+	for (i = 0; i < len; i++) {
+		fce(space, getItemFromSpace(space, i), p);
 
-        if (space->listIndex->count == len - 1) {
-            len--;
-            i--;
-        }
-    }
+		if (space->listIndex->count == len - 1) {
+			len--;
+			i--;
+		}
+	}
 }
 
 void
 actionSpaceFromLocation(space_t * space, void *f, void *p, int x, int y,
-                        int w, int h)
+						int w, int h)
 {
-    void (*fce) (space_t * space, void *f, void *p);
-    list_t *list;
-    int len;
-    int i;
+	void (*fce) (space_t * space, void *f, void *p);
+	list_t *list;
+	int len;
+	int i;
 
-    fce = f;
+	fce = f;
 
-    list = newList();
+	list = newList();
 
-    getObjectFromSpace(space, x, y, w, h, list);
+	getObjectFromSpace(space, x, y, w, h, list);
 
-    len = list->count;
+	len = list->count;
 
-    for (i = 0; i < len; i++) {
-        fce(space, list->list[i], p);
-    }
+	for (i = 0; i < len; i++) {
+		fce(space, list->list[i], p);
+	}
 
-    destroyList(list);
+	destroyList(list);
 }
 
-void
-destroySpace(space_t * p)
+void destroySpace(space_t * p)
 {
-    int j, i;
+	int j, i;
 
-    destroyIndex(p->listIndex);
+	destroyIndex(p->listIndex);
 
-    for (i = 0; i < p->h; i++) {
-        for (j = 0; j < p->w; j++) {
-            destroyZone(p->zone[j][i]);
-        }
-    }
+	for (i = 0; i < p->h; i++) {
+		for (j = 0; j < p->w; j++) {
+			destroyZone(p->zone[j][i]);
+		}
+	}
 
-    for (i = 0; i < p->w; i++) {
-        free(p->zone[i]);
-    }
+	for (i = 0; i < p->w; i++) {
+		free(p->zone[i]);
+	}
 
-    free(p->zone);
-    free(p);
+	free(p->zone);
+	free(p);
 }
 
-void
-destroySpaceWithObject(space_t * p, void *f)
+void destroySpaceWithObject(space_t * p, void *f)
 {
-    void (*fce) (void *param);
-    int i;
+	void (*fce) (void *param);
+	int i;
 
-    fce = f;
+	fce = f;
 
-    for (i = 0; i < p->listIndex->count; i++) {
-        fce(getItemFromSpace(p, i));
-    }
+	for (i = 0; i < p->listIndex->count; i++) {
+		fce(getItemFromSpace(p, i));
+	}
 
-    destroySpace(p);
+	destroySpace(p);
 }