Return to number.c CVS log

Up to [Research Unix] / researchv10no / cmd / sort

Annotation of researchv10no/cmd/sort/number.c, revision 1.1.1.1

1.1       root        1: /* Copyright 1990, AT&T Bell Labs */
                      2: 
                      3: /* Canonicalize the number string pointed to by dp, of length
                      4:    len.  Put the result in kp.
                      5: 
                      6:    A field of length zero, or all blank, is regarded as 0.
                      7:    Over/underflow is rendered as huge or zero and properly signed.
                      8:    It happens 1e+-1022.
                      9: 
                     10:    Canonicalized strings may be compared as strings of unsigned
                     11:    chars.  For good measure, a canonical string has no zero bytes.
                     12: 
                     13:    Syntax: optionally signed floating point, with optional
                     14:    leading spaces.  A syntax deviation ends the number.
                     15: 
                     16:    Form of output: packed in 4-bit nibbles.  First
                     17:    3 nibbles count the number N of significant digits
                     18:    before the decimal point.  The quantity actually stored
                     19:    is 2048+sign(x)*(N+1024).  Further nibbles contain
                     20:    1 decimal digit d each, stored as d+2 if x is positive
                     21:    and as 10-d if x is negative.  Leading and trailing
                     22:    zeros are stripped, and a trailing "digit" d = -1 
                     23:    is appended.  (The trailing digit handled like all others,
                     24:    so encodes as 1 or 0xb according to the sign of x.)
                     25:    An odd number of nibbles is padded with zero.
                     26: 
                     27:    Buglet: overflow is reported if output is exactly filled.
                     28: 
                     29: */
                     30: #include "fsort.h"
                     31: 
                     32: #define encode(x) (neg? 10-(x): (x)+2)
                     33: #define putdig(x) (nib? (*dig=encode(x)<<4, nib=0): \
                     34:                  (*dig++|=encode(x), nib=1))
                     35: 
                     36: static int gflag;
                     37: 
                     38: int
                     39: gcode(uchar *dp, uchar*kp, int len, struct field *f)
                     40: {
                     41:        int ret;
                     42:        gflag++;
                     43:        ret = ncode(dp, kp, len, f);
                     44:        gflag--;
                     45:        return ret;
                     46: }
                     47: 
                     48: int
                     49: ncode(uchar *dp, uchar*kp, int len, struct field *f)
                     50: {
                     51:        uchar *dig = kp + 1;    /* byte for next digit */
                     52:        int nib = 0;    /* high nibble 1, low nibble 0 */
                     53:        uchar *cp = dp;
                     54:        uchar *ep = cp + len;   /* end pointer */
                     55:        int zeros = 0;  /* count zeros seen but not installed */
                     56:        int sigdig = 1024;
                     57:        int neg = f->rflag;     /* 0 for +, 1 for - */
                     58:        int decimal = 0;
                     59:        int n, inv;
                     60: 
                     61:        kp[1] = 0;
                     62:        for( ; cp<ep ; cp++)    /* eat blanks */
                     63:                if(*cp!=' ' && *cp!='\t')
                     64:                        break;
                     65:        if(cp < ep)             /* eat sign */
                     66:                switch(*cp) {
                     67:                case '-':
                     68:                        neg ^= 1;
                     69:                case '+':
                     70:                        cp++;
                     71:                }
                     72:        for( ; cp<ep; cp++)     /* eat leading zeros */
                     73:                if(*cp != '0')
                     74:                        break;
                     75:        if(*cp=='.' && cp<ep) { /* decimal point among lead zeros */
                     76:                decimal++;
                     77:                for(cp++; cp<ep; cp++) {
                     78:                        if(*cp != '0')
                     79:                                break;
                     80:                        sigdig--;
                     81:                }
                     82:        }
                     83:        if(*cp>'9' || *cp<'0' || cp>=ep) {      /* no sig digit*/
                     84:                sigdig = 0;
                     85:                neg = 0;
                     86:                goto retzero;
                     87:        }
                     88:        for( ; cp<ep; cp++) {
                     89:                switch(*cp) {
                     90:                default:
                     91:                        goto out;
                     92:                case '.':
                     93:                        if(decimal)
                     94:                                goto out;
                     95:                        decimal++;
                     96:                        continue;
                     97:                case '0':
                     98:                        zeros++;
                     99:                        if(!decimal)
                    100:                                sigdig++;
                    101:                        continue;
                    102:                case '1': case '2': case '3': case '4': case '5':
                    103:                case '6': case '7': case '8': case '9':
                    104:                        for( ; zeros>0; zeros--)
                    105:                                putdig(0);
                    106:                        n = *cp - '0';
                    107:                        putdig(n);
                    108:                        if(!decimal)
                    109:                                sigdig++;
                    110:                        continue;
                    111:                case 'e':
                    112:                case 'E':
                    113:                        if(!gflag)
                    114:                                goto out;
                    115:                        inv = 1;
                    116:                        if(cp < ep) switch(*++cp) {
                    117:                        case '-':
                    118:                                inv = -1;
                    119:                        case '+':
                    120:                                cp++;
                    121:                        }
                    122:                        if(*cp>'9' || *cp<'0' || cp>=ep)
                    123:                                goto out;
                    124:                        for(n=0; cp<ep; cp++) {
                    125:                                int c = *cp;
                    126:                                if(c<'0' || c>'9')
                    127:                                        break;
                    128:                                if((n = 10*n+c-'0') >= 0)
                    129:                                        continue;
                    130:                                sigdig = 2047*inv;
                    131:                                goto out;
                    132:                        }
                    133:                        sigdig += n*inv;
                    134:                        goto out;
                    135:                }
                    136:        }
                    137: out:
                    138:        if(sigdig<0 || sigdig>=2047) {
                    139:                sigdig = sigdig<0? 0: 2047;
                    140:                warn("numeric field overflow", (char*)dp, len);
                    141:                dig = kp + 1;
                    142:                *dig = 0;
                    143:                nib = 0;
                    144:        }
                    145: retzero:
                    146:        if(neg)
                    147:                sigdig = 2048 - sigdig;
                    148:        else
                    149:                sigdig = 2048 + sigdig;
                    150:        kp[0] = sigdig >> 4;
                    151:        kp[1] |= sigdig << 4;
                    152:        putdig(-1);
                    153:        return dig - kp + 1 - nib;
                    154: }

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