740 lines
20 KiB
C
740 lines
20 KiB
C
/***
|
|
*cvt.c - C floating-point output conversions
|
|
*
|
|
* Copyright (c) 1987-89, Microsoft Corporation
|
|
*
|
|
*Purpose:
|
|
* contains routines for performing %e, %f, and %g output conversions
|
|
* for printf, etc.
|
|
*
|
|
* routines include _cfltcvt(), _cftoe(), _cftof(), _cftog(), _fassign(),
|
|
* _positive(), _cropzeros(), _forcdecpt()
|
|
*
|
|
*Revision History:
|
|
* 04-18-84 RN author
|
|
* 01-15-87 BCM corrected processing of %g formats (to handle precision
|
|
* as the maximum number of signifcant digits displayed)
|
|
* 03-24-87 BCM Evaluation Issues: (fccvt.obj version for ?LIBFA)
|
|
* ------------------
|
|
* SDS - no problem
|
|
* GD/TS :
|
|
* char g_fmt = 0; (local, initialized)
|
|
* int g_magnitude =0; (local, initialized)
|
|
* char g_round_expansion = 0; (local, initialized)
|
|
* STRFLT g_pflt; (local, uninitialized)
|
|
* other INIT :
|
|
* ALTMATH __fpmath() initialization (perhaps)
|
|
* TERM - nothing
|
|
* 10-22-87 BCM changes for OS/2 Support Library -
|
|
* including elimination of g_... static variables
|
|
* in favor of stack-based variables & function arguments
|
|
* under MTHREAD switch; changed interfaces to _cfto? routines
|
|
* 01-15-88 BCM remove IBMC20 switches; use only memmove, not memcpy;
|
|
* use just MTHREAD switch, not SS_NEQ_DGROUP
|
|
* 06-13-88 WAJ Fixed %.1g processing for small x
|
|
* 08-02-88 WAJ Made changes to _fassign() for new input().
|
|
* 03-09-89 WAJ Added some long double support.
|
|
* 06-05-89 WAJ Made changes for C6. LDOUBLE => long double
|
|
* 06-12-89 WAJ Renamed this file from cvtn.c to cvt.c
|
|
* 11-02-89 WAJ Removed register.h
|
|
* 06-28-90 WAJ Removed fars.
|
|
* 11-15-90 WAJ Added _cdecl where needed. Also "pascal" => "_pascal".
|
|
* 09-12-91 GDP _cdecl=>_CALLTYPE2 _pascal=>_CALLTYPE5 near=>_NEAR
|
|
* 04-30-92 GDP Removed floating point code. Instead used S/W routines
|
|
* (_atodbl, _atoflt _atoldbl), so that to avoid generation
|
|
* of IEEE exceptions from the lib code.
|
|
* 03-11-93 JWM Added minimal support for _INTL decimal point - one byte only!
|
|
* 07-16-93 SRW ALPHA Merge
|
|
*
|
|
*******************************************************************************/
|
|
|
|
#include <ctype.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include <cv.h>
|
|
#include <nlsint.h>
|
|
|
|
#ifdef i386
|
|
// Uncomment this for enabling 10-byte long double string conversions
|
|
// #define LONG_DOUBLE
|
|
#endif
|
|
|
|
|
|
/* this routine resides in the crt32 tree */
|
|
extern void _fptostr(char *buf, int digits, STRFLT pflt);
|
|
|
|
|
|
static void _CALLTYPE5 _shift( char *s, int dist );
|
|
|
|
#ifdef MTHREAD
|
|
static char * _cftoe2( char * buf, int ndec, int caps, STRFLT pflt, char g_fmt );
|
|
static char * _cftof2( char * buf, int ndec, STRFLT pflt, char g_fmt );
|
|
|
|
#else /* not MTHREAD */
|
|
static char * _cftoe_g( double * pvalue, char * buf, int ndec, int caps );
|
|
static char * _cftof_g( double * pvalue, char * buf, int ndec );
|
|
#endif /* not MTHREAD */
|
|
|
|
/***
|
|
*_forcdecpt(buffer) - force a decimal point in floating-point output
|
|
*Purpose:
|
|
* force a decimal point in floating point output. we are only called if '#'
|
|
* flag is given and precision is 0; so we know the number has no '.'. insert
|
|
* the '.' and move everybody else back one position, until '\0' seen
|
|
*
|
|
* side effects: futzes around with the buffer, trying to insert a '.'
|
|
* after the initial string of digits. the first char can usually be
|
|
* skipped since it will be a digit or a '-'. but in the 0-precision case,
|
|
* the number could start with 'e' or 'E', so we'd want the '.' before the
|
|
* exponent in that case.
|
|
*
|
|
*Entry:
|
|
* buffer = (char *) pointer to buffer to modify
|
|
*
|
|
*Exit:
|
|
* returns : (void)
|
|
*
|
|
*Exceptions:
|
|
*******************************************************************************/
|
|
|
|
void _CALLTYPE2 _forcdecpt( char * buffer )
|
|
{
|
|
char holdchar;
|
|
char nextchar;
|
|
|
|
if (tolower(*buffer) != 'e'){
|
|
do {
|
|
buffer++;
|
|
}
|
|
while (isdigit(*buffer));
|
|
}
|
|
|
|
holdchar = *buffer;
|
|
|
|
#ifdef _INTL
|
|
*buffer++ = *_decimal_point;
|
|
#else
|
|
*buffer++ = '.';
|
|
#endif
|
|
|
|
do {
|
|
nextchar = *buffer;
|
|
*buffer = holdchar;
|
|
holdchar = nextchar;
|
|
}
|
|
|
|
while(*buffer++);
|
|
}
|
|
|
|
|
|
/***
|
|
*_cropzeros(buffer) - removes trailing zeros from floating-point output
|
|
*Purpose:
|
|
* removes trailing zeros (after the '.') from floating-point output;
|
|
* called only when we're doing %g format, there's no '#' flag, and
|
|
* precision is non-zero. plays around with the buffer, looking for
|
|
* trailing zeros. when we find them, then we move everbody else forward
|
|
* so they overlay the zeros. if we eliminate the entire fraction part,
|
|
* then we overlay the decimal point ('.'), too.
|
|
*
|
|
* side effects: changes the buffer from
|
|
* [-] digit [digit...] [ . [digits...] [0...] ] [(exponent part)]
|
|
* to
|
|
* [-] digit [digit...] [ . digit [digits...] ] [(exponent part)]
|
|
* or
|
|
* [-] digit [digit...] [(exponent part)]
|
|
*
|
|
*Entry:
|
|
* buffer = (char *) pointer to buffer to modify
|
|
*
|
|
*Exit:
|
|
* returns : (void)
|
|
*
|
|
*Exceptions:
|
|
*******************************************************************************/
|
|
|
|
void _CALLTYPE2 _cropzeros( char * buf )
|
|
{
|
|
char *stop;
|
|
|
|
#ifdef _INTL
|
|
while (*buf && *buf != *_decimal_point)
|
|
#else
|
|
while (*buf && *buf != '.')
|
|
#endif
|
|
buf++;
|
|
|
|
if (*buf++) {
|
|
while (*buf && *buf != 'e' && *buf != 'E')
|
|
buf++;
|
|
|
|
stop = buf--;
|
|
|
|
while (*buf == '0')
|
|
buf--;
|
|
|
|
#ifdef _INTL
|
|
if (*buf == *_decimal_point)
|
|
#else
|
|
if (*buf == '.')
|
|
#endif
|
|
buf--;
|
|
|
|
while( (*++buf = *stop++) != '\0' );
|
|
}
|
|
}
|
|
|
|
|
|
int _CALLTYPE2 _positive( double * arg )
|
|
{
|
|
return( (*arg >= 0.0) );
|
|
}
|
|
|
|
|
|
void _CALLTYPE2 _fassign( int flag, char * argument, char * number )
|
|
{
|
|
|
|
FLOAT floattemp;
|
|
DOUBLE doubletemp;
|
|
|
|
#ifdef LONG_DOUBLE
|
|
_LDOUBLE longtemp;
|
|
|
|
switch( flag ){
|
|
case 2:
|
|
_atoldbl(&longtemp, number );
|
|
*(_LDOUBLE UNALIGNED *)argument = longtemp;
|
|
break;
|
|
|
|
case 1:
|
|
_atodbl( &doubletemp, number );
|
|
*(DOUBLE UNALIGNED *)argument = doubletemp;
|
|
break;
|
|
|
|
default:
|
|
_atoflt( &floattemp, number );
|
|
*(FLOAT UNALIGNED *)argument = floattemp;
|
|
}
|
|
|
|
#else /* not LONG_DOUBLE */
|
|
if (flag) {
|
|
|
|
_atodbl( &doubletemp, number );
|
|
#if defined(_ALPHA_) && !defined(_MSC_VER)
|
|
/*
|
|
* Alpha acc does not support unaligned double yet.
|
|
*/
|
|
((long UNALIGNED *)argument)[0] = ((long *)&doubletemp)[0];
|
|
((long UNALIGNED *)argument)[1] = ((long *)&doubletemp)[1];
|
|
#else
|
|
*(DOUBLE UNALIGNED *)argument = doubletemp;
|
|
#endif
|
|
} else {
|
|
_atoflt( &floattemp, number );
|
|
#if defined(_ALPHA_) && !defined(_MSC_VER)
|
|
/*
|
|
* Alpha acc does not support unaligned float yet.
|
|
*/
|
|
*((long UNALIGNED *)argument) = *((long *)&floattemp);
|
|
#else
|
|
*(FLOAT UNALIGNED *)argument = floattemp;
|
|
#endif
|
|
}
|
|
#endif /* not LONG_DOUBLE */
|
|
}
|
|
|
|
|
|
#ifndef MTHREAD
|
|
static char g_fmt = 0;
|
|
static int g_magnitude = 0;
|
|
static char g_round_expansion = 0;
|
|
static STRFLT g_pflt;
|
|
#endif
|
|
|
|
|
|
/*
|
|
* Function name: _cftoe
|
|
*
|
|
* Arguments: pvalue - double * pointer
|
|
* buf - char * pointer
|
|
* ndec - int
|
|
* caps - int
|
|
*
|
|
* Description: _cftoe converts the double pointed to by pvalue to a null
|
|
* terminated string of ASCII digits in the c language
|
|
* printf %e format, nad returns a pointer to the result.
|
|
* This format has the form [-]d.ddde(+/-)ddd, where there
|
|
* will be ndec digits following the decimal point. If
|
|
* ndec <= 0, no decimal point will appear. The low order
|
|
* digit is rounded. If caps is nonzero then the exponent
|
|
* will appear as E(+/-)ddd.
|
|
*
|
|
* Side Effects: the buffer 'buf' is assumed to have a minimum length
|
|
* of CVTBUFSIZE (defined in cvt.h) and the routines will
|
|
* not write over this size.
|
|
*
|
|
* Copyright: written R.K. Wyss, Microsoft, Sept. 9, 1983
|
|
* copyright (c) Microsoft Corp. 1983
|
|
*
|
|
* History:
|
|
*
|
|
*/
|
|
|
|
#ifdef MTHREAD
|
|
static char * _cftoe2( char * buf, int ndec, int caps, STRFLT pflt, char g_fmt )
|
|
#else
|
|
char * _CALLTYPE2 _cftoe( double * pvalue, char * buf, int ndec, int caps )
|
|
#endif
|
|
{
|
|
#ifndef MTHREAD
|
|
STRFLT pflt;
|
|
#endif
|
|
|
|
char *p;
|
|
int exp;
|
|
|
|
#ifdef MTHREAD
|
|
int g_magnitude = pflt->decpt - 1;
|
|
#endif
|
|
|
|
/* first convert the value */
|
|
|
|
/* place the output in the buffer and round. Leave space in the buffer
|
|
* for the '-' sign (if any) and the decimal point (if any)
|
|
*/
|
|
|
|
if (g_fmt) {
|
|
#ifndef MTHREAD
|
|
pflt = g_pflt;
|
|
#endif
|
|
/* shift it right one place if nec. for decimal point */
|
|
|
|
p = buf + (pflt->sign == '-');
|
|
_shift(p, (ndec > 0));
|
|
}
|
|
#ifndef MTHREAD
|
|
else {
|
|
pflt = _fltout(*pvalue);
|
|
_fptostr(buf + (pflt->sign == '-') + (ndec > 0), ndec + 1, pflt);
|
|
}
|
|
#endif
|
|
|
|
|
|
/* now fix the number up to be in e format */
|
|
|
|
p = buf;
|
|
|
|
/* put in negative sign if needed */
|
|
|
|
if (pflt->sign == '-')
|
|
*p++ = '-';
|
|
|
|
/* put in decimal point if needed. Copy the first digit to the place
|
|
* left for it and put the decimal point in its place
|
|
*/
|
|
|
|
if (ndec > 0) {
|
|
*p = *(p+1);
|
|
#ifdef _INTL
|
|
*(++p) = *_decimal_point;
|
|
#else
|
|
*(++p) = '.';
|
|
#endif
|
|
}
|
|
|
|
/* find the end of the string and attach the exponent field */
|
|
|
|
p = strcpy(p+ndec+(!g_fmt), "e+000");
|
|
|
|
/* adjust exponent indicator according to caps flag and increment
|
|
* pointer to point to exponent sign
|
|
*/
|
|
|
|
if (caps)
|
|
*p = 'E';
|
|
|
|
p++;
|
|
|
|
/* if mantissa is zero, then the number is 0 and we are done; otherwise
|
|
* adjust the exponent sign (if necessary) and value.
|
|
*/
|
|
|
|
if (*pflt->mantissa != '0') {
|
|
|
|
/* check to see if exponent is negative; if so adjust exponent sign and
|
|
* exponent value.
|
|
*/
|
|
|
|
if( (exp = pflt->decpt - 1) < 0 ) {
|
|
exp = -exp;
|
|
*p = '-';
|
|
}
|
|
|
|
p++;
|
|
|
|
if (exp >= 100) {
|
|
*p += (char)(exp / 100);
|
|
exp %= 100;
|
|
}
|
|
p++;
|
|
|
|
if (exp >= 10) {
|
|
*p += (char)(exp / 10);
|
|
exp %= 10;
|
|
}
|
|
|
|
*++p += (char)exp;
|
|
}
|
|
|
|
return(buf);
|
|
}
|
|
|
|
|
|
#ifdef MTHREAD
|
|
|
|
char * _CALLTYPE2 _cftoe( double * pvalue, char * buf, int ndec, int caps )
|
|
{
|
|
struct _strflt retstrflt;
|
|
char resstr[21];
|
|
STRFLT pflt = &retstrflt;
|
|
|
|
_fltout2(*pvalue, (struct _strflt *)&retstrflt,
|
|
(char *)resstr);
|
|
_fptostr(buf + (pflt->sign == '-') + (ndec > 0), ndec + 1, pflt);
|
|
_cftoe2(buf, ndec, caps, pflt, /* g_fmt = */ 0);
|
|
|
|
return( buf );
|
|
}
|
|
|
|
#else /* not MTHREAD */
|
|
|
|
static char * _cftoe_g( double * pvalue, char * buf, int ndec, int caps )
|
|
{
|
|
char *res;
|
|
g_fmt = 1;
|
|
res = _cftoe(pvalue, buf, ndec, caps);
|
|
g_fmt = 0;
|
|
return (res);
|
|
}
|
|
|
|
#endif /* not MTHREAD */
|
|
|
|
|
|
#ifdef MTHREAD
|
|
static char * _cftof2( char * buf, int ndec, STRFLT pflt, char g_fmt )
|
|
|
|
#else
|
|
char * _CALLTYPE2 _cftof( double * pvalue, char * buf, int ndec )
|
|
#endif
|
|
|
|
{
|
|
#ifndef MTHREAD
|
|
STRFLT pflt;
|
|
#endif
|
|
|
|
char *p;
|
|
char addzero = 0;
|
|
|
|
#ifdef MTHREAD
|
|
int g_magnitude = pflt->decpt - 1;
|
|
#endif
|
|
|
|
|
|
/* first convert the value */
|
|
|
|
/* place the output in the users buffer and round. Save space for
|
|
* the minus sign now if it will be needed
|
|
*/
|
|
|
|
if (g_fmt) {
|
|
#ifndef MTHREAD
|
|
pflt = g_pflt;
|
|
#endif
|
|
|
|
p = buf + (pflt->sign == '-');
|
|
if (g_magnitude == ndec) {
|
|
char *q = p + g_magnitude;
|
|
*q++ = '0';
|
|
*q = '\0';
|
|
/* allows for extra place-holding '0' in the exponent == precision
|
|
* case of the g format
|
|
*/
|
|
}
|
|
}
|
|
#ifndef MTHREAD
|
|
else {
|
|
pflt = _fltout(*pvalue);
|
|
_fptostr(buf+(pflt->sign == '-'), ndec + pflt->decpt, pflt);
|
|
}
|
|
#endif
|
|
|
|
|
|
/* now fix up the number to be in the correct f format */
|
|
|
|
p = buf;
|
|
|
|
/* put in negative sign, if necessary */
|
|
|
|
if (pflt->sign == '-')
|
|
*p++ = '-';
|
|
|
|
/* insert leading 0 for purely fractional values and position ourselves
|
|
* at the correct spot for inserting the decimal point
|
|
*/
|
|
|
|
if (pflt->decpt <= 0) {
|
|
_shift(p, 1);
|
|
*p++ = '0';
|
|
}
|
|
else
|
|
p += pflt->decpt;
|
|
|
|
/* put in decimal point if required and any zero padding needed */
|
|
|
|
if (ndec > 0) {
|
|
_shift(p, 1);
|
|
#ifdef _INTL
|
|
*p++ = *_decimal_point;
|
|
#else
|
|
*p++ = '.';
|
|
#endif
|
|
|
|
/* if the value is less than 1 then we may need to put 0's out in
|
|
* front of the first non-zero digit of the mantissa
|
|
*/
|
|
|
|
if (pflt->decpt < 0) {
|
|
if( g_fmt )
|
|
ndec = -pflt->decpt;
|
|
else
|
|
ndec = (ndec < -pflt->decpt ) ? ndec : -pflt->decpt;
|
|
_shift(p, ndec);
|
|
memset( p, '0', ndec);
|
|
}
|
|
}
|
|
|
|
return( buf);
|
|
}
|
|
|
|
|
|
/*
|
|
* Function name: _cftof
|
|
*
|
|
* Arguments: value - double * pointer
|
|
* buf - char * pointer
|
|
* ndec - int
|
|
*
|
|
* Description: _cftof converts the double pointed to by pvalue to a null
|
|
* terminated string of ASCII digits in the c language
|
|
* printf %f format, and returns a pointer to the result.
|
|
* This format has the form [-]ddddd.ddddd, where there will
|
|
* be ndec digits following the decimal point. If ndec <= 0,
|
|
* no decimal point will appear. The low order digit is
|
|
* rounded.
|
|
*
|
|
* Side Effects: the buffer 'buf' is assumed to have a minimum length
|
|
* of CVTBUFSIZE (defined in cvt.h) and the routines will
|
|
* not write over this size.
|
|
*
|
|
* Copyright: written R.K. Wyss, Microsoft, Sept. 9, 1983
|
|
* copyright (c) Microsoft Corp. 1983
|
|
*
|
|
* History:
|
|
*
|
|
*/
|
|
|
|
#ifdef MTHREAD
|
|
|
|
char * _CALLTYPE2 _cftof( double * pvalue, char * buf, int ndec )
|
|
{
|
|
struct _strflt retstrflt;
|
|
char resstr[21];
|
|
STRFLT pflt = &retstrflt;
|
|
_fltout2(*pvalue, (struct _strflt *) &retstrflt,
|
|
(char *) resstr);
|
|
_fptostr(buf+(pflt->sign == '-'), ndec + pflt->decpt, pflt);
|
|
_cftof2(buf, ndec, pflt, /* g_fmt = */ 0);
|
|
|
|
return( buf );
|
|
}
|
|
|
|
#else /* not MTHREAD */
|
|
|
|
|
|
static char * _cftof_g( double * pvalue, char * buf, int ndec )
|
|
{
|
|
char *res;
|
|
g_fmt = 1;
|
|
res = _cftof(pvalue, buf, ndec);
|
|
g_fmt = 0;
|
|
return (res);
|
|
}
|
|
|
|
#endif /* not MTHREAD */
|
|
|
|
/*
|
|
* Function name: _cftog
|
|
*
|
|
* Arguments: value - double * pointer
|
|
* buf - char * pointer
|
|
* ndec - int
|
|
*
|
|
* Description: _cftog converts the double pointed to by pvalue to a null
|
|
* terminated string of ASCII digits in the c language
|
|
* printf %g format, and returns a pointer to the result.
|
|
* The form used depends on the value converted. The printf
|
|
* %e form will be used if the magnitude of valude is less
|
|
* than -4 or is greater than ndec, otherwise printf %f will
|
|
* be used. ndec always specifies the number of digits
|
|
* following the decimal point. The low order digit is
|
|
* appropriately rounded.
|
|
*
|
|
* Side Effects: the buffer 'buf' is assumed to have a minimum length
|
|
* of CVTBUFSIZE (defined in cvt.h) and the routines will
|
|
* not write over this size.
|
|
*
|
|
* Copyright: written R.K. Wyss, Microsoft, Sept. 9, 1983
|
|
* copyright (c) Microsoft Corp. 1983
|
|
*
|
|
* History:
|
|
*
|
|
*/
|
|
|
|
char * _CALLTYPE2 _cftog( double * pvalue, char * buf, int ndec, int caps )
|
|
{
|
|
char *p;
|
|
|
|
#ifdef MTHREAD
|
|
char g_round_expansion = 0;
|
|
STRFLT g_pflt;
|
|
int g_magnitude;
|
|
struct _strflt retstrflt;
|
|
char resstr[21];
|
|
|
|
/* first convert the number */
|
|
|
|
g_pflt = &retstrflt;
|
|
_fltout2(*pvalue, (struct _strflt *)&retstrflt,
|
|
(char *)resstr);
|
|
|
|
#else /* not MTHREAD */
|
|
|
|
/* first convert the number */
|
|
|
|
g_pflt = _fltout(*pvalue);
|
|
#endif /* not MTHREAD */
|
|
|
|
g_magnitude = g_pflt->decpt - 1;
|
|
p = buf + (g_pflt->sign == '-');
|
|
|
|
_fptostr(p, ndec, g_pflt);
|
|
g_round_expansion = (char)(g_magnitude < (g_pflt->decpt-1));
|
|
|
|
|
|
/* compute the magnitude of value */
|
|
|
|
g_magnitude = g_pflt->decpt - 1;
|
|
|
|
/* convert value to the c language g format */
|
|
|
|
if (g_magnitude < -4 || g_magnitude >= ndec){ /* use e format */
|
|
/* (g_round_expansion ==>
|
|
* extra digit will be overwritten by 'e+xxx')
|
|
*/
|
|
|
|
#ifdef MTHREAD
|
|
return(_cftoe2(buf, ndec, caps, g_pflt, /* g_fmt = */ 1));
|
|
#else
|
|
return(_cftoe_g(pvalue, buf, ndec, caps));
|
|
#endif
|
|
|
|
}
|
|
else { /* use f format */
|
|
if (g_round_expansion) {
|
|
/* throw away extra final digit from expansion */
|
|
while (*p++);
|
|
*(p-2) = '\0';
|
|
}
|
|
|
|
#ifdef MTHREAD
|
|
return(_cftof2(buf, ndec, g_pflt, /* g_fmt = */ 1));
|
|
#else
|
|
return(_cftof_g(pvalue, buf, ndec));
|
|
#endif
|
|
|
|
}
|
|
}
|
|
|
|
/***
|
|
*_cfltcvt(arg, buf, format, precision, caps) - convert floating-point output
|
|
*Purpose:
|
|
*
|
|
*Entry:
|
|
* arg = (double *) pointer to double-precision floating-point number
|
|
* buf = (char *) pointer to buffer into which to put the converted
|
|
* ASCII form of the number
|
|
* format = (int) 'e', 'f', or 'g'
|
|
* precision = (int) giving number of decimal places for %e and %f formats,
|
|
* and giving maximum number of significant digits for
|
|
* %g format
|
|
* caps = (int) flag indicating whether 'E' in exponent should be capatilized
|
|
* (for %E and %G formats only)
|
|
*
|
|
*Exit:
|
|
* returns : (void)
|
|
*
|
|
*Exceptions:
|
|
*******************************************************************************/
|
|
/*
|
|
* Function name: _cfltcvt
|
|
*
|
|
* Arguments: arg - double * pointer
|
|
* buf - char * pointer
|
|
* format - int
|
|
* ndec - int
|
|
* caps - int
|
|
*
|
|
* Description: _cfltcvt determines from the format, what routines to
|
|
* call to generate the correct floating point format
|
|
*
|
|
* Side Effects: none
|
|
*
|
|
* Author: Dave Weil, Jan 12, 1985
|
|
*
|
|
* Copyright: Copyright (C) Microsoft Corp. 1985
|
|
*/
|
|
|
|
void _CALLTYPE2 _cfltcvt( double * arg, char * buffer, int format, int precision, int caps )
|
|
{
|
|
if (format == 'e' || format == 'E')
|
|
_cftoe(arg, buffer, precision, caps);
|
|
else if (format == 'f')
|
|
_cftof(arg, buffer, precision);
|
|
else
|
|
_cftog(arg, buffer, precision, caps);
|
|
}
|
|
|
|
/***
|
|
*_shift(s, dist) - shift a null-terminated string in memory (internal routine)
|
|
*Purpose:
|
|
* _shift is a helper routine that shifts a null-terminated string
|
|
* in memory, e.g., moves part of a buffer used for floating-point output
|
|
*
|
|
* modifies memory locations (s+dist) through (s+dist+strlen(s))
|
|
*
|
|
*Entry:
|
|
* s = (char *) pointer to string to move
|
|
* dist = (int) distance to move the string to the right (if negative, to left)
|
|
*
|
|
*Exit:
|
|
* returns : (void)
|
|
*
|
|
*Exceptions:
|
|
*******************************************************************************/
|
|
|
|
static void _CALLTYPE5 _shift( char *s, int dist )
|
|
{
|
|
if( dist )
|
|
memmove(s+dist, s, strlen(s)+1);
|
|
}
|