c_cpp/etc/calc/lib_util.c

   1 /*
   2  * lib_util - calc library utility routines
   3  *
   4  * Copyright (C) 1999-2006  Landon Curt Noll
   5  *
   6  * Calc is open software; you can redistribute it and/or modify it under
   7  * the terms of the version 2.1 of the GNU Lesser General Public License
   8  * as published by the Free Software Foundation.
   9  *
  10  * Calc is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General
  13  * Public License for more details.
  14  *
  15  * A copy of version 2.1 of the GNU Lesser General Public License is
  16  * distributed with calc under the filename COPYING-LGPL.  You should have
  17  * received a copy with calc; if not, write to Free Software Foundation, Inc.
  18  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  *
  20  * @(#) $Revision: 30.1 $
  21  * @(#) $Id: lib_util.c,v 30.1 2007/03/16 11:09:46 chongo Exp $
  22  * @(#) $Source: /usr/local/src/bin/calc/RCS/lib_util.c,v $
  23  *
  24  * Under source code control:   1997/04/19 21:38:30
  25  * File existed as early as:    1997
  26  *
  27  * chongo <was here> /\oo/\     http://www.isthe.com/chongo/
  28  * Share and enjoy!  :-)        http://www.isthe.com/chongo/tech/comp/calc/
  29  */
  30
  31 /*
  32  * These routines are here to support users of libcalc.a.  These routines
  33  * are not directly used by calc itself, however.
  34  */
  35
  36
  37 #include "zmath.h"
  38 #include "lib_util.h"
  39
  40
  41 /*
  42  * lowhex2bin - quick low order ASCII hex to binary conversion
  43  *
  44  * We just use mod 16 for non-hex ASCII chars.  We use just mod 128
  45  * for non-ASCII to ASCII conversion.
  46  *
  47  *   | 00 nul | 01 soh | 02 stx | 03 etx | 04 eot | 05 enq | 06 ack | 07 bel |
  48  *   | 08 bs  | 09 ht  | 0a nl  | 0b vt  | 0c np  | 0d cr  | 0e so  | 0f si  |
  49  *   | 10 dle | 11 dc1 | 12 dc2 | 13 dc3 | 14 dc4 | 15 nak | 16 syn | 17 etb |
  50  *   | 18 can | 19 em  | 1a sub | 1b esc | 1c fs  | 1d gs  | 1e rs  | 1f us  |
  51  *   | 20 sp  | 21 !   | 22 "   | 23 #   | 24 $   | 25 %   | 26 &   | 27 '   |
  52  *   | 28 (   | 29 )   | 2a *   | 2b +   | 2c ,   | 2d -   | 2e .   | 2f /   |
  53  *   | 30 0   | 31 1   | 32 2   | 33 3   | 34 4   | 35 5   | 36 6   | 37 7   |
  54  *   | 38 8   | 39 9   | 3a :   | 3b ;   | 3c <   | 3d =   | 3e >   | 3f ?   |
  55  *   | 40 @   | 41 A   | 42 B   | 43 C   | 44 D   | 45 E   | 46 F   | 47 G   |
  56  *   | 48 H   | 49 I   | 4a J   | 4b K   | 4c L   | 4d M   | 4e N   | 4f O   |
  57  *   | 50 P   | 51 Q   | 52 R   | 53 S   | 54 T   | 55 U   | 56 V   | 57 W   |
  58  *   | 58 X   | 59 Y   | 5a Z   | 5b [   | 5c \   | 5d ]   | 5e ^   | 5f _   |
  59  *   | 60 `   | 61 a   | 62 b   | 63 c   | 64 d   | 65 e   | 66 f   | 67 g   |
  60  *   | 68 h   | 69 i   | 6a j   | 6b k   | 6c l   | 6d m   | 6e n   | 6f o   |
  61  *   | 70 p   | 71 q   | 72 r   | 73 s   | 74 t   | 75 u   | 76 v   | 77 w   |
  62  *   | 78 x   | 79 y   | 7a z   | 7b {   | 7c |   | 7d }   | 7e ~   | 7f del |
  63  */
  64 int lowhex2bin[256] = {
  65   /* 0   1   2   3   4   5   6   7   8   9   a   b   c   d   e   f  */
  66     0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,    /* 0 */
  67     0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,    /* 1 */
  68     0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,    /* 2 */
  69     0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,    /* 3 */
  70     0x0,0xa,0xb,0xc,0xd,0xe,0xf,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,    /* 4 */
  71     0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,    /* 5 */
  72     0x0,0xa,0xb,0xc,0xd,0xe,0xf,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,    /* 6 */
  73     0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,    /* 7 */
  74     0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,    /* 8 */
  75     0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,    /* 9 */
  76     0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,    /* a */
  77     0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,    /* b */
  78     0x0,0xa,0xb,0xc,0xd,0xe,0xf,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,    /* c */
  79     0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,    /* d */
  80     0x0,0xa,0xb,0xc,0xd,0xe,0xf,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf,    /* e */
  81     0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8,0x9,0xa,0xb,0xc,0xd,0xe,0xf     /* f */
  82 };
  83
  84
  85 /*
  86  * hex2bin - macro to convert two ASCII hex chars into binary value
  87  *
  88  * given:
  89  *      high - high order hex ASCII char
  90  *      low - low order hex ASCII char
  91  *
  92  * returns:
  93  *      numeric equivalent to 0x{high}{low} as an int
  94  */
  95 #define hex2bin(high,low) \
  96         (lowhex2bin[(int)((char)(high))]<<4 | lowhex2bin[((int)(char)(low))])
  97
  98 /*
  99  * lowbin2hex - quick low order binary conversion to ASCII hex
 100  */
 101 char lowbin2hex[256] = {
 102         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f',
 103         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f',
 104         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f',
 105         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f',
 106         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f',
 107         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f',
 108         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f',
 109         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f',
 110         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f',
 111         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f',
 112         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f',
 113         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f',
 114         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f',
 115         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f',
 116         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f',
 117         '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'
 118 };
 119
 120
 121 /*
 122  * convstr2z - convert a string into a ZVALUE
 123  *
 124  * NOTE: No attempt is make to deal with byte order.
 125  *
 126  * given:
 127  *      str     string to convert
 128  *
 129  * returns:
 130  *      ZVALUE
 131  */
 132 ZVALUE
 133 convstr2z(char *str)
 134 {
 135         HALF *v;        /* storage for string as HALFs */
 136         ZVALUE ret;     /* return value */
 137         size_t len;     /* length in HALFs of our string rounded up */
 138
 139         /*
 140          * firewall
 141          */
 142         if (str == NULL || *str == '\0') {
 143                 /* NULL or empty strings return 0 */
 144                 return _zero_;
 145         }
 146
 147         /*
 148          * allocate HALF strorage
 149          */
 150         len = (strlen(str)+sizeof(HALF)-1)/sizeof(HALF);
 151         v = (HALF *)malloc(len * sizeof(HALF));
 152         if (v == NULL) {
 153                 math_error("convstr2z bad malloc");
 154                 /*NOTREACHED*/
 155         }
 156         v[len-1] = 0;   /* deal with possible partial end of string HALF */
 157
 158         /*
 159          * initialize HALF array with string value
 160          */
 161         memcpy((void *)v, (void *)str, strlen(str));
 162
 163         /*
 164          * setup the rest of the ZVALUE
 165          */
 166         ret.v = v;
 167         ret.len = len;
 168         ret.sign = 0;
 169         ztrim(&ret);
 170
 171         /*
 172          * return our result
 173          */
 174         return ret;
 175 }
 176
 177
 178 /*
 179  * convhex2z - convert hex string to ZVALUE
 180  *
 181  * usage:
 182  *      str     hex ASCII string with optional leading 0x
 183  *
 184  * returns:
 185  *      ZVALUE
 186  */
 187 ZVALUE
 188 convhex2z(char *hex)
 189 {
 190         HALF *v;        /* storage for string as HALFs */
 191         HALF *hp;       /* HALF pointer */
 192         char *sp;       /* string pointer */
 193         ZVALUE ret;     /* return value */
 194         int len;        /* length in HALFs of our string rounded up */
 195         size_t slen;    /* hex string length */
 196         int i;
 197
 198         /*
 199          * firewall
 200          */
 201         if (hex == NULL || hex[0] == '\0') {
 202                 /* NULL or empty strings return 0 */
 203                 return _zero_;
 204         }
 205
 206         /*
 207          * skip leading 0X or 0x if needed
 208          */
 209         if (hex[0] == '0' && (hex[1] == 'x' || hex[1] == 'X')) {
 210                 hex += 2;
 211         }
 212         if (hex[0] == '\0') {
 213                 /* just 0X or 0x returns 0 */
 214                 return _zero_;
 215         }
 216
 217         /*
 218          * allocate HALF strorage
 219          */
 220         slen = strlen(hex);
 221         len = ((slen*4)+BASEB-1)/BASEB;
 222         v = (HALF *)malloc(len * sizeof(HALF));
 223         if (v == NULL) {
 224                 math_error("convhex2z bad malloc");
 225                 /*NOTREACHED*/
 226         }
 227         v[len-1] = 0;   /* deal with possible partial end of string HALF */
 228
 229         /*
 230          * deal with the upper partial HALF value
 231          */
 232         hp = v+len-1;
 233         sp = hex;
 234         if ((slen % (BASEB/4)) != 0) {
 235
 236                 /* deal with a odd length hex string first */
 237                 if (slen % 2 == 1) {
 238                         *hp = hex2bin('0', *sp++);
 239                         --slen;
 240
 241                 /* even length - top top hex char to process */
 242                 } else {
 243                         *hp = 0;
 244                 }
 245                 /* slen is even now */
 246
 247                 /* eat two hex chars at a time until the HALF is full */
 248                 for (; (slen % (BASEB/4)) != 0; slen -= 2, sp += 2) {
 249                         *hp = ((*hp<<8) | hex2bin(sp[0], sp[1]));
 250                 }
 251
 252                 /* move on to the next HALF */
 253                 --hp;
 254         }
 255         /* slen is now a multiple of BASEB/4 */
 256
 257         /*
 258          * deal with full HALFs
 259          */
 260         for (; slen > 0; slen -= (BASEB/4), --hp) {
 261
 262                 /* clear HALF */
 263                 *hp = 0;
 264
 265                 /* eat two hex chars at a time until the HALF is full */
 266                 for (i=0; i < (BASEB/4); i += 2) {
 267                         *hp = ((*hp<<8) | hex2bin(sp[i], sp[i+1]));
 268                 }
 269         }
 270
 271         /*
 272          * setup the rest of the ZVALUE
 273          */
 274         ret.v = v;
 275         ret.len = len;
 276         ret.sign = 0;
 277         ztrim(&ret);
 278
 279         /*
 280          * return our result
 281          */
 282         return ret;
 283 }
 284
 285
 286 /*
 287  * convz2hex - convert ZVALUE to hex string
 288  *
 289  * We will ignore the sign of the value.
 290  *
 291  * usage:
 292  *      z       ZVALUE
 293  *
 294  * returns:
 295  *      str     hex ASCII malloced string (without a leading 0x)
 296  */
 297 char *
 298 convz2hex(ZVALUE z)
 299 {
 300         char *ret;      /* string to return */
 301         int slen;       /* string length (not counting \0) */
 302         HALF half;      /* HALF value to convert */
 303         int seen_nz;    /* 0 => we have not seen a non-zero hex char (yet) */
 304         char *p;
 305         int i;
 306         int j;
 307
 308         /*
 309          * firewall
 310          */
 311         if (z.v == NULL || ziszero(z)) {
 312                 /* malloc and return "0" */
 313                 ret = (char *)malloc(sizeof("0"));
 314                 if (ret == NULL) {
 315                         math_error("convz2hex bad malloc of 0 value");
 316                         /*NOTREACHED*/
 317                 }
 318                 ret[0] = '0';
 319                 ret[1] = '\0';
 320                 return ret;
 321         }
 322
 323         /*
 324          * malloc string storage
 325          */
 326         slen = (z.len * BASEB/4);
 327         ret = (char *)calloc(slen+1+1, sizeof(char));
 328         if (ret == NULL) {
 329                 math_error("convz2hex bad malloc of string");
 330                 /*NOTREACHED*/
 331         }
 332
 333         /*
 334          * load in hex ASCII chars for each HALF
 335          *
 336          * We will not write leading '0' hex chars into the string.
 337          */
 338         seen_nz = 0;
 339         for (p=ret, i=z.len-1; i >= 0; --i) {
 340
 341                 /*
 342                  * load in ASCII hex by ASCII hex
 343                  */
 344                 for (half=z.v[i], j=BASEB-4; j >= 0; j-=4) {
 345                         if (seen_nz) {
 346                                 /* we saw a non-zero, just load the rest */
 347                                 *p++ = lowbin2hex[(half >> j) & 0xff];
 348                         } else {
 349                                 /* all zeros so far */
 350                                 *p = lowbin2hex[(half >> j) & 0xff];
 351                                 if (*p != '0') {
 352                                         /* we found our first non-zero char */
 353                                         ++p;
 354                                         seen_nz = 1;
 355                                 }
 356                         }
 357                 }
 358         }
 359         if (seen_nz) {
 360                 *p = '\0';
 361         } else {
 362                 /* saw nothing but 0's, so just return 0 */
 363                 *ret = '0';
 364                 *(ret+1) = '\0';
 365         }
 366
 367         /*
 368          * return the new string
 369          */
 370         return ret;
 371 }