source/lib/ldb/ldb_sqlite3/base160.c

   1 /*
   2    base160 code used by ldb_sqlite3
   3
   4    Copyright (C) 2004 Derrell Lipman
   5
   6    This library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2 of the License, or (at your option) any later version.
  10
  11    This library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with this library; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21
  22 /*
  23  * ldb_sqlite3_base160()
  24  *
  25  * Convert an integer value to a string containing the base 160 representation
  26  * of the integer.  We always convert to a string representation that is 4
  27  * bytes in length, and we always null terminate.
  28  *
  29  * Parameters:
  30  *   val --
  31  *     The value to be converted
  32  *
  33  *   result --
  34  *     Buffer in which the result is to be placed
  35  *
  36  * Returns:
  37  *   nothing
  38  */
  39 static unsigned char        base160tab[161] =
  40 {
  41     48 , 49 , 50 , 51 , 52 , 53 , 54 , 55 , 56 , 57 , /* 0-9 */
  42     58 , 59 , 65 , 66 , 67 , 68 , 69 , 70 , 71 , 72 , /* : ; A-H */
  43     73 , 74 , 75 , 76 , 77 , 78 , 79 , 80 , 81 , 82 , /* I-R */
  44     83 , 84 , 85 , 86 , 87 , 88 , 89 , 90 , 97 , 98 , /* S-Z , a-b */
  45     99 , 100, 101, 102, 103, 104, 105, 106, 107, 108, /* c-l */
  46     109, 110, 111, 112, 113, 114, 115, 116, 117, 118, /* m-v */
  47     119, 120, 121, 122, 160, 161, 162, 163, 164, 165, /* w-z, latin1 */
  48     166, 167, 168, 169, 170, 171, 172, 173, 174, 175, /* latin1 */
  49     176, 177, 178, 179, 180, 181, 182, 183, 184, 185, /* latin1 */
  50     186, 187, 188, 189, 190, 191, 192, 193, 194, 195, /* latin1 */
  51     196, 197, 198, 199, 200, 201, 202, 203, 204, 205, /* latin1 */
  52     206, 207, 208, 209, 210, 211, 212, 213, 214, 215, /* latin1 */
  53     216, 217, 218, 219, 220, 221, 222, 223, 224, 225, /* latin1 */
  54     226, 227, 228, 229, 230, 231, 232, 233, 234, 235, /* latin1 */
  55     236, 237, 238, 239, 240, 241, 242, 243, 244, 245, /* latin1 */
  56     246, 247, 248, 249, 250, 251, 252, 253, 254, 255, /* latin1 */
  57     '\0'
  58 };
  59
  60
  61 /*
  62  * lsqlite3_base160()
  63  *
  64  * Convert an unsigned long integer into a base160 representation of the
  65  * number.
  66  *
  67  * Parameters:
  68  *   val --
  69  *     value to be converted
  70  *
  71  *   result --
  72  *     character array, 5 bytes long, into which the base160 representation
  73  *     will be placed.  The result will be a four-digit representation of the
  74  *     number (with leading zeros prepended as necessary), and null
  75  *     terminated.
  76  *
  77  * Returns:
  78  *   Nothing
  79  */
  80 void
  81 lsqlite3_base160(unsigned long val,
  82                  unsigned char result[5])
  83 {
  84     int             i;
  85
  86     for (i = 3; i >= 0; i--) {
  87
  88         result[i] = base160tab[val % 160];
  89         val /= 160;
  90     }
  91
  92     result[4] = '\0';
  93 }
  94
  95
  96 /*
  97  * lsqlite3_base160Next()
  98  *
  99  * Retrieve the next-greater number in the base160 sequence for the terminal
 100  * tree node (the last four digits).  Only one tree level (four digits) are
 101  * operated on.
 102  *
 103  * Parameters:
 104  *   base160 -- a character array containing either an empty string (in which
 105  *              case no operation is performed), or a string of base160 digits
 106  *              with a length of a multiple of four digits.
 107  *
 108  *              Upon return, the trailing four digits (one tree level) will
 109  *              have been incremented by 1.
 110  *
 111  * Returns:
 112  *   base160 -- the modified array
 113  */
 114 char *
 115 lsqlite3_base160Next(char base160[])
 116 {
 117     int             i;
 118     int             len;
 119     unsigned char * pTab;
 120     char *          pBase160 = base160;
 121
 122     /*
 123      * We need a minimum of four digits, and we will always get a multiple of
 124      * four digits.
 125      */
 126     if (len = strlen(pBase160)) >= 4)
 127     {
 128         pBase160 += strlen(pBase160) - 1;
 129
 130         /* We only carry through four digits: one level in the tree */
 131         for (i = 0; i < 4; i++) {
 132
 133             /* What base160 value does this digit have? */
 134             pTab = strchr(base160tab, *pBase160);
 135
 136             /* Is there a carry? */
 137             if (pTab < base160tab + sizeof(base160tab) - 1) {
 138
 139                 /* Nope.  Just increment this value and we're done. */
 140                 *pBase160 = *++pTab;
 141                 break;
 142             } else {
 143
 144                 /*
 145                  * There's a carry.  This value gets base160tab[0], we
 146                  * decrement the buffer pointer to get the next higher-order
 147                  * digit, and continue in the loop.
 148                  */
 149                 *pBase160-- = base160tab[0];
 150             }
 151         }
 152     }
 153
 154     return base160;
 155 }