Return to myatol.c CVS log

Up to [MW Coherent from dump] / coherent / b / conf / patch

Annotation of coherent/b/conf/patch/myatol.c, revision 1.1.1.1

1.1       root        1: /**
                      2:  *
                      3:  * long
                      4:  * myatol( s )         -- Ascii to Long integer conversion.
                      5:  * char * s;
                      6:  *
                      7:  *     Input:  s = pointer to string containing a numeric prefix.
                      8:  *
                      9:  *     Action: Parse input string.
                     10:  *             Parse optional leading sign character '-'.
                     11:  *             Parse optional numeric base specification '0', '0o', and '0x'.
                     12:  *             Parse following numeric digits.
                     13:  *
                     14:  *     Return: Long integer value.
                     15:  *
                     16:  *     Notes:  Numeric parsing terminates on first non-digit.
                     17:  */
                     18: long
                     19: myatol( s )
                     20:        register char * s;
                     21: {
                     22:        register int base;
                     23:        register int sign;
                     24:        auto    long valu;
                     25: 
                     26:        /*
                     27:         * Check for leading negative sign.
                     28:         */
                     29:        sign = 1;
                     30:        if ( *s == '-' ) {
                     31:                sign = -1;
                     32:                s++;
                     33:        }
                     34: 
                     35:        /*
                     36:         * Check for base specification.
                     37:         */
                     38:        base = 10;
                     39:        if ( *s == '0' ) {
                     40:                switch ( *++s ) {
                     41:                case 'x':       base = 16;      ++s;    break;
                     42:                case 'o':       base =  8;      ++s;    break;
                     43:                default:        base =  8;
                     44:                }
                     45:        }
                     46: 
                     47:        for ( valu = 0L; *s != '\0'; s++ ) {
                     48: 
                     49:                /*
                     50:                 * Decimal digit.
                     51:                 */
                     52:                if ( ('0' <= *s) && (*s <= '9') ) {
                     53:                        valu *= base;
                     54:                        valu += *s - '0';
                     55:                }
                     56: 
                     57:                /*
                     58:                 * Upper case hex digit.
                     59:                 */
                     60:                else if ( (base == 16) && ('A' <= *s) && (*s <= 'F') ) {
                     61:                        valu *= base;
                     62:                        valu += *s - ('A' - 10);
                     63:                }
                     64: 
                     65:                /*
                     66:                 * Lower case Hex digit.
                     67:                 */
                     68:                else if ( (base == 16) && ('a' <= *s) && (*s <= 'f') ) {
                     69:                        valu *= base;
                     70:                        valu += *s - ('a' - 10);
                     71:                }
                     72: 
                     73:                /*
                     74:                 * Not a digit.
                     75:                 */
                     76:                else
                     77:                        break;
                     78:        }
                     79: 
                     80:        if ( sign < 0 )
                     81:                valu = -valu;
                     82: 
                     83:        return valu;
                     84: }

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