format and clean up code

git-svn-id: https://svn.osgeo.org/grass/grass/trunk@39648 15284696-431f-4ddb-bdfa-cd5b030d7da7

lib/segment/address.c

@@ -14,41 +14,47 @@
 
 #include <grass/segment.h>
 
-int segment_address_fast(const SEGMENT * SEG, int row, int col, int *n, int *index)
+int segment_address_fast(const SEGMENT * SEG, int row, int col, int *n,
+			 int *index)
 {
     if (row) {
-        int seg_r = row >> SEG->srowbits;
-        int seg_c = col >> SEG->scolbits;
-     
-        *n = seg_r * SEG->spr + seg_c;
-        *index = ((row - (seg_r << SEG->srowbits)) << SEG->scolbits) + col - (seg_c << SEG->scolbits);
+	int seg_r = row >> SEG->srowbits;
+	int seg_c = col >> SEG->scolbits;
+
+	*n = seg_r * SEG->spr + seg_c;
+	*index =
+	    ((row - (seg_r << SEG->srowbits)) << SEG->scolbits) + col -
+	    (seg_c << SEG->scolbits);
     }
     /* for simple arrays */
     else {
-        *n = col >> SEG->scolbits;
-        *index = col - ((*n) << SEG->scolbits);
+	*n = col >> SEG->scolbits;
+	*index = col - ((*n) << SEG->scolbits);
     }
     if (SEG->slow_seek == 0)
-        *index = *index << SEG->lenbits;
+	*index = *index << SEG->lenbits;
     else
-        *index *= SEG->len;
+	*index *= SEG->len;
 
     return 0;
 }
 
-int segment_address_slow(const SEGMENT * SEG, int row, int col, int *n, int *index)
+int segment_address_slow(const SEGMENT * SEG, int row, int col, int *n,
+			 int *index)
 {
     if (row) {
-        int seg_r = row / SEG->srows;
-        int seg_c = col / SEG->scols;
+	int seg_r = row / SEG->srows;
+	int seg_c = col / SEG->scols;
 
-        *n = seg_r * SEG->spr + seg_c;
-        *index = (row - seg_r * SEG->srows) * SEG->scols + col - seg_c * SEG->scols;
+	*n = seg_r * SEG->spr + seg_c;
+	*index =
+	    (row - seg_r * SEG->srows) * SEG->scols + col -
+	    seg_c * SEG->scols;
     }
     /* for simple arrays */
     else {
-        *n = col / SEG->scols;
-        *index = col - *n * SEG->scols;
+	*n = col / SEG->scols;
+	*index = col - *n * SEG->scols;
     }
     *index *= SEG->len;
 
@@ -56,8 +62,7 @@ int segment_address_slow(const SEGMENT * SEG, int row, int col, int *n, int *ind
 }
 
 static int (*segment_adrs[2]) () = {
-    segment_address_fast, segment_address_slow
-};
+segment_address_fast, segment_address_slow};
 
 /**
  * \fn int segment_address (SEGMENT *SEG, int row, int col, int *n, int *index)
@@ -75,12 +80,12 @@ static int (*segment_adrs[2]) () = {
 int segment_address(const SEGMENT * SEG, int row, int col, int *n, int *index)
 {
     /* old code
-    *n = row / SEG->srows * SEG->spr + col / SEG->scols;
-    *index = (row % SEG->srows * SEG->scols + col % SEG->scols) * SEG->len;
-    */
+     *n = row / SEG->srows * SEG->spr + col / SEG->scols;
+     *index = (row % SEG->srows * SEG->scols + col % SEG->scols) * SEG->len;
+     */
 
     /* this function is called at least once every time data are accessed in SEG
      * avoid very slow modulus and divisions, modulus was the main time killer */
 
-    return (*segment_adrs[SEG->slow_adrs])(SEG, row, col, n, index);
+    return (*segment_adrs[SEG->slow_adrs]) (SEG, row, col, n, index);
 }

lib/segment/pagein.c

