Return to dolfptoa.c CVS log

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

ntp 4.2.6p5

    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: }