Return to min.c CVS log

Up to [MW Coherent from dump] / coherent / d / usr / lib / libmp

Annotation of coherent/d/usr/lib/libmp/min.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include <assert.h>
                      3: #include <ctype.h>
                      4: #include "mprec.h"
                      5: 
                      6: 
                      7: /*
                      8:  *     Ibase is an int which contains the input base used by min.
                      9:  *     It should be between 2 and 16.  Regardless of ibase, the
                     10:  *     legal digits are 0 - 9 and A - F.
                     11:  */
                     12: 
                     13: int    ibase = 10;
                     14: 
                     15: 
                     16: /*
                     17:  *     Min reads in a number in base ibase from stdin and sets "a" 
                     18:  *     to that number.  Note that a leading minus sign is allowed as
                     19:  *     are leading blanks.
                     20:  */
                     21: 
                     22: void
                     23: min(a)
                     24: register mint *a;
                     25: {
                     26:        register int ch;
                     27:        register char mifl;     /* leading minus flag */
                     28:        char cval;
                     29:        mint c = {1, &cval};
                     30: 
                     31:        assert(2 <= ibase && ibase <= 16);
                     32:        /* throw away old value, and set to zero */
                     33:        mcopy(mzero, a);
                     34: 
                     35:        /* skip leading blanks */
                     36:        do {
                     37:                ch = getchar();
                     38:        } while (isascii(ch) && isspace(ch));
                     39: 
                     40:        /* check for leading minus */
                     41:        mifl = ch == '-';
                     42:        if (mifl)
                     43:                do {
                     44:                        ch = getchar();
                     45:                } while (isascii(ch) && isspace(ch));
                     46: 
                     47:        /* scan thru actual number, building result in a */
                     48:        while (okdigit(ch)) {
                     49:                cval = valdigit(ch);
                     50:                smult(a, ibase, a);
                     51:                madd(a, &c, a);
                     52:                ch = getchar();
                     53:        }
                     54:        ungetc(ch, stdin);
                     55: 
                     56:        /* adjust sign of a */
                     57:        if (mifl)
                     58:                mneg(a, a);
                     59: }
                     60: 
                     61: 
                     62: /*
                     63:  *     Okdigit returns true iff "ch" is a valid digit.  This means
                     64:  *     iff it is a normal digit or one of the letters 'A' thru 'F'.
                     65:  */
                     66: 
                     67: static
                     68: okdigit(ch)
                     69: register int ch;
                     70: {
                     71:        return (isascii(ch) && isdigit(ch) || 'A'<=ch && ch<='F');
                     72: }
                     73: 
                     74: 
                     75: /*
                     76:  *     Valdigit returns the numerical value for the character "ch"
                     77:  *     when it is interpreted as a digit.  Note that valdigit assumes
                     78:  *     that "ch" has already been successfully tested by okdigit.
                     79:  */
                     80: 
                     81: static
                     82: valdigit(ch)
                     83: register int ch;
                     84: {
                     85:        return (isdigit(ch) ? ch+0-'0' : ch+0xA-'A');
                     86: }

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