@@ -43,7 +43,7 @@ int segment_pagein(SEGMENT * SEG, int n)
     /* is n the current segment? */
     if (n == SEG->scb[SEG->cur].n)
 	return SEG->cur;
-	
+
     /* search the in memory segments */
     seg_search.i = 0;
     seg_search.n = n;
@@ -63,34 +63,37 @@ int segment_pagein(SEGMENT * SEG, int n)
 	    /* make it youngest */
 	    SEG->youngest = SEG->scb[cur].age;
 	}
-	
+
 	return SEG->cur = cur;
     }
-    
+
     /* find a slot to use to hold segment */
-    if (SEG->nfreeslots) {  /* any free slots left ? */
-	cur = SEG->freeslot[--SEG->nfreeslots];
-    }
-    else {	/* find oldest segment */
+    if (!SEG->nfreeslots) {
+	/* use oldest segment */
 	SEG->oldest = SEG->oldest->younger;
 	cur = SEG->oldest->cur;
 	SEG->oldest->cur = -1;
-	SEG->scb[cur].age = NULL;
-    }
 
-    /* if slot is used, write it out, if dirty */
-    if (SEG->scb[cur].n >= 0 && SEG->scb[cur].dirty) {
-	if (segment_pageout(SEG, cur) < 0)
-	    return -1;
+	/* unload segment (remove from search tree) */
+	if (SEG->scb[cur].n >= 0) {
+	    seg_search.n = SEG->scb[cur].n;
+	    if (rbtree_remove(SEG->loaded, &seg_search) == 0)
+		G_fatal_error("could not remove segment");
+	    seg_search.n = n;
+
+	    /* write it out if dirty */
+	    if (SEG->scb[cur].dirty) {
+		if (segment_pageout(SEG, cur) < 0)
+		    return -1;
+	    }
+	}
     }
-	
-    if (SEG->scb[cur].n >= 0) {
-	seg_search.n = SEG->scb[cur].n;
-	if (rbtree_remove(SEG->loaded, &seg_search) == 0)
-	    G_fatal_error("could not remove segment");
-	seg_search.n = n;
+    else {
+	/* free slots left */
+	cur = SEG->freeslot[--SEG->nfreeslots];
     }
 
+
     /* read in the segment */
     SEG->scb[cur].n = n;
     SEG->scb[cur].dirty = 0;
@@ -113,9 +116,6 @@ int segment_pagein(SEGMENT * SEG, int n)
 	return -1;
     }
 
-    if (cur < 0 || n < 0)
-	G_fatal_error("segment not loaded");
-
     /* remember loaded segment */
     seg_search.i = cur;
     if (rbtree_insert(SEG->loaded, &seg_search) == 0)
@@ -125,6 +125,6 @@ int segment_pagein(SEGMENT * SEG, int n)
     SEG->youngest = SEG->youngest->younger;
     SEG->scb[cur].age = SEG->youngest;
     SEG->youngest->cur = cur;
-    
+
     return SEG->cur = cur;
 }

lib/segment/put.c

@@ -47,8 +47,8 @@ int segment_put(SEGMENT * SEG, const void *buf, int row, int col)
 
     segment_address(SEG, row, col, &n, &index);
     if ((i = segment_pagein(SEG, n)) < 0) {
-        G_warning("segment lib: put: pagein failed");
-        return -1;
+	G_warning("segment lib: put: pagein failed");
+	return -1;
     }
 
     SEG->scb[i].dirty = 1;

lib/segment/rbtree.c

@@ -47,7 +47,7 @@ int is_red(struct RB_NODE *);
 /* create new tree and initialize
  * returns pointer to new tree, NULL for memory allocation error
  */
