From: Koji Arai <jca02266@gmail.com>
Date: Sat, 23 Aug 2008 19:14:06 +0000 (+0900)
Subject: re-indent for pm2 source by GNU indent.
X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=eb49646ce1a24dc41f3930ec42a36bb1dac3e748;p=lha%2Flha.git

re-indent for pm2 source by GNU indent.
---

diff --git a/src/pm2.c b/src/pm2.c
index 1be6de4..67d3624 100644
--- a/src/pm2.c
+++ b/src/pm2.c
@@ -12,14 +12,15 @@ static unsigned short lastupdate;
 static unsigned short dicsiz1;
 #define offset (0x100 - 2)
 
-void decode_start_pm2(void)
+void
+decode_start_pm2(void)
 {
     dicsiz1 = (1 << dicbit) - 1;
     init_getbits();
     hist_init();
     nextcount = 0;
     lastupdate = 0;
-    getbits(1); /* discard bit */
+    getbits(1);                 /* discard bit */
 }
 
 
@@ -30,88 +31,86 @@ static int historyBase[8] = {   0,   8,  16,  32,  64,  96, 128, 192 };
 static int repeatBits[6]  = {   3,   3,   5,   6,   7,   0 };
 static int repeatBase[6]  = {  17,  25,  33,  65, 129, 256 };
 
