Subversion Repositories planix.SVN

#include "os.h"
#include <mp.h>
#include "dat.h"

#define between(x,min,max)      (((min-1-x) & (x-max-1))>>8)

static int
dec16chr(int c)
{
        int o;

        o  = between(c, '0', '9') & (1+(c-'0'));
        o |= between(c, 'A', 'F') & (1+10+(c-'A'));
        o |= between(c, 'a', 'f') & (1+10+(c-'a'));
        return o-1;
}

static int
dec32chr(int c)
{
        int o;

        o  = between(c, 'A', 'Z') & (1+(c-'A'));
        o |= between(c, 'a', 'z') & (1+(c-'a'));
        o |= between(c, '2', '7') & (1+26+(c-'2'));
        return o-1;
}

static int
dec64chr(int c)
{
        int o;

        o  = between(c, 'A', 'Z') & (1+(c-'A'));
        o |= between(c, 'a', 'z') & (1+26+(c-'a'));
        o |= between(c, '0', '9') & (1+52+(c-'0'));
        o |= between(c, '+', '+') & (1+62);
        o |= between(c, '/', '/') & (1+63);
        return o-1;
}



static char*
frompow2(char *a, mpint *b, int s)
{
        char *p, *next;
        mpdigit x;
        int i;

        i = 1<<s;
        for(p = a; (dec16chr(*p) & 255) < i; p++)
                ;

        mpbits(b, (p-a)*s);
        b->top = 0;
        next = p;

        while(p > a){
                x = 0;
                for(i = 0; i < Dbits; i += s){
                        if(p <= a)
                                break;
                        x |= dec16chr(*--p)<<i;
                }
                b->p[b->top++] = x;
        }
        return next;
}

static char*
from8(char *a, mpint *b)
{
        char *p, *next;
        mpdigit x, y;
        int i;

        for(p = a; ((*p - '0') & 255) < 8; p++)
                ;

        mpbits(b, (p-a)*3);
        b->top = 0;
        next = p;

        i = 0;
        x = y = 0;
        while(p > a){
                y = *--p - '0';
                x |= y << i;
                i += 3;
                if(i >= Dbits){
Digout:
                        i -= Dbits;
                        b->p[b->top++] = x;
                        x = y >> 3-i;
                }
        }
        if(i > 0)
                goto Digout;

        return next;
}

static ulong mppow10[] = {
        1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000
};

static char*
from10(char *a, mpint *b)
{
        ulong x, y;
        mpint *pow, *r;
        int i;

        pow = mpnew(0);
        r = mpnew(0);

        b->top = 0;
        for(;;){
                // do a billion at a time in native arithmetic
                x = 0;
                for(i = 0; i < 9; i++){
                        y = *a - '0';
                        if(y > 9)
                                break;
                        a++;
                        x *= 10;
                        x += y;
                }
                if(i == 0)
                        break;

                // accumulate into mpint
                uitomp(mppow10[i], pow);
                uitomp(x, r);
                mpmul(b, pow, b);
                mpadd(b, r, b);
                if(i < 9)
                        break;
        }
        mpfree(pow);
        mpfree(r);
        return a;
}

static char*
fromdecx(char *a, mpint *b, int (*chr)(int), int (*dec)(uchar*, int, char*, int))
{
        char *buf = a;
        uchar *p;
        int n, m;

        b->top = 0;
        for(; (*chr)(*a) >= 0; a++)
                ;
        n = a-buf;
        if(n > 0){
                p = malloc(n);
                if(p == nil)
                        sysfatal("malloc: %r");
                m = (*dec)(p, n, buf, n);
                if(m > 0)
                        betomp(p, m, b);
                free(p);
        }
        return a;
}

mpint*
strtomp(char *a, char **pp, int base, mpint *b)
{
        int sign;
        char *e;

        if(b == nil){
                b = mpnew(0);
                setmalloctag(b, getcallerpc(&a));
        }

        while(*a==' ' || *a=='\t')
                a++;

        sign = 1;
        for(;; a++){
                switch(*a){
                case '-':
                        sign *= -1;
                        continue;
                }
                break;
        }

        if(base == 0){
                base = 10;
                if(a[0] == '0'){
                        if(a[1] == 'x' || a[1] == 'X') {
                                a += 2;
                                base = 16;
                        } else if(a[1] == 'b' || a[1] == 'B') {
                                a += 2;
                                base = 2;
                        } else if(a[1] >= '0' && a[1] <= '7') {
                                a++;
                                base = 8;
                        }
                }
        }

        switch(base){
        case 2:
                e = frompow2(a, b, 1);
                break;
        case 4:
                e = frompow2(a, b, 2);
                break;
        case 8:
                e = from8(a, b);
                break;
        case 10:
                e = from10(a, b);
                break;
        case 16:
                e = frompow2(a, b, 4);
                break;
        case 32:
                e = fromdecx(a, b, dec32chr, dec32);
                break;
        case 64:
                e = fromdecx(a, b, dec64chr, dec64);
                break;
        default:
                abort();
                return nil;
        }

        if(pp != nil)
                *pp = e;

        // if no characters parsed, there wasn't a number to convert
        if(e == a)
                return nil;

        b->sign = sign;
        return mpnorm(b);
}