Return to dolfptoa.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / libntp

Annotation of embedaddon/ntp/libntp/dolfptoa.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:  * dolfptoa - do the grunge work of converting an l_fp number to decimal
                      3:  */
                      4: #include <stdio.h>
                      5: 
                      6: #include "ntp_fp.h"
                      7: #include "lib_strbuf.h"
                      8: #include "ntp_string.h"
                      9: #include "ntp_stdlib.h"
                     10: 
                     11: char *
                     12: dolfptoa(
                     13:        u_long fpi,
                     14:        u_long fpv,
                     15:        int neg,
                     16:        short ndec,
                     17:        int msec
                     18:        )
                     19: {
                     20:        register u_char *cp, *cpend;
                     21:        register u_long lwork;
                     22:        register int dec;
                     23:        u_char cbuf[24];
                     24:        u_char *cpdec;
                     25:        char *buf;
                     26:        char *bp;
                     27: 
                     28:        /*
                     29:         * Get a string buffer before starting
                     30:         */
                     31:        LIB_GETBUF(buf);
                     32: 
                     33:        /*
                     34:         * Zero the character buffer
                     35:         */
                     36:        memset((char *) cbuf, 0, sizeof(cbuf));
                     37: 
                     38:        /*
                     39:         * safeguard against sign extensions and other mishaps on 64 bit platforms
                     40:         * the code following is designed for and only for 32-bit inputs and
                     41:         * only 32-bit worth of input are supplied.
                     42:          */
                     43:        fpi &= 0xffffffff;
                     44:        fpv &= 0xffffffff;
                     45: 
                     46:        /*
                     47:         * Work on the integral part.  This is biased by what I know
                     48:         * compiles fairly well for a 68000.
                     49:         */
                     50:        cp = cpend = &cbuf[10];
                     51:        lwork = fpi;
                     52:        if (lwork & 0xffff0000) {
                     53:                register u_long lten = 10;
                     54:                register u_long ltmp;
                     55: 
                     56:                do {
                     57:                        ltmp = lwork;
                     58:                        lwork /= lten;
                     59:                        ltmp -= (lwork << 3) + (lwork << 1);
                     60:                        if (cp < cbuf) abort(); /* rather die a horrible death than trash the memory */
                     61:                        *--cp = (u_char)ltmp;
                     62:                } while (lwork & 0xffff0000);
                     63:        }
                     64:        if (lwork != 0) {
                     65:                register u_short sten = 10;
                     66:                register u_short stmp;
                     67:                register u_short swork = (u_short)lwork;
                     68: 
                     69:                do {
                     70:                        stmp = swork;
                     71:                        swork = (u_short) (swork/sten);
                     72:                        stmp = (u_short)(stmp - ((swork<<3) + (swork<<1)));
                     73:                        if (cp < cbuf) abort(); /* rather die a horrible death than trash the memory */
                     74:                        *--cp = (u_char)stmp;
                     75:                } while (swork != 0);
                     76:        }
                     77: 
                     78:        /*
                     79:         * Done that, now deal with the problem of the fraction.  First
                     80:         * determine the number of decimal places.
                     81:         */
                     82:        if (msec) {
                     83:                dec = ndec + 3;
                     84:                if (dec < 3)
                     85:                    dec = 3;
                     86:                cpdec = &cbuf[13];
                     87:        } else {
                     88:                dec = ndec;
                     89:                if (dec < 0)
                     90:                    dec = 0;
                     91:                cpdec = &cbuf[10];
                     92:        }
                     93:        if (dec > 12)
                     94:            dec = 12;
                     95:        
                     96:        /*
                     97:         * If there's a fraction to deal with, do so.
                     98:         */
                     99:        if (fpv != 0) {
                    100:                l_fp work;
                    101: 
                    102:                work.l_ui = 0;
                    103:                work.l_uf = fpv;
                    104:                while (dec > 0) {
                    105:                        l_fp ftmp;
                    106: 
                    107:                        dec--;
                    108:                        /*
                    109:                         * The scheme here is to multiply the
                    110:                         * fraction (0.1234...) by ten.  This moves
                    111:                         * a junk of BCD into the units part.
                    112:                         * record that and iterate.
                    113:                         */
                    114:                        work.l_ui = 0;
                    115:                        L_LSHIFT(&work);
                    116:                        ftmp = work;
                    117:                        L_LSHIFT(&work);
                    118:                        L_LSHIFT(&work);
                    119:                        L_ADD(&work, &ftmp);
                    120:                        *cpend++ = (u_char)work.l_ui;
                    121:                        if (work.l_uf == 0)
                    122:                            break;
                    123:                        if (cpend > (cbuf + sizeof(cbuf))) abort(); /* rather die a horrible death than trash the memory */
                    124:                }
                    125: 
                    126:                /*
                    127:                 * Rounding is rotten
                    128:                 */
                    129:                if (work.l_uf & 0x80000000) {
                    130:                        register u_char *tp = cpend;
                    131: 
                    132:                        *(--tp) += 1;
                    133:                        while (*tp >= 10) {
                    134:                                *tp = 0;
                    135:                                *(--tp) += 1;
                    136:                        };
                    137:                        if (tp < cp)
                    138:                            cp = tp;
                    139:                }
                    140:        }
                    141:        cpend += dec;
                    142: 
                    143: 
                    144:        /*
                    145:         * We've now got the fraction in cbuf[], with cp pointing at
                    146:         * the first character, cpend pointing past the last, and
                    147:         * cpdec pointing at the first character past the decimal.
                    148:         * Remove leading zeros, then format the number into the
                    149:         * buffer.
                    150:         */
                    151:        while (cp < cpdec) {
                    152:                if (*cp != 0)
                    153:                    break;
                    154:                cp++;
                    155:        }
                    156:        if (cp == cpdec)
                    157:            --cp;
                    158: 
                    159:        bp = buf;
                    160:        if (neg)
                    161:            *bp++ = '-';
                    162:        while (cp < cpend) {
                    163:                if (cp == cpdec)
                    164:                    *bp++ = '.';
                    165:                *bp++ = (char)(*cp++ + '0');    /* ascii dependent? */
                    166:        }
                    167:        *bp = '\0';
                    168: 
                    169:        /*
                    170:         * Done!
                    171:         */
                    172:        return buf;
                    173: }