-unsigned short decode_c_pm2(void)
+unsigned short
+decode_c_pm2(void)
 {
     /* various admin: */
-    while (lastupdate != loc)
-    {
+    while (lastupdate != loc) {
         hist_update(dtext[lastupdate]);
         lastupdate = (lastupdate + 1) & dicsiz1;
     }
     while (decode_count >= nextcount)
-    /* Actually it will never loop, because count doesn't grow that fast.
-       However, this is the way LHA does it.
-       Probably other encoding methods can have repeats larger than 256 bytes.
-       Note: LHA puts this code in decode_p...
-    */
+        /* Actually it will never loop, because count doesn't grow that fast.
+           However, this is the way LHA does it.
+           Probably other encoding methods can have repeats larger than 256 bytes.
+           Note: LHA puts this code in decode_p...
+         */
     {
-        if (nextcount == 0x0000)
-        {
+        if (nextcount == 0x0000) {
             maketree1();
             maketree2(5);
             nextcount = 0x0400;
         }
-        else if (nextcount == 0x0400)
-        {
+        else if (nextcount == 0x0400) {
             maketree2(6);
             nextcount = 0x0800;
         }
-        else if (nextcount == 0x0800)
-        {
+        else if (nextcount == 0x0800) {
             maketree2(7);
             nextcount = 0x1000;
         }
-        else if (nextcount == 0x1000)
-        {
-            if (getbits(1) != 0) maketree1();
+        else if (nextcount == 0x1000) {
+            if (getbits(1) != 0)
+                maketree1();
             maketree2(8);
             nextcount = 0x2000;
         }
-        else
-        { /* 0x2000, 0x3000, 0x4000, ... */
-            if (getbits(1) != 0)
-            {
+        else {                  /* 0x2000, 0x3000, 0x4000, ... */
+            if (getbits(1) != 0) {
                 maketree1();
                 maketree2(8);
             }
             nextcount += 0x1000;
         }
     }
-    gettree1 = tree_get(&tree1); /* value preserved for decode_p */
-       	
+    gettree1 = tree_get(&tree1);        /* value preserved for decode_p */
+
     /* direct value (ret <= UCHAR_MAX) */
-    if (gettree1 < 8) return hist_lookup(
-        historyBase[gettree1] + getbits(historyBits[gettree1]) );
+    if (gettree1 < 8)
+        return hist_lookup(historyBase[gettree1] +
+                           getbits(historyBits[gettree1]));
     /* repeats: (ret > UCHAR_MAX) */
-    if (gettree1 < 23) return offset + 2 + (gettree1 - 8);
+    if (gettree1 < 23)
+        return offset + 2 + (gettree1 - 8);
+
     return offset + repeatBase[gettree1 - 23]
         + getbits(repeatBits[gettree1 - 23]);
 }
 
-unsigned short decode_p_pm2(void)
+unsigned short
+decode_p_pm2(void)
 {
     /* gettree1 value preserved from decode_c */
     int nbits, delta, gettree2;
-    if (gettree1 == 8)
-    { /* 2-byte repeat with offset 0..63 */
-        nbits = 6; delta = 0;
+    if (gettree1 == 8) {        /* 2-byte repeat with offset 0..63 */
+        nbits = 6;
+        delta = 0;
     }
-    else if (gettree1 < 28)
-    { /* n-byte repeat with offset 0..8191 */
+    else if (gettree1 < 28) {   /* n-byte repeat with offset 0..8191 */
         gettree2 = tree_get(&tree2);
-        if (gettree2 == 0)
-        {
-       	    nbits = 6; delta = 0;
-       	}
-       	else
-       	{ /* 1..7 */
-       	    nbits = 5 + gettree2; delta = 1 << nbits;
-       	}
+        if (gettree2 == 0) {
+            nbits = 6;
+            delta = 0;
+        }
+        else {                  /* 1..7 */
+            nbits = 5 + gettree2;
+            delta = 1 << nbits;
+        }
     }
-    else
-    { /* 256 bytes repeat with offset 0 */
-   	    nbits = 0; delta = 0;
+    else {                      /* 256 bytes repeat with offset 0 */
+        nbits = 0;
+        delta = 0;
     }
+
     return delta + getbits(nbits);
-                    	
 }
diff --git a/src/pm2hist.c b/src/pm2hist.c
index d6e143f..8f7584d 100644
--- a/src/pm2hist.c
+++ b/src/pm2hist.c
@@ -8,13 +8,13 @@ static unsigned char prev[0x100];
 static unsigned char next[0x100];
 static unsigned char lastbyte;
 
-void hist_init()
+void
+hist_init()
 {
     int i;
-    for (i = 0; i < 0x100; i++)
-    {
+    for (i = 0; i < 0x100; i++) {
         prev[(0xFF + i) & 0xFF] = i;
-      	next[(0x01 + i) & 0xFF] = i;
+        next[(0x01 + i) & 0xFF] = i;
     }
     prev[0x7F] = 0x00; next[0x00] = 0x7F;
     prev[0xDF] = 0x80; next[0x80] = 0xDF;
@@ -24,42 +24,46 @@ void hist_init()
     lastbyte = 0x20;
 }
 
-unsigned char hist_lookup(int n)
+unsigned char
+hist_lookup(int n)
 {
     int i;
     unsigned char *direction = prev;
-    if (n >= 0x80)
-    {
+    if (n >= 0x80) {
         /* Speedup: If you have to process more than half the ring,
-                    it's faster to walk the other way around.
-        */
+           it's faster to walk the other way around.
+         */
         direction = next;
         n = 0x100 - n;
     }
-    for (i = lastbyte; n != 0; n--) i = direction[i];
+    for (i = lastbyte; n != 0; n--)
+        i = direction[i];
+
     return i;
-}   	   	
-	
-void hist_update(unsigned char data)
+}
+
+void
+hist_update(unsigned char data)
 {
     unsigned char oldNext, oldPrev, newNext;
-    if (data == lastbyte) return;
-    	
+
+    if (data == lastbyte)
+        return;
+
     /* detach from old position */
     oldNext = next[data];
     oldPrev = prev[data];
     prev[oldNext] = oldPrev;
     next[oldPrev] = oldNext;
-	
+
     /* attach to new next */
     newNext = next[lastbyte];
     prev[newNext] = data;
     next[data] = newNext;
-    	
+
     /* attach to new prev */
     prev[data] = lastbyte;
     next[lastbyte] = data;
-    	
+
     lastbyte = data;
 }
-
diff --git a/src/pm2tree.c b/src/pm2tree.c
index 1b1a0bc..4891c98 100644
--- a/src/pm2tree.c
+++ b/src/pm2tree.c
@@ -17,140 +17,142 @@ static unsigned char table2[8];
 static unsigned char tree1bound;
 static unsigned char mindepth;
 
-void maketree1()
+void
+maketree1()
 {
     int i, nbits, x;
     tree1bound = getbits(5);
     mindepth = getbits(3);
-    if (mindepth == 0)
-    {
+    if (mindepth == 0) {
         tree_setsingle(&tree1, tree1bound - 1);
     }
-    else
-    {
-        for (i = 0; i<32; i++) table1[i] = 0;
-       	nbits = getbits(3);
-       	for (i = 0; i < tree1bound; i++) {
+    else {
+        for (i = 0; i < 32; i++)
+            table1[i] = 0;
+        nbits = getbits(3);
+        for (i = 0; i < tree1bound; i++) {
             x = getbits(nbits);
-            table1[i] = ( x == 0 ? 0 : x - 1 + mindepth );
+            table1[i] = (x == 0 ? 0 : x - 1 + mindepth);
         }
-       	tree_rebuild(&tree1, tree1bound, mindepth, table1);
+        tree_rebuild(&tree1, tree1bound, mindepth, table1);
     }
 }
 
-void maketree2(int par_b) /* in use: 5 <= par_b <= 8 */
+void
+maketree2(int par_b) /* in use: 5 <= par_b <= 8 */
 {
     int i, count, index;
-    if (tree1bound < 10) return;
-    if (tree1bound == 29 && mindepth == 0) return;
-	
-    for (i = 0; i < 8; i++) table2[i] = 0;
-    for (i = 0; i < par_b; i++) table2[i] = getbits(3);
+
+    if (tree1bound < 10)
+        return;
+
+    if (tree1bound == 29 && mindepth == 0)
+        return;
+
+    for (i = 0; i < 8; i++)
+        table2[i] = 0;
+    for (i = 0; i < par_b; i++)
+        table2[i] = getbits(3);
+
     index = 0;
     count = 0;
-    for (i = 0; i < 8; i++)
-    {
-       	if (table2[i] != 0)
-       	{
-       	    index = i;
-       	    count++;
+    for (i = 0; i < 8; i++) {
+        if (table2[i] != 0) {
+            index = i;
+            count++;
         }
     }
-    	
-    if (count == 1)
-    {
+
+    if (count == 1) {
         tree_setsingle(&tree2, index);
     }
-    else if (count > 1)
-    {
-       	mindepth = 1;
-       	tree_rebuild(&tree2, 8, mindepth, table2);
+    else if (count > 1) {
+        mindepth = 1;
+        tree_rebuild(&tree2, 8, mindepth, table2);
     }
     // Note: count == 0 is possible!
     //       Excluding that possibility was a bug in version 1.
 
 }
 
-int tree_get(struct tree *t)
+int
+tree_get(struct tree *t)
 {
     int i;
     i = t->root;
-    while (i < 0x80)
-    {
-        i = ( getbits(1) == 0 ? t->leftarr[i] : t->rightarr[i] );
+    while (i < 0x80) {
+        i = (getbits(1) == 0 ? t->leftarr[i] : t->rightarr[i]);
     }
     return i & 0x7F;
 }
 
-void tree_setsingle(struct tree *t, unsigned char value)
+void
+tree_setsingle(struct tree *t, unsigned char value)
 {
     t->root = 128 | value;
 }
 
-void tree_rebuild(t, bound, mindepth, table)
-struct tree *t;
-unsigned char bound;
-unsigned char mindepth;
-unsigned char *table;
+void
+tree_rebuild(struct tree *t,
+             unsigned char bound,
+             unsigned char mindepth,
+             unsigned char *table)
 {
     unsigned char *parentarr, d;
     int i, curr, empty, n;
+
     parentarr = (unsigned char *)malloc(bound * sizeof(unsigned char));
     t->root = 0;
-    for (i = 0; i < bound; i++)
-    {
-        t->leftarr[i]   = 0;
-        t->rightarr[i]  = 0;
+    for (i = 0; i < bound; i++) {
+        t->leftarr[i] = 0;
+        t->rightarr[i] = 0;
         parentarr[i] = 0;
     }
-    	
-    for (i = 0; i < mindepth - 1; i++)
-    {
-       	t->leftarr[i] = i + 1;
-       	parentarr[i+1] = i;
+
+    for (i = 0; i < mindepth - 1; i++) {
+        t->leftarr[i] = i + 1;
+        parentarr[i + 1] = i;
     }
 
     curr = mindepth - 1;
     empty = mindepth;
-    for (d = mindepth; TRUE; d++)
-    {
-        for (i = 0; i < bound; i++)
-        {
-            if (table[i] == d)
-            {
-               	if (t->leftarr[curr] == 0) t->leftarr[curr] = i | 128;
-                else
-                {
+    for (d = mindepth; TRUE; d++) {
+        for (i = 0; i < bound; i++) {
+            if (table[i] == d) {
+                if (t->leftarr[curr] == 0)
+                    t->leftarr[curr] = i | 128;
+                else {
                     t->rightarr[curr] = i | 128;
                     n = 0;
-                    while (t->rightarr[curr] != 0)
-                    {
-                    	if (curr == 0) /* root? -> done */
-                    	{
-                    	    free(parentarr);
-                    	    return;
-                    	}
-                      	curr = parentarr[curr];
-                       	n++;
+                    while (t->rightarr[curr] != 0) {
+                        if (curr == 0) {        /* root? -> done */
+                            free(parentarr);
+                            return;
+                        }
+                        curr = parentarr[curr];
+                        n++;
                     }
                     t->rightarr[curr] = empty;
-                    for (;;)
-                    {
-                       	parentarr[empty] = curr;
-                       	curr = empty;
-                       	empty++;
-                        	
-                       	n--; if (n == 0) break;
-                       	t->leftarr[curr] = empty;
+                    for (;;) {
+                        parentarr[empty] = curr;
+                        curr = empty;
+                        empty++;
+
+                        n--;
+                        if (n == 0)
+                            break;
+                        t->leftarr[curr] = empty;
                     }
                 }
             }
         }
-       	if (t->leftarr[curr] == 0) t->leftarr[curr] = empty; else t->rightarr[curr] = empty;
-        	
+        if (t->leftarr[curr] == 0)
+            t->leftarr[curr] = empty;
+        else
+            t->rightarr[curr] = empty;
+
         parentarr[empty] = curr;
         curr = empty;
         empty++;
     }
 }
-
diff --git a/src/pm2tree.h b/src/pm2tree.h
index 3618ec4..afd1b1d 100644
--- a/src/pm2tree.h
+++ b/src/pm2tree.h
@@ -2,7 +2,9 @@
 	pm2tree.h -- tree for pmext2 decoding
 ***********************************************************/
 
-struct tree { unsigned char root, *leftarr, *rightarr; };
+struct tree {
+    unsigned char root, *leftarr, *rightarr;
+};
 
 extern struct tree tree1, tree2;
 
@@ -11,4 +13,4 @@ void maketree2(int par_b);
 int tree_get(struct tree *t);
 void tree_setsingle(struct tree *t, unsigned char value);
 void tree_rebuild(struct tree *t, unsigned char bound,
-    unsigned char mindepth, unsigned char *table);
+                  unsigned char mindepth, unsigned char *table);