URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-stable/] [newlib-1.18.0/] [newlib/] [libc/] [stdlib/] [ecvtbuf.c] - Rev 829
Compare with Previous | Blame | View Log
/* FUNCTION <<ecvtbuf>>, <<fcvtbuf>>---double or float to string INDEX ecvtbuf INDEX fcvtbuf ANSI_SYNOPSIS #include <stdio.h> char *ecvtbuf(double <[val]>, int <[chars]>, int *<[decpt]>, int *<[sgn]>, char *<[buf]>); char *fcvtbuf(double <[val]>, int <[decimals]>, int *<[decpt]>, int *<[sgn]>, char *<[buf]>); TRAD_SYNOPSIS #include <stdio.h> char *ecvtbuf(<[val]>, <[chars]>, <[decpt]>, <[sgn]>, <[buf]>); double <[val]>; int <[chars]>; int *<[decpt]>; int *<[sgn]>; char *<[buf]>; char *fcvtbuf(<[val]>, <[decimals]>, <[decpt]>, <[sgn]>, <[buf]>); double <[val]>; int <[decimals]>; int *<[decpt]>; int *<[sgn]>; char *<[buf]>; DESCRIPTION <<ecvtbuf>> and <<fcvtbuf>> produce (null-terminated) strings of digits representating the <<double>> number <[val]>. The only difference between <<ecvtbuf>> and <<fcvtbuf>> is the interpretation of the second argument (<[chars]> or <[decimals]>). For <<ecvtbuf>>, the second argument <[chars]> specifies the total number of characters to write (which is also the number of significant digits in the formatted string, since these two functions write only digits). For <<fcvtbuf>>, the second argument <[decimals]> specifies the number of characters to write after the decimal point; all digits for the integer part of <[val]> are always included. Since <<ecvtbuf>> and <<fcvtbuf>> write only digits in the output string, they record the location of the decimal point in <<*<[decpt]>>>, and the sign of the number in <<*<[sgn]>>>. After formatting a number, <<*<[decpt]>>> contains the number of digits to the left of the decimal point. <<*<[sgn]>>> contains <<0>> if the number is positive, and <<1>> if it is negative. For both functions, you supply a pointer <[buf]> to an area of memory to hold the converted string. RETURNS Both functions return a pointer to <[buf]>, the string containing a character representation of <[val]>. PORTABILITY Neither function is ANSI C. Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>, <<lseek>>, <<read>>, <<sbrk>>, <<write>>. */ #include <_ansi.h> #include <stdlib.h> #include <string.h> #include <reent.h> #include "mprec.h" #include "local.h" static void _DEFUN (print_f, (ptr, buf, invalue, ndigit, type, dot, mode), struct _reent *ptr _AND char *buf _AND double invalue _AND int ndigit _AND char type _AND int dot _AND int mode) { int decpt; int sign; char *p, *start, *end; start = p = _dtoa_r (ptr, invalue, mode, ndigit, &decpt, &sign, &end); if (decpt == 9999) { strcpy (buf, p); return; } while (*p && decpt > 0) { *buf++ = *p++; decpt--; } /* Even if not in buffer */ while (decpt > 0) { *buf++ = '0'; decpt--; } if (dot || *p) { if (p == start) *buf++ = '0'; *buf++ = '.'; while (decpt < 0 && ndigit > 0) { *buf++ = '0'; decpt++; ndigit--; } /* Print rest of stuff */ while (*p && ndigit > 0) { *buf++ = *p++; ndigit--; } /* And trailing zeros */ while (ndigit > 0) { *buf++ = '0'; ndigit--; } } *buf++ = 0; } /* Print number in e format with width chars after. TYPE is one of 'e' or 'E'. It may also be one of 'g' or 'G' indicating that _gcvt is calling us and we should remove trailing zeroes. WIDTH is the number of digits of precision after the decimal point. */ static void _DEFUN (print_e, (ptr, buf, invalue, width, type, dot), struct _reent *ptr _AND char *buf _AND double invalue _AND int width _AND char type _AND int dot) { int sign; char *end; char *p; int decpt; int top; int ndigit = width; p = _dtoa_r (ptr, invalue, 2, width + 1, &decpt, &sign, &end); if (decpt == 9999) { strcpy (buf, p); return; } *buf++ = *p++; if (dot || ndigit != 0) *buf++ = '.'; while (*p && ndigit > 0) { *buf++ = *p++; ndigit--; } /* Add trailing zeroes to fill out to ndigits unless this is 'g' format. Also, convert g/G to e/E. */ if (type == 'g') type = 'e'; else if (type == 'G') type = 'E'; else { while (ndigit > 0) { *buf++ = '0'; ndigit--; } } /* Add the exponent. */ *buf++ = type; decpt--; if (decpt < 0) { *buf++ = '-'; decpt = -decpt; } else { *buf++ = '+'; } if (decpt > 99) { int top = decpt / 100; *buf++ = top + '0'; decpt -= top * 100; } top = decpt / 10; *buf++ = top + '0'; decpt -= top * 10; *buf++ = decpt + '0'; *buf++ = 0; } #ifndef _REENT_ONLY /* Undocumented behaviour: when given NULL as a buffer, return a pointer to static space in the rent structure. This is only to support ecvt and fcvt, which aren't ANSI anyway. */ char * _DEFUN (fcvtbuf, (invalue, ndigit, decpt, sign, fcvt_buf), double invalue _AND int ndigit _AND int *decpt _AND int *sign _AND char *fcvt_buf) { char *save; char *p; char *end; int done = 0; if (fcvt_buf == NULL) { if (_REENT->_cvtlen <= ndigit + 35) { if ((fcvt_buf = (char *) _realloc_r (_REENT, _REENT->_cvtbuf, ndigit + 36)) == NULL) return NULL; _REENT->_cvtlen = ndigit + 36; _REENT->_cvtbuf = fcvt_buf; } fcvt_buf = _REENT->_cvtbuf ; } save = fcvt_buf; if (invalue < 1.0 && invalue > -1.0) { p = _dtoa_r (_REENT, invalue, 2, ndigit, decpt, sign, &end); } else { p = _dtoa_r (_REENT, invalue, 3, ndigit, decpt, sign, &end); } /* Now copy */ done = -*decpt; while (p < end) { *fcvt_buf++ = *p++; done++; } /* And unsuppress the trailing zeroes */ while (done < ndigit) { *fcvt_buf++ = '0'; done++; } *fcvt_buf++ = 0; return save; } char * _DEFUN (ecvtbuf, (invalue, ndigit, decpt, sign, fcvt_buf), double invalue _AND int ndigit _AND int *decpt _AND int *sign _AND char *fcvt_buf) { char *save; char *p; char *end; int done = 0; if (fcvt_buf == NULL) { if (_REENT->_cvtlen <= ndigit) { if ((fcvt_buf = (char *) _realloc_r (_REENT, _REENT->_cvtbuf, ndigit + 1)) == NULL) return NULL; _REENT->_cvtlen = ndigit + 1; _REENT->_cvtbuf = fcvt_buf; } fcvt_buf = _REENT->_cvtbuf ; } save = fcvt_buf; p = _dtoa_r (_REENT, invalue, 2, ndigit, decpt, sign, &end); /* Now copy */ while (p < end) { *fcvt_buf++ = *p++; done++; } /* And unsuppress the trailing zeroes */ while (done < ndigit) { *fcvt_buf++ = '0'; done++; } *fcvt_buf++ = 0; return save; } #endif char * _DEFUN (_gcvt, (ptr, invalue, ndigit, buf, type, dot), struct _reent *ptr _AND double invalue _AND int ndigit _AND char *buf _AND char type _AND int dot) { char *save = buf; if (invalue < 0) { invalue = -invalue; } if (invalue == 0) { *buf++ = '0'; *buf = '\0'; } else /* Which one to print ? ANSI says that anything with more that 4 zeros after the . or more than precision digits before is printed in e with the qualification that trailing zeroes are removed from the fraction portion. */ if (0.0001 >= invalue || invalue >= _mprec_log10 (ndigit)) { /* We subtract 1 from ndigit because in the 'e' format the precision is the number of digits after the . but in 'g' format it is the number of significant digits. We defer changing type to e/E so that print_e() can know it's us calling and thus should remove trailing zeroes. */ print_e (ptr, buf, invalue, ndigit - 1, type, dot); } else { int decpt; int sign; char *end; char *p; if (invalue < 1.0) { /* what we want is ndigits after the point */ p = _dtoa_r (ptr, invalue, 3, ndigit, &decpt, &sign, &end); } else { p = _dtoa_r (ptr, invalue, 2, ndigit, &decpt, &sign, &end); } if (decpt == 9999) { strcpy (buf, p); return save; } while (*p && decpt > 0) { *buf++ = *p++; decpt--; ndigit--; } /* Even if not in buffer */ while (decpt > 0 && ndigit > 0) { *buf++ = '0'; decpt--; ndigit--; } if (dot || *p) { if (buf == save) *buf++ = '0'; *buf++ = '.'; while (decpt < 0 && ndigit > 0) { *buf++ = '0'; decpt++; ndigit--; } /* Print rest of stuff */ while (*p && ndigit > 0) { *buf++ = *p++; ndigit--; } /* And trailing zeros */ if (dot) { while (ndigit > 0) { *buf++ = '0'; ndigit--; } } } *buf++ = 0; } return save; } char * _DEFUN (_dcvt, (ptr, buffer, invalue, precision, width, type, dot), struct _reent *ptr _AND char *buffer _AND double invalue _AND int precision _AND int width _AND char type _AND int dot) { switch (type) { case 'f': case 'F': print_f (ptr, buffer, invalue, precision, type, precision == 0 ? dot : 1, 3); break; case 'g': case 'G': if (precision == 0) precision = 1; _gcvt (ptr, invalue, precision, buffer, type, dot); break; case 'e': case 'E': print_e (ptr, buffer, invalue, precision, type, dot); } return buffer; }