Return to putnum.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin / bc

Annotation of coherent/d/bin/bc/putnum.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include "bc.h"
                      3: 
                      4: 
                      5: /*
                      6:  *     The current output base is encoded in several variables.
                      7:  *     If every digit in the base can be represented by a single
                      8:  *     char (ie. outbase <= maxsobase) then smallbase is TRUE and
                      9:  *     obase contains the output base.  If not then smallbase is
                     10:  *     FALSE and obase contains 10.  In any case, outbase contains
                     11:  *     the current output base.
                     12:  */
                     13: 
                     14: static int     smallbase = TRUE;       /* TRUE iff 2 <= output base <= 16 */
                     15: static int     logobase;               /* max number of chars per digit */
                     16: 
                     17: 
                     18: /*
                     19:  *     Putnum writes the rvalue pointed to by `a' onto the standard
                     20:  *     output.
                     21:  */
                     22: 
                     23: putnum(a)
                     24: rvalue *a;
                     25: {
                     26:        register int    scale;
                     27:        mint            intp,
                     28:                        fracp;
                     29:        register mint   *intpart = &intp,
                     30:                        *fracpart = &fracp;
                     31: 
                     32:        minit(intpart);
                     33:        minit(fracpart);
                     34:        scale = a->scale;
                     35:        mdiv(&a->mantissa, pow10(scale), intpart, fracpart);
                     36:        if (!ispos(&a->mantissa)) {
                     37:                mneg(intpart, intpart);
                     38:                mneg(fracpart, fracpart);
                     39:                pstring("-", 0);
                     40:        }
                     41:        if (!zerop(intpart) || scale == 0)
                     42:                if (smallbase)
                     43:                        smallint(intpart);
                     44:                else
                     45:                        bigint(intpart);
                     46:        mvfree(intpart);
                     47:        if (scale != 0)
                     48:                pfrac(fracpart, scale);
                     49:        mvfree(fracpart);
                     50: }
                     51: 
                     52: 
                     53: /*
                     54:  *     Smallint prints out the positive integer a in obase.
                     55:  */
                     56: 
                     57: static
                     58: smallint(a)
                     59: mint   *a;
                     60: {
                     61:        register char   *str;
                     62: 
                     63:        str = mtos(a);
                     64:        pstring(str, 0);
                     65:        mpfree(str);
                     66: }
                     67: 
                     68: 
                     69: /*
                     70:  *     Bigint prints out the positive integer a in outbase which
                     71:  *     is assumed to be "big".  It uses recursion to print the large
                     72:  *     "digits" in the correct order.
                     73:  *     Note that on exit, the value of `a' is grabage.
                     74:  */
                     75: 
                     76: static
                     77: bigint(a)
                     78: register mint  *a;
                     79: {
                     80:        mint    rm;
                     81:        register mint   *rem = &rm;
                     82:        register char   *str;
                     83: 
                     84:        minit(rem);
                     85:        mdiv(a, &outbase, a, rem);
                     86:        str = mtos(rem);
                     87:        mvfree(rem);
                     88:        if (zerop(a))
                     89:                pstring(str, 0);
                     90:        else {
                     91:                bigint(a);
                     92:                pstring(" ", 0);
                     93:                pstring(str, logobase);
                     94:        }
                     95:        mpfree(str);
                     96: }
                     97: 
                     98: 
                     99: /*
                    100:  *     Pfrac is used to print the fractional part when the output base
                    101:  *     is not 10.  `fracpart' is the fractional part times 10 to the
                    102:  *     `scale'.  Note that `fracpart' is destroyed.
                    103:  */
                    104: 
                    105: pfrac(fracpart, scale)
                    106: register mint  *fracpart;
                    107: int            scale;
                    108: {
                    109:        register int    digcnt;
                    110:        char            *str;
                    111:        mint            dig;
                    112: 
                    113:        pstring(".", 0);
                    114:        if (smallbase && obase == 10) {
                    115:                str = mtos(fracpart);
                    116:                pstring(str, scale);
                    117:                mpfree(str);
                    118:        } else {
                    119:                digcnt = (smallbase ? scale : (scale+logobase-1)/logobase);
                    120:                minit(&dig);
                    121:                do {
                    122:                        mult(fracpart, &outbase, fracpart);
                    123:                        mdiv(fracpart, pow10(scale), &dig, fracpart);
                    124:                        str = mtos(&dig);
                    125:                        pstring(str, logobase);
                    126:                        if (!smallbase)
                    127:                                pstring(" ", 0);
                    128:                        mpfree(str);
                    129:                } while (--digcnt > 0);
                    130:                mvfree(&dig);
                    131:        }
                    132: }
                    133: 
                    134: 
                    135: /*
                    136:  *     Sobase takes the rvalue pointed to by lval and sets the output
                    137:  *     base to it if it is an acceptable value.
                    138:  */
                    139: 
                    140: sobase(lval)
                    141: register rvalue        *lval;
                    142: {
                    143:        mint            tmp,
                    144:                        rem;
                    145:        register mint   *temp = &tmp;
                    146: 
                    147:        minit(temp);
                    148:        shift(&lval->mantissa, - lval->scale, temp);
                    149:        if (mcmp(mone, temp) >= 0)
                    150:                bcmerr("Invalid output base");
                    151:        mcopy(temp, &outbase);
                    152:        smallbase = mcmp(&outbase, &maxsobase) <= 0;
                    153:        if (smallbase)
                    154:                obase = mtoi(&outbase);
                    155:        else {
                    156:                obase = 10;
                    157:                msub(temp, mone, temp);
                    158:                minit(&rem);
                    159:                for (logobase = 0; !zerop(temp); ++logobase)
                    160:                        mdiv(temp, &ten, temp, &rem);
                    161:                mvfree(&rem);
                    162:        }
                    163:        mvfree(temp);
                    164: }

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