Return to pariCE.c CVS log

Up to [local] / OpenXM_contrib / pari / Odos

Annotation of OpenXM_contrib/pari/Odos/pariCE.c, Revision 1.1.1.1

1.1       maekawa     1: #include <stdlib.h>
                      2: #include <windows.h>
                      3:
                      4:
                      5: int isspace(int c) {
                      6:        if ((c >= 0x09) && (c <= 0x0D)) return 1;
                      7:        else if (c == 0x20) return 1;
                      8:        return 0;
                      9: }
                     10:
                     11: int isdigit(int c) {
                     12:        if ((c >= '0') && (c <= '9')) return 1;
                     13:        else return 0;
                     14: }
                     15:
                     16: int isxdigit(int c) {
                     17:        if ((c >= '0') && (c <= '9')) return 1;
                     18:        else if ((c >= 'a') && (c <= 'f')) return 1;
                     19:        else if ((c >= 'A') && (c <= 'F')) return 1;
                     20:        else return 0;
                     21: }
                     22:
                     23: int isalpha(int c) {
                     24:        if ((c >= 'a') && (c <= 'z')) return 1;
                     25:        else if ((c >= 'A') && (c <= 'Z')) return 1;
                     26:        else return 0;
                     27: }
                     28:
                     29: int isalnum(int c) {
                     30:        if ((c >= '0') && (c <= '9')) return 1;
                     31:        else if ((c >= 'a') && (c <= 'z')) return 1;
                     32:        else if ((c >= 'A') && (c <= 'Z')) return 1;
                     33:        else return 0;
                     34: }
                     35:
                     36: static int checkDigit(char ch, int base) {
                     37:        int n;
                     38:
                     39:        if (ch >= '0' && ch <= '9') n = ch - '0';
                     40:        else if (ch >= 'a' && ch <= 'z') n = ch + 10 - 'a';
                     41:        else if (ch >= 'A' && ch <= 'Z') n = ch + 10 - 'A';
                     42:        else return -1;
                     43:
                     44:        return n >= base ? -1 : n;
                     45: }
                     46:
                     47: long strtol(const char *s, char **endptr, int base) {
                     48:        const char *sc;
                     49:        char sign;
                     50:        int actualbase;
                     51:        double result;
                     52:
                     53:        /* if the base is illegal, then return 0; */
                     54:        if (! (base >= 2 && base <= 36) ){
                     55:                if (endptr) *endptr = (char *)s;
                     56:                return 0;
                     57:        }
                     58:
                     59:        /* skip leading spaces */
                     60:        for (sc = s; *sc == ' '; ++sc);
                     61:
                     62:        /* parse the sign */
                     63:        if (*sc == '-' || *sc == '+') {
                     64:                sign = *sc;
                     65:                sc++;
                     66:        }
                     67:        else {
                     68:                sign = '+';
                     69:        }
                     70:
                     71:        /* the default base = 10 */
                     72:        actualbase = base == 0 ? 10 : base;
                     73:
                     74:        /* if base is undefined, and number starts '0x', then we have base 16 */
                     75:        if (base == 0 && sc[0] == '0' && (sc[1] == 'x' || sc[1] == 'X')) { actualbase = 16; sc += 2; }
                     76:
                     77:        /* else if base is undefined, and number starts '0', then we have base 8 */
                     78:        else if (base == 0 && sc[0] == '0') actualbase = 8;
                     79:
                     80:        /* else if base == 16, then skip any leading '0x' */
                     81:        else if (base == 16 && sc[0] == '0' && (sc[1] == 'x' || sc[1] == 'X')) sc += 2;
                     82:
                     83:        /* skip leading zeroes */
                     84:        for (; *sc == '0'; ++sc);
                     85:
                     86:        /* the result so far is 0. We are going to work with doubles because these give 52 bits of accuracy */
                     87:        result = 0.0;
                     88:
                     89:        /* sc now points to the first unprocessed digit. Keep processing until first non digit or overflow */
                     90:        for (;;) {
                     91:                int d = checkDigit(*sc, actualbase);
                     92:
                     93:                /* if the digit was illegal, then we have terminated */
                     94:                if (d < 0) {
                     95:                        if (endptr) *endptr = (char *)sc;
                     96:                        return sign == '-' ? -(long)result : (long)result;
                     97:                }
                     98:
                     99:                /* roll in the new digit */
                    100:                result = result * actualbase + d;
                    101:
                    102:                /* check for overflow */
                    103:                if (sign == '+' && result > (double)LONG_MAX) {
                    104:                        if (endptr) *endptr = (char *)(sc+1);
                    105:                        return LONG_MAX;
                    106:                }
                    107:                if (sign == '-' && result > -(double)LONG_MIN) {
                    108:                        if (endptr) *endptr = (char *)(sc+1);
                    109:                        return LONG_MIN;
                    110:                }
                    111:
                    112:                /* go on to the next character */
                    113:                sc++;
                    114:        }
                    115: }
                    116:
                    117: /*
                    118:  *  Implement rename and unlink in win32 procedures. This is complicated
                    119:  *  by the fact that these procedures take wide chars.
                    120:  */
                    121:
                    122: #define MAX_FILENAME_LEN           128
                    123:
                    124: int rename(const char *oldname, const char *newname) {
                    125:        int succ;
                    126:        short soldname[MAX_FILENAME_LEN];
                    127:        short snewname[MAX_FILENAME_LEN];
                    128:
                    129:        MultiByteToWideChar(CP_ACP, 0, oldname, strlen(oldname)+1, soldname, MAX_FILENAME_LEN);
                    130:        MultiByteToWideChar(CP_ACP, 0, newname, strlen(newname)+1, snewname, MAX_FILENAME_LEN);
                    131:        succ = MoveFile(soldname, snewname);
                    132:        return !succ;
                    133: }
                    134:
                    135: int unlink(char *name) {
                    136:        int succ;
                    137:        short wname[MAX_FILENAME_LEN];
                    138:
                    139:        MultiByteToWideChar(CP_ACP, 0, name, strlen(name)+1, wname, MAX_FILENAME_LEN);
                    140:
                    141:        succ = DeleteFile(wname);
                    142:        return !succ;
                    143: }
                    144:
                    145: void *calloc(size_t nelem, size_t size) {
                    146:        const size_t n = nelem*size;
                    147:        char *p = malloc(n);
                    148:
                    149:        if (p) memset(p, '\0', n);
                    150:        return p;
                    151: }