Return to ftoa.c CVS log

Up to [CSRG BSD Unix] / 42BSD / ingres / source / gutil

Annotation of 42BSD/ingres/source/gutil/ftoa.c, revision 1.1

1.1     ! root        1: # include      <sccs.h>
        !             2: 
        !             3: SCCSID(@(#)ftoa.c      7.1     2/5/81)
        !             4: 
        !             5: # define       MAXDIG          25
        !             6: 
        !             7: /*
        !             8: **  FLOATING POINT TO ASCII CONVERSION
        !             9: **
        !            10: **     'Value' is converted to an ascii character string and stored
        !            11: **     into 'ascii'.  Ascii should have room for at least 'width' + 1
        !            12: **     characters.  'Width' is the width of the output field (max).
        !            13: **     'Prec' is the number of characters to put after the decimal
        !            14: **     point.  The format of the output string is controlled by
        !            15: **     'format'.
        !            16: **
        !            17: **     'Format' can be:
        !            18: **             e or E: "E" format output
        !            19: **             f or F:  "F" format output
        !            20: **             g or G:  "F" format output if it will fit, otherwise
        !            21: **                     use "E" format.
        !            22: **             n or N:  same as G, but decimal points will not always
        !            23: **                     be aligned.
        !            24: **
        !            25: **     If 'format' is upper case, the "E" comes out in upper case;
        !            26: **     otherwise it comes out in lower case.
        !            27: **
        !            28: **     When the field width is not big enough, it fills the field with
        !            29: **     stars ("*****") and returns zero.  Normal return is the width
        !            30: **     of the output field (sometimes shorter than 'width').
        !            31: */
        !            32: 
        !            33: ftoa(value, ascii, width, prec1, format)
        !            34: double value;
        !            35: char   *ascii;
        !            36: int    width;
        !            37: int    prec1;
        !            38: char   format;
        !            39: {
        !            40:        auto int        expon;
        !            41:        auto int        sign;
        !            42:        register int    avail;
        !            43:        register char   *a;
        !            44:        register char   *p;
        !            45:        char            mode;
        !            46:        int             lowercase;
        !            47:        int             prec;
        !            48:        extern char     *ecvt(), *fcvt();
        !            49: 
        !            50:        prec = prec1;
        !            51:        mode = format;
        !            52:        lowercase = 'a' - 'A';
        !            53:        if (mode >= 'a')
        !            54:                mode -= 'a' - 'A';
        !            55:        else
        !            56:                lowercase = 0;
        !            57: 
        !            58:        if (mode != 'E')
        !            59:        {
        !            60:                /* try 'F' style output */
        !            61:                p = fcvt(value, prec, &expon, &sign);
        !            62:                avail = width;
        !            63:                a = ascii;
        !            64: 
        !            65:                /* output sign */
        !            66:                if (sign)
        !            67:                {
        !            68:                        avail--;
        !            69:                        *a++ = '-';
        !            70:                }
        !            71: 
        !            72:                /* output '0' before the decimal point */
        !            73:                if (expon <= 0)
        !            74:                {
        !            75:                        *a++ = '0';
        !            76:                        avail--;
        !            77:                }
        !            78: 
        !            79:                /* compute space length left after dec pt and fraction */
        !            80:                avail -= prec + 1;
        !            81:                if (mode == 'G')
        !            82:                        avail -= 4;
        !            83: 
        !            84:                if (avail >= expon)
        !            85:                {
        !            86: 
        !            87:                        /* it fits.  output */
        !            88:                        while (expon > 0)
        !            89:                        {
        !            90:                                /* output left of dp */
        !            91:                                expon--;
        !            92:                                if (*p)
        !            93:                                {
        !            94:                                        *a++ = *p++;
        !            95:                                }
        !            96:                                else
        !            97:                                        *a++ = '0';
        !            98:                        }
        !            99: 
        !           100:                        /* output fraction (right of dec pt) */
        !           101:                        avail = expon;
        !           102:                        goto frac_out;
        !           103:                }
        !           104:                /* won't fit; let's hope for G format */
        !           105:        }
        !           106: 
        !           107:        if (mode != 'F')
        !           108:        {
        !           109:                /* try to do E style output */
        !           110:                p = ecvt(value, prec + 1, &expon, &sign);
        !           111:                avail = width - 5;
        !           112:                a = ascii;
        !           113: 
        !           114:                /* output the sign */
        !           115:                if (sign)
        !           116:                {
        !           117:                        *a++ = '-';
        !           118:                        avail--;
        !           119:                }
        !           120:        }
        !           121: 
        !           122:        /* check for field too small */
        !           123:        if (mode == 'F' || avail < prec)
        !           124:        {
        !           125:                /* sorry joker, you lose */
        !           126:                a = ascii;
        !           127:                for (avail = width; avail > 0; avail--)
        !           128:                        *a++ = '*';
        !           129:                *a = 0;
        !           130:                return (0);
        !           131:        }
        !           132: 
        !           133:        /* it fits; output the number */
        !           134:        mode = 'E';
        !           135: 
        !           136:        /* output the LHS single digit */
        !           137:        *a++ = *p++;
        !           138:        expon--;
        !           139: 
        !           140:        /* output the rhs */
        !           141:        avail = 1;
        !           142: 
        !           143:   frac_out:
        !           144:        *a++ = '.';
        !           145:        while (prec > 0)
        !           146:        {
        !           147:                prec--;
        !           148:                if (avail < 0)
        !           149:                {
        !           150:                        avail++;
        !           151:                        *a++ = '0';
        !           152:                }
        !           153:                else
        !           154:                {
        !           155:                        if (*p)
        !           156:                                *a++ = *p++;
        !           157:                        else
        !           158:                                *a++ = '0';
        !           159:                }
        !           160:        }
        !           161: 
        !           162:        /* output the exponent */
        !           163:        if (mode == 'E')
        !           164:        {
        !           165:                *a++ = 'E' + lowercase;
        !           166:                if (expon < 0)
        !           167:                {
        !           168:                        *a++ = '-';
        !           169:                        expon = -expon;
        !           170:                }
        !           171:                else
        !           172:                        *a++ = '+';
        !           173:                *a++ = (expon / 10) % 10 + '0';
        !           174:                *a++ = expon % 10 + '0';
        !           175:        }
        !           176: 
        !           177:        /* output spaces on the end in G format */
        !           178:        if (mode == 'G')
        !           179:        {
        !           180:                *a++ = ' ';
        !           181:                *a++ = ' ';
        !           182:                *a++ = ' ';
        !           183:                *a++ = ' ';
        !           184:        }
        !           185: 
        !           186:        /* finally, we can return */
        !           187:        *a = 0;
        !           188:        avail = a - ascii;
        !           189:        return (avail);
        !           190: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.