Return to number.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/number.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * print numbers
        !             3:  */
        !             4: 
        !             5: #include <stdio.h>
        !             6: #include <ctype.h>
        !             7: 
        !             8: int    flag;
        !             9: int max  = 21;
        !            10: char   *card[] = {
        !            11:        "hundred",
        !            12:        "thousand",
        !            13:        "million",
        !            14:        "billion",
        !            15:        "trillion",
        !            16:        "quadrillion",
        !            17:        "quintillion",
        !            18:        "sextillion",
        !            19:        "septillion",
        !            20:        "octillion",
        !            21:        "nonillion",
        !            22:        "decillion",
        !            23:        "undecillion",
        !            24:        "duodecillion",
        !            25:        "tredecillion",
        !            26:        "quattuordecillion",
        !            27:        "quindecillion",
        !            28:        "sexdecillion",
        !            29:        "septendecillion",
        !            30:        "octodecillion",
        !            31:        "novemdecillion",
        !            32:        "vigintillion"
        !            33: };
        !            34: char *unit[] = {
        !            35:        "zero",
        !            36:        "one",
        !            37:        "two",
        !            38:        "three",
        !            39:        "four",
        !            40:        "five",
        !            41:        "six",
        !            42:        "seven",
        !            43:        "eight",
        !            44:        "nine"
        !            45: };
        !            46: char *teen[] = {
        !            47:        "ten",
        !            48:        "eleven",
        !            49:        "twelve",
        !            50:        "thirteen",
        !            51:        "fourteen",
        !            52:        "fifteen",
        !            53:        "sixteen",
        !            54:        "seventeen",
        !            55:        "eighteen",
        !            56:        "nineteen"
        !            57: };
        !            58: char *decade[] = {
        !            59:        "zero",
        !            60:        "ten",
        !            61:        "twenty",
        !            62:        "thirty",
        !            63:        "forty",
        !            64:        "fifty",
        !            65:        "sixty",
        !            66:        "seventy",
        !            67:        "eighty",
        !            68:        "ninety"
        !            69: };
        !            70: char   line[100];
        !            71: main()
        !            72: {
        !            73:        register c, i, fraction;
        !            74:        int r;
        !            75: 
        !            76:        setbuf(stdout, NULL);
        !            77:        fraction = 0;
        !            78:        while ((c = getchar()) != EOF)  {
        !            79:                if(!isdigit(c))  {
        !            80:                        fraction = (c == '.');
        !            81:                        putchar(c);
        !            82:                        continue;
        !            83:                }
        !            84:                if(fraction) {
        !            85:                        while(isdigit(c)) {
        !            86:                                putchar(' ');
        !            87:                                putchar(c);
        !            88:                                if ((c = getchar()) == EOF)
        !            89:                                        exit(1);
        !            90:                        }
        !            91:                        putchar(' ');
        !            92:                        goto out;
        !            93:                }
        !            94:                putchar(' ');
        !            95:                i = 0;
        !            96:                line[i++] = '0';
        !            97:                line[i++] = '0';
        !            98:                while(c == '0')
        !            99:                        if ((c = getchar()) == EOF)
        !           100:                                exit(1);
        !           101:                while(isdigit(c)) {
        !           102:                        if(i < 98)
        !           103:                                line[i++] = c;
        !           104:                        if ((c = getchar()) == EOF)
        !           105:                                exit(1);
        !           106:                }
        !           107:                line[i] = 0;
        !           108:                r = i/3;
        !           109:                if(r == 0) {
        !           110:                        print("zero");
        !           111:                        goto out;
        !           112:                }
        !           113:                conv(line+i-3*r, r);
        !           114: 
        !           115: out:
        !           116:                fraction = (c == '.');
        !           117:                nline();
        !           118:                printf("...\n");
        !           119:                if(c != '\n')
        !           120:                        putchar(c);
        !           121:        }
        !           122: }
        !           123: 
        !           124: conv(p, c)
        !           125: char *p;
        !           126: {
        !           127: 
        !           128:        if(c > max) {
        !           129:                conv(p, c-max);
        !           130:                print(card[max]);
        !           131:                nline();
        !           132:                p += (c-max)*3;
        !           133:                c = max;
        !           134:        }
        !           135:        while(c > 1) {
        !           136:                c--;
        !           137:                conv(p, 1);
        !           138:                cprint(card[c]);
        !           139:                nline();
        !           140:                p += 3;
        !           141:        }
        !           142:        ones(p[0]);
        !           143:        cprint(card[0]);
        !           144:        tens(p);
        !           145:        ones(p[2]);
        !           146: }
        !           147: 
        !           148: ones(d)
        !           149: {
        !           150:        if(d=='0')
        !           151:                return;
        !           152:        print(unit[d-'0']);
        !           153: }
        !           154: 
        !           155: tens(p)
        !           156: char *p;
        !           157: {
        !           158: 
        !           159:        switch(p[1]) {
        !           160: 
        !           161:        case '0':
        !           162:                return;
        !           163: 
        !           164:        case '1':
        !           165:                print(teen[p[2]-'0']);
        !           166:                p[2] = '0';
        !           167:                return;
        !           168:        }
        !           169: 
        !           170:        print(decade[p[1]-'0']);
        !           171: }
        !           172: 
        !           173: nline()
        !           174: {
        !           175: 
        !           176:        if(flag)
        !           177:                printf(".\n");
        !           178:        flag = 0;
        !           179: }
        !           180: 
        !           181: cprint(s)
        !           182: char *s;
        !           183: {
        !           184: 
        !           185:        if(flag)
        !           186:                print(s);
        !           187: }
        !           188: 
        !           189: print(s)
        !           190: char *s;
        !           191: {
        !           192: 
        !           193:        if(flag)
        !           194:                printf(" ");
        !           195:        printf(s);
        !           196:        flag = 1;
        !           197: }

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