// 
// Decompiled by Procyon v0.6.0
// 

package ch.randelshofer.fastdoubleparser;

import java.util.Map;
import java.math.BigInteger;

final class ParseDigitsTaskCharSequence
{
    private ParseDigitsTaskCharSequence() {
    }
    
    static BigInteger parseDigitsIterative(final CharSequence str, int from, final int to) {
        assert str != null : "str==null";
        final int numDigits = to - from;
        final BigSignificand bigSignificand = new BigSignificand(FastIntegerMath.estimateNumBits(numDigits));
        final int preroll = from + (numDigits & 0x7);
        final int value = FastDoubleSwar.tryToParseUpTo7Digits(str, from, preroll);
        boolean success = value >= 0;
        bigSignificand.add(value);
        int addend;
        for (from = preroll; from < to; from += 8) {
            addend = FastDoubleSwar.tryToParseEightDigits(str, from);
            success &= (addend >= 0);
            bigSignificand.fma(100000000, addend);
        }
        if (!success) {
            throw new NumberFormatException("illegal syntax");
        }
        return bigSignificand.toBigInteger();
    }
    
    static BigInteger parseDigitsRecursive(final CharSequence str, final int from, final int to, final Map<Integer, BigInteger> powersOfTen, final int recursionThreshold) {
        assert str != null : "str==null";
        assert powersOfTen != null : "powersOfTen==null";
        final int numDigits = to - from;
        if (numDigits <= recursionThreshold) {
            return parseDigitsIterative(str, from, to);
        }
        final int mid = FastIntegerMath.splitFloor16(from, to);
        BigInteger high = parseDigitsRecursive(str, from, mid, powersOfTen, recursionThreshold);
        final BigInteger low = parseDigitsRecursive(str, mid, to, powersOfTen, recursionThreshold);
        high = FftMultiplier.multiply(high, powersOfTen.get(to - mid));
        return low.add(high);
    }
}