-struct RB_TREE *rbtree_create(rb_compare_fn *compare, size_t rb_datasize)
+struct RB_TREE *rbtree_create(rb_compare_fn * compare, size_t rb_datasize)
 {
     struct RB_TREE *tree = G_malloc(sizeof(*tree));
 
@@ -64,7 +64,7 @@ struct RB_TREE *rbtree_create(rb_compare_fn *compare, size_t rb_datasize)
     tree->root = NULL;
 
     return tree;
-} 
+}
 
 /* add an item to a tree
  * non-recursive top-down insertion
@@ -74,7 +74,7 @@ struct RB_TREE *rbtree_create(rb_compare_fn *compare, size_t rb_datasize)
 int rbtree_insert(struct RB_TREE *tree, void *data)
 {
     assert(tree && data);
-    
+
     if (tree->root == NULL) {
 	/* create a new root node for tree */
 	tree->root = rbtree_make_node(tree->datasize, data);
@@ -82,10 +82,12 @@ int rbtree_insert(struct RB_TREE *tree, void *data)
 	    return 0;
     }
     else {
-	struct RB_NODE head = {0}; /* False tree root */
+	struct RB_NODE head = { 0 };	/* False tree root */
+
+	struct RB_NODE *g, *t;	/* Grandparent & parent */
+
+	struct RB_NODE *p, *q;	/* Iterator & parent */
 
-	struct RB_NODE *g, *t;     /* Grandparent & parent */
-	struct RB_NODE *p, *q;     /* Iterator & parent */
 	int dir = 0, last = 0;
 
 	/* Set up helpers */
@@ -94,7 +96,7 @@ int rbtree_insert(struct RB_TREE *tree, void *data)
 	q = t->link[1] = tree->root;
 
 	/* Search down the tree */
-	for ( ; ; ) {
+	for (;;) {
 	    if (q == NULL) {
 		/* Insert new node at the bottom */
 		p->link[dir] = q = rbtree_make_node(tree->datasize, data);
@@ -154,15 +156,15 @@ int rbtree_insert(struct RB_TREE *tree, void *data)
  */
 int rbtree_remove(struct RB_TREE *tree, const void *data)
 {
-    struct RB_NODE head = {0}; /* False tree root */
-    struct RB_NODE *q, *p, *g; /* Helpers */
-    struct RB_NODE *f = NULL;  /* Found item */
+    struct RB_NODE head = { 0 };	/* False tree root */
+    struct RB_NODE *q, *p, *g;	/* Helpers */
+    struct RB_NODE *f = NULL;	/* Found item */
     int dir = 1, removed = 0;
 
     assert(tree && data);
 
     if (tree->root == NULL) {
-	return 0; /* empty tree, nothing to remove */
+	return 0;		/* empty tree, nothing to remove */
     }
 
     /* Set up helpers */
@@ -193,8 +195,7 @@ int rbtree_remove(struct RB_TREE *tree, const void *data)
 		struct RB_NODE *s = p->link[!last];
 
 		if (s != NULL) {
-		    if (!is_red(s->link[!last]) &&
-		        !is_red(s->link[last])) {
+		    if (!is_red(s->link[!last]) && !is_red(s->link[last])) {
 			/* Color flip */
 			p->red = 0;
 			s->red = 1;
@@ -232,7 +233,7 @@ int rbtree_remove(struct RB_TREE *tree, const void *data)
 
     /* Update root and make it black */
     tree->root = head.link[1];
-    if ( tree->root != NULL)
+    if (tree->root != NULL)
 	tree->root->red = 0;
 
     return removed;
@@ -251,7 +252,7 @@ void *rbtree_find(struct RB_TREE *tree, const void *data)
     while (curr_node != NULL) {
 	cmp = tree->rb_compare(curr_node->data, data);
 	if (cmp == 0)
-	    return curr_node->data;   /* found */
+	    return curr_node->data;	/* found */
 	else {
 	    curr_node = curr_node->link[cmp < 0];
 	}
@@ -283,7 +284,7 @@ int rbtree_init_trav(struct RB_TRAV *trav, struct RB_TREE *tree)
 void *rbtree_traverse(struct RB_TRAV *trav)
 {
     assert(trav);
-    
+
     if (trav->curr_node == NULL) {
 	if (trav->first)
 	    G_debug(1, "RB tree: empty tree");
@@ -292,7 +293,7 @@ void *rbtree_traverse(struct RB_TRAV *trav)
 
 	return NULL;
     }
-	
+
     if (!trav->first)
 	return rbtree_next(trav);
     else {
@@ -322,7 +323,7 @@ void *rbtree_traverse_start(struct RB_TRAV *trav, const void *data)
 
 	return NULL;
     }
-	
+
     if (!trav->first)
 	return rbtree_next(trav);
 
@@ -343,13 +344,13 @@ void *rbtree_traverse_start(struct RB_TRAV *trav, const void *data)
 	     * largest item is smaller than search template */
 	    if (trav->curr_node->link[dir] == NULL)
 		return trav->curr_node->data;
-		
+
 	    trav->up[trav->top++] = trav->curr_node;
 	    trav->curr_node = trav->curr_node->link[dir];
 	}
     }
 
-    return NULL; /* should not happen */
+    return NULL;		/* should not happen */
 }
 
 /* two functions needed to fully traverse the tree: initialize and continue
@@ -371,7 +372,7 @@ void *rbtree_first(struct RB_TRAV *trav)
 	trav->curr_node = trav->curr_node->link[0];
     }
 
-    return trav->curr_node->data; /* return smallest item */
+    return trav->curr_node->data;	/* return smallest item */
 }
 
 /* continue traversing the tree in ascending order
@@ -393,6 +394,7 @@ void *rbtree_next(struct RB_TRAV *trav)
     else {
 	/* at smallest item in this branch, go back up */
 	struct RB_NODE *last;
+
 	do {
 	    if (trav->top == 0) {
 		trav->curr_node = NULL;
@@ -406,12 +408,13 @@ void *rbtree_next(struct RB_TRAV *trav)
     if (trav->curr_node != NULL) {
 	return trav->curr_node->data;
     }
-    else	
-	return NULL; /* finished traversing */
+    else
+	return NULL;		/* finished traversing */
 }
 
 /* destroy the tree */
-void rbtree_destroy(struct RB_TREE *tree) {
+void rbtree_destroy(struct RB_TREE *tree)
+{
     rbtree_destroy2(tree->root);
     G_free(tree);
 }
@@ -430,7 +433,7 @@ void rbtree_destroy2(struct RB_NODE *root)
 int rbtree_debug(struct RB_TREE *tree, struct RB_NODE *root)
 {
     int lh, rh;
- 
+
     if (root == NULL)
 	return 1;
     else {
@@ -452,7 +455,7 @@ int rbtree_debug(struct RB_TREE *tree, struct RB_NODE *root)
 	if (ln) {
 	    lcmp = tree->rb_compare(ln->data, root->data);
 	}
-	
+
 	if (rn) {
 	    rcmp = tree->rb_compare(rn->data, root->data);
 	}
@@ -460,8 +463,8 @@ int rbtree_debug(struct RB_TREE *tree, struct RB_NODE *root)
 	/* Invalid binary search tree:
 	 * left node >= parent or right node <= parent */
 	if ((ln != NULL && lcmp > -1)
-	 || (rn != NULL && rcmp < 1)) {
-	    G_warning("Red Black Tree debugging: Binary tree violation" );
+	    || (rn != NULL && rcmp < 1)) {
+	    G_warning("Red Black Tree debugging: Binary tree violation");
 	    return 0;
 	}
 
@@ -496,9 +499,9 @@ struct RB_NODE *rbtree_make_node(size_t datasize, void *data)
     new_node->data = G_malloc(datasize);
     if (new_node->data == NULL)
 	G_fatal_error("RB Search Tree: Out of memory!");
-	
+
     memcpy(new_node->data, data, datasize);
-    new_node->red = 1;            /* 1 is red, 0 is black */
+    new_node->red = 1;		/* 1 is red, 0 is black */
     new_node->link[0] = NULL;
     new_node->link[1] = NULL;
 
@@ -527,7 +530,7 @@ struct RB_NODE *rbtree_single(struct RB_NODE *root, int dir)
 
     return newroot;
 }
- 
+
 /* double rotation */
 struct RB_NODE *rbtree_double(struct RB_NODE *root, int dir)
 {

lib/segment/release.c

@@ -14,6 +14,7 @@
 
 #include <stdlib.h>
 #include <grass/segment.h>
+#include "rbtree.h"
 
 
 /**
@@ -43,6 +44,10 @@ int segment_release(SEGMENT * SEG)
 	free(SEG->scb[i].buf);
     free(SEG->scb);
 
+    free(SEG->freeslot);
+    free(SEG->agequeue);
+    rbtree_destroy(SEG->loaded);
+
     SEG->open = 0;
 
     return 1;

lib/segment/seek.c

@@ -61,8 +61,7 @@ int segment_seek_slow(const SEGMENT * SEG, int n, int index)
 }
 
 static int (*segment_seek_mode[2]) () = {
-    segment_seek_fast, segment_seek_slow
-};
+segment_seek_fast, segment_seek_slow};
 
 int segment_seek(const SEGMENT * SEG, int n, int index)
 {

lib/segment/setup.c

@@ -17,7 +17,6 @@
 #include <math.h>
 #include <grass/gis.h>
 #include <grass/segment.h>
-
 #include "rbtree.h"
 
 
@@ -81,7 +80,8 @@ int segment_setup(SEGMENT * SEG)
     /* adjust number of open segments if larger than number of total segments */
     if (SEG->nseg > SEG->spr * ((SEG->nrows + SEG->srows - 1) / SEG->srows)) {
 	G_warning("segment: reducing number of open segments from %d to %d",
-		   SEG->nseg, SEG->spr * ((SEG->nrows + SEG->srows - 1) / SEG->srows));
+		  SEG->nseg,
+		  SEG->spr * ((SEG->nrows + SEG->srows - 1) / SEG->srows));
 	SEG->nseg = SEG->spr * ((SEG->nrows + SEG->srows - 1) / SEG->srows);
     }
 
@@ -93,12 +93,13 @@ int segment_setup(SEGMENT * SEG)
     if ((SEG->freeslot = (int *)G_malloc(SEG->nseg * sizeof(int))) == NULL)
 	return -2;
 
-    if ((SEG->agequeue = (struct aq *)G_malloc((SEG->nseg + 1) * sizeof(struct aq))) == NULL)
+    if ((SEG->agequeue =
+	 (struct aq *)G_malloc((SEG->nseg + 1) * sizeof(struct aq))) == NULL)
 	return -2;
 
     SEG->srowscols = SEG->srows * SEG->scols;
     SEG->size = SEG->srowscols * SEG->len;
-    
+
     for (i = 0; i < SEG->nseg; i++) {
 	if ((SEG->scb[i].buf = G_malloc(SEG->size)) == NULL)
 	    return -2;
@@ -117,16 +118,16 @@ int segment_setup(SEGMENT * SEG)
 	    SEG->agequeue[i].older = &(SEG->agequeue[i + 1]);
 	}
     }
-    
+
     SEG->agequeue[SEG->nseg].cur = -1;
     SEG->agequeue[SEG->nseg].younger = &(SEG->agequeue[SEG->nseg - 1]);
     SEG->agequeue[SEG->nseg].older = &(SEG->agequeue[0]);
     SEG->youngest = SEG->oldest = &(SEG->agequeue[SEG->nseg]);
-    
+
     SEG->nfreeslots = SEG->nseg;
     SEG->cur = 0;
     SEG->open = 1;
-    
+
     SEG->loaded = rbtree_create(segment_compare, sizeof(SEGID));
 
     return 1;
@@ -135,14 +136,14 @@ int segment_setup(SEGMENT * SEG)
 int segment_compare(const void *sega, const void *segb)
 {
     SEGID *a, *b;
-    
-    a = (SEGID *)sega;
-    b = (SEGID *)segb;
-    
+
+    a = (SEGID *) sega;
+    b = (SEGID *) segb;
+
     if (a->n > b->n)
 	return 1;
     else if (a->n < b->n)
 	return -1;
-    
+
     return 0;
 }