Return to dofptoa.c CVS log

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

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

1.1       misho       1: /*
                      2:  * dofptoa - do the grunge work to convert an fp number to ascii
                      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: dofptoa(
                     13:        u_fp fpv,
                     14:        int neg,
                     15:        short ndec,
                     16:        int msec
                     17:        )
                     18: {
                     19:        register u_char *cp, *cpend;
                     20:        register u_long val;
                     21:        register short dec;
                     22:        u_char cbuf[12];
                     23:        u_char *cpdec;
                     24:        char *buf;
                     25:        char *bp;
                     26: 
                     27:        /*
                     28:         * Get a string buffer before starting
                     29:         */
                     30:        LIB_GETBUF(buf);
                     31: 
                     32:        /*
                     33:         * Zero out the buffer
                     34:         */
                     35:        memset((char *)cbuf, 0, sizeof cbuf);
                     36: 
                     37:        /*
                     38:         * Set the pointers to point at the first
                     39:         * decimal place.  Get a local copy of the value.
                     40:         */
                     41:        cp = cpend = &cbuf[5];
                     42:        val = fpv;
                     43: 
                     44:        /*
                     45:         * If we have to, decode the integral part
                     46:         */
                     47:        if (!(val & 0xffff0000))
                     48:            cp--;
                     49:        else {
                     50:                register u_short sv = (u_short)(val >> 16);
                     51:                register u_short tmp;
                     52:                register u_short ten = 10;
                     53: 
                     54:                do {
                     55:                        tmp = sv;
                     56:                        sv = (u_short) (sv/ten);
                     57:                        *(--cp) = (u_char)(tmp - ((sv<<3) + (sv<<1)));
                     58:                } while (sv != 0);
                     59:        }
                     60: 
                     61:        /*
                     62:         * Figure out how much of the fraction to do
                     63:         */
                     64:        if (msec) {
                     65:                dec = (short)(ndec + 3);
                     66:                if (dec < 3)
                     67:                    dec = 3;
                     68:                cpdec = &cbuf[8];
                     69:        } else {
                     70:                dec = ndec;
                     71:                cpdec = cpend;
                     72:        }
                     73: 
                     74:        if (dec > 6)
                     75:            dec = 6;
                     76:        
                     77:        if (dec > 0) {
                     78:                do {
                     79:                        val &= 0xffff;
                     80:                        val = (val << 3) + (val << 1);
                     81:                        *cpend++ = (u_char)(val >> 16);
                     82:                } while (--dec > 0);
                     83:        }
                     84: 
                     85:        if (val & 0x8000) {
                     86:                register u_char *tp;
                     87:                /*
                     88:                 * Round it. Ick.
                     89:                 */
                     90:                tp = cpend;
                     91:                *(--tp) += 1;
                     92:                while (*tp >= 10) {
                     93:                        *tp = 0;
                     94:                        *(--tp) += 1;
                     95:                }
                     96:        }
                     97: 
                     98:        /*
                     99:         * Remove leading zeroes if necessary
                    100:         */
                    101:        while (cp < (cpdec -1) && *cp == 0)
                    102:            cp++;
                    103:        
                    104:        /*
                    105:         * Copy it into the buffer, asciizing as we go.
                    106:         */
                    107:        bp = buf;
                    108:        if (neg)
                    109:            *bp++ = '-';
                    110:        
                    111:        while (cp < cpend) {
                    112:                if (cp == cpdec)
                    113:                    *bp++ = '.';
                    114:                *bp++ = (char)(*cp++ + '0');
                    115:        }
                    116:        *bp = '\0';
                    117:        return buf;
                    118: }