Return to mtos.c CVS log

Up to [MW Coherent from dump] / coherent / d / usr / lib / libmp

Annotation of coherent/d/usr/lib/libmp/mtos.c, revision 1.1.1.1

1.1       root        1: #include "mprec.h"
                      2: #include <assert.h>
                      3: 
                      4: 
                      5: /*
                      6:  *     Sizfac is an array whoose obase - 2 component contains the
                      7:  *     maximum number of characters needed per byte of mint when
                      8:  *     converted to a string in base obase.  This simply means that 
                      9:  *     sizfac[obase - 2] contains the log (base obase) of BASE, rounded
                     10:  *     up.
                     11:  */
                     12: 
                     13: static int     sizfac[] = {
                     14:        7,      /* 2^7 = 128 */
                     15:        5,      /* 3^5 = 243 */
                     16:        4,      /* 4^4 = 256 */
                     17:        3,      /* 5^3 = 125 */
                     18:        3,      /* 6^3 = 216 */
                     19:        3,      /* 7^3 = 343 */
                     20:        3,      /* 8^3 = 512 */
                     21:        3,      /* 9^3 = 729 */
                     22:        3,      /* 10^3 = 1000 */
                     23:        3,      /* 11^3 = 1331 */
                     24:        2,      /* 12^2 = 144 */
                     25:        2,      /* 13^2 = 169 */
                     26:        2,      /* 14^2 = 196 */
                     27:        2,      /* 15^2 = 225 */
                     28:        2       /* 16^2 = 256 */
                     29: };
                     30: 
                     31: 
                     32: /*
                     33:  *     Dtc is an array of characters indexed by the allowable
                     34:  *     digist (0 to 15).  Dtc[i] is the character to represent
                     35:  *     the digit i.
                     36:  */
                     37: 
                     38: static char    dtc[] = {
                     39:        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                     40:        'A', 'B', 'C', 'D', 'E', 'F'
                     41: };
                     42: 
                     43: 
                     44: /*
                     45:  *     Obase is a int which is the output base used by mtos.  The value
                     46:  *     of obase shoud be between 2 and 16.  For bases greater than 10
                     47:  *     the characters A to F are used as digits.
                     48:  */
                     49: 
                     50: int    obase = 10;
                     51: 
                     52: 
                     53: /*
                     54:  *     Mtos converts the mint pointed to by "a" into a string of characters
                     55:  *     in base obase.  It returns a pointer to that string.  Note that
                     56:  *     obase is assumed to satisfy 2 <= obase <= 16.
                     57:  *     Also note that space for the string is allocated useing mpalc so
                     58:  *     that to release the space, the caller should use mpfree.
                     59:  */
                     60: 
                     61: char *
                     62: mtos(a)
                     63: mint *a;
                     64: {
                     65:        register char *rp, *to;
                     66:        mint    ac;
                     67:        int mifl;
                     68:        int dig;
                     69:        unsigned size;
                     70:        char *res;
                     71: 
                     72:        assert(2 <= obase <= 16);
                     73: 
                     74:        /* set ac = abs(a), copying if necessary */
                     75:        minit(&ac);
                     76:        if (mifl = ispos(a))
                     77:                mcopy(a, &ac);
                     78:        else
                     79:                mneg(a, &ac);
                     80: 
                     81:        /* calculate maximum size of result and allocate space */
                     82:        size = 1 + ac.len * sizfac[obase - 2];
                     83:        if (!mifl)
                     84:                ++size;
                     85:        res = (char *)mpalc(size);
                     86:        if (res == NULL)
                     87:                mperr("No space for string.");
                     88: 
                     89:        /*      create string - from back to front */
                     90:        rp = res + size;
                     91:        *--rp = '\0';
                     92:        do {
                     93:                sdiv(&ac, obase, &ac, &dig);
                     94:                *--rp = dtc[dig];
                     95:        } while (!zerop(&ac));
                     96:        mpfree(ac.val);
                     97:        if (!mifl)
                     98:                *--rp = '-';
                     99:        assert(rp >= res);
                    100: 
                    101:        /* left justify string if necessary */
                    102:        if (rp != res) {
                    103:                to = res;
                    104:                while ((*to++ = *rp++) != '\0')
                    105:                        ;
                    106:        }
                    107: 
                    108:        return(res);
                    109